xref: /titanic_52/usr/src/lib/krb5/kadm5/kadm_rpc_xdr.c (revision 587644a8567e6a9533f88401daa59cbd78c4632f)
1 /*
2  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 
7 /*
8  * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
9  *
10  *	Openvision retains the copyright to derivative works of
11  *	this source code.  Do *NOT* create a derivative of this
12  *	source code before consulting with your legal department.
13  *	Do *NOT* integrate *ANY* of this source code into another
14  *	product before consulting with your legal department.
15  *
16  *	For further information, read the top-level Openvision
17  *	copyright which is contained in the top-level MIT Kerberos
18  *	copyright.
19  *
20  * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
21  *
22  */
23 
24 
25 /*
26  * Copyright 1993 OpenVision Technologies, Inc., All Rights Reserved
27  */
28 
29 #include <rpc/rpc.h>
30 #include <errno.h>
31 #include <kadm5/admin.h>
32 #include <kadm5/kadm_rpc.h>
33 #include <krb5.h>
34 #include <stdlib.h>
35 #include <string.h>
36 
37 static bool_t
38 _xdr_kadm5_principal_ent_rec(XDR *xdrs, kadm5_principal_ent_rec *objp,
39 			     int v);
40 
41 bool_t
42 xdr_krb5_salttype(XDR *xdrs, krb5_int32 *objp); /* SUNWresync121 XXX */
43 /*
44  * Function: xdr_ui_4
45  *
46  * Purpose: XDR function which serves as a wrapper for xdr_u_int,
47  * to prevent compiler warnings about type clashes between u_int32
48  * and krb5_ui_4.
49  */
50 bool_t xdr_ui_4(XDR *xdrs, krb5_ui_4 *objp)
51 {
52   /* Assumes that krb5_ui_4 and u_int32 are both four bytes long.
53      This should not be a harmful assumption. */
54   return xdr_u_int(xdrs, (uint32_t *) objp);
55 }
56 
57 
58 /*
59  * Function: xdr_nullstring
60  *
61  * Purpose: XDR function for "strings" that are either NULL-terminated
62  * or NULL.
63  */
64 bool_t xdr_nullstring(XDR *xdrs, char **objp)
65 {
66      u_int size;
67 
68      if (xdrs->x_op == XDR_ENCODE) {
69 	  if (*objp == NULL)
70 	       size = 0;
71 	  else
72 	       size = strlen(*objp) + 1;
73      }
74      if (! xdr_u_int(xdrs, &size)) {
75 	  return FALSE;
76 	}
77      switch (xdrs->x_op) {
78      case XDR_DECODE:
79 	  if (size == 0) {
80 	       *objp = NULL;
81 	       return TRUE;
82 	  } else if (*objp == NULL) {
83 	       *objp = (char *) mem_alloc(size);
84 	       if (*objp == NULL) {
85 		    errno = ENOMEM;
86 		    return FALSE;
87 	       }
88 	  }
89 	  return (xdr_opaque(xdrs, *objp, size));
90 
91      case XDR_ENCODE:
92 	  if (size != 0)
93 	       return (xdr_opaque(xdrs, *objp, size));
94 	  return TRUE;
95 
96      case XDR_FREE:
97 	  if (*objp != NULL)
98 	       mem_free(*objp, size);
99 	  *objp = NULL;
100 	  return TRUE;
101      }
102 
103      return FALSE;
104 }
105 
106 /*
107  * Function: xdr_nulltype
108  *
109  * Purpose: XDR function for arbitrary pointer types that are either
110  * NULL or contain data.
111  */
112 bool_t xdr_nulltype(XDR *xdrs, void **objp, xdrproc_t proc)
113 {
114      bool_t null;
115 
116      switch (xdrs->x_op) {
117      case XDR_DECODE:
118 	  if (!xdr_bool(xdrs, &null))
119 	      return FALSE;
120 	  if (null) {
121 	       *objp = NULL;
122 	       return TRUE;
123 	  }
124 	  return (*proc)(xdrs, objp);
125 
126      case XDR_ENCODE:
127 	  if (*objp == NULL)
128 	       null = TRUE;
129 	  else
130 	       null = FALSE;
131 	  if (!xdr_bool(xdrs, &null))
132 	       return FALSE;
133 	  if (null == FALSE)
134 	       return (*proc)(xdrs, objp);
135 	  return TRUE;
136 
137      case XDR_FREE:
138 	  if (*objp)
139 	       return (*proc)(xdrs, objp);
140 	  return TRUE;
141      }
142 
143      return FALSE;
144 }
145 
146 bool_t
147 xdr_krb5_timestamp(XDR *xdrs, krb5_timestamp *objp)
148 {
149   /* This assumes that int32 and krb5_timestamp are the same size.
150      This shouldn't be a problem, since we've got a unit test which
151      checks for this. */
152 	if (!xdr_int(xdrs, (int32_t *) objp)) {
153 		return (FALSE);
154 	}
155 	return (TRUE);
156 }
157 
158 bool_t
159 xdr_krb5_kvno(XDR *xdrs, krb5_kvno *objp)
160 {
161 	unsigned char tmp;
162 
163 	tmp = '\0'; /* for purify, else xdr_u_char performs a umr */
164 
165 	if (xdrs->x_op == XDR_ENCODE)
166 		tmp = (unsigned char) *objp;
167 
168 	if (!xdr_u_char(xdrs, &tmp))
169 		return (FALSE);
170 
171 	if (xdrs->x_op == XDR_DECODE)
172 		*objp = (krb5_kvno) tmp;
173 
174 	return (TRUE);
175 }
176 
177 bool_t
178 xdr_krb5_deltat(XDR *xdrs, krb5_deltat *objp)
179 {
180   /* This assumes that int32 and krb5_deltat are the same size.
181      This shouldn't be a problem, since we've got a unit test which
182      checks for this. */
183 	if (!xdr_int(xdrs, (int32_t *) objp)) {
184 		return (FALSE);
185 	}
186 	return (TRUE);
187 }
188 
189 bool_t
190 xdr_krb5_flags(XDR *xdrs, krb5_flags *objp)
191 {
192   /* This assumes that int32 and krb5_flags are the same size.
193      This shouldn't be a problem, since we've got a unit test which
194      checks for this. */
195 	if (!xdr_int(xdrs, (int32_t *) objp)) {
196 		return (FALSE);
197 	}
198 	return (TRUE);
199 }
200 
201 bool_t
202 xdr_krb5_ui_4(XDR *xdrs, krb5_ui_4 *objp)
203 {
204 	if (!xdr_u_int(xdrs, (uint32_t *) objp)) {
205 		return (FALSE);
206 	}
207 	return (TRUE);
208 }
209 
210 bool_t
211 xdr_krb5_int16(XDR *xdrs, krb5_int16 *objp)
212 {
213     int tmp;
214 
215     tmp = (int) *objp;
216 
217     if (!xdr_int(xdrs, &tmp))
218 	return(FALSE);
219 
220     *objp = (krb5_int16) tmp;
221 
222     return(TRUE);
223 }
224 
225 /*
226  * Function: xdr_krb5_ui_2
227  *
228  * Purpose: XDR function which serves as a wrapper for xdr_u_int,
229  * to prevent compiler warnings about type clashes between u_int
230  * and krb5_ui_2.
231  */
232 bool_t
233 xdr_krb5_ui_2(XDR *xdrs, krb5_ui_2 *objp)
234 {
235     unsigned int tmp;
236 
237     tmp = (unsigned int) *objp;
238 
239     if (!xdr_u_int(xdrs, &tmp))
240 	return(FALSE);
241 
242     *objp = (krb5_ui_2) tmp;
243 
244     return(TRUE);
245 }
246 
247 
248 
249 bool_t xdr_krb5_key_data_nocontents(XDR *xdrs, krb5_key_data *objp)
250 {
251      /*
252       * Note that this function intentionally DOES NOT tranfer key
253       * length or contents!  xdr_krb5_key_data in adb_xdr.c does, but
254       * that is only for use within the server-side library.
255       */
256      unsigned int tmp;
257 
258      if (xdrs->x_op == XDR_DECODE)
259 	  memset((char *) objp, 0, sizeof(krb5_key_data));
260 
261      if (!xdr_krb5_int16(xdrs, &objp->key_data_ver)) {
262 	  return (FALSE);
263      }
264      if (!xdr_krb5_int16(xdrs, &objp->key_data_kvno)) {
265 	  return (FALSE);
266      }
267      if (!xdr_krb5_int16(xdrs, &objp->key_data_type[0])) {
268 	  return (FALSE);
269      }
270      if (objp->key_data_ver > 1) {
271 	  if (!xdr_krb5_int16(xdrs, &objp->key_data_type[1])) {
272 	       return (FALSE);
273 	  }
274      }
275      /*
276       * kadm5_get_principal on the server side allocates and returns
277       * key contents when asked.  Even though this function refuses to
278       * transmit that data, it still has to *free* the data at the
279       * appropriate time to avoid a memory leak.
280       */
281      if (xdrs->x_op == XDR_FREE) {
282 	  tmp = (unsigned int) objp->key_data_length[0];
283 	  if (!xdr_bytes(xdrs, (char **) &objp->key_data_contents[0],
284 			 &tmp, ~0))
285 	       return FALSE;
286 
287 	  tmp = (unsigned int) objp->key_data_length[1];
288 	  if (!xdr_bytes(xdrs, (char **) &objp->key_data_contents[1],
289 			 &tmp, ~0))
290 	       return FALSE;
291      }
292 
293      return (TRUE);
294 }
295 
296 
297 bool_t
298 xdr_krb5_key_salt_tuple(XDR *xdrs, krb5_key_salt_tuple *objp)
299 {
300     if (!xdr_krb5_enctype(xdrs, &objp->ks_enctype))
301 	return FALSE;
302     if (!xdr_krb5_salttype(xdrs, &objp->ks_salttype))
303 	return FALSE;
304     return TRUE;
305 }
306 
307 bool_t xdr_krb5_tl_data(XDR *xdrs, krb5_tl_data **tl_data_head)
308 {
309      krb5_tl_data *tl, *tl2;
310      bool_t more;
311      unsigned int len;
312 
313      switch (xdrs->x_op) {
314      case XDR_FREE:
315 	  tl = tl2 = *tl_data_head;
316 	  while (tl) {
317 	       tl2 = tl->tl_data_next;
318 	       free(tl->tl_data_contents);
319 	       free(tl);
320 	       tl = tl2;
321 	  }
322 	  break;
323 
324      case XDR_ENCODE:
325 	  tl = *tl_data_head;
326 	  while (1) {
327 	       more = (tl != NULL);
328 	       if (!xdr_bool(xdrs, &more))
329 		    return FALSE;
330 	       if (tl == NULL)
331 		    break;
332 	       if (!xdr_krb5_int16(xdrs, &tl->tl_data_type))
333 		    return FALSE;
334 	       len = tl->tl_data_length;
335 	       if (!xdr_bytes(xdrs, (char **) &tl->tl_data_contents, &len, ~0))
336 		    return FALSE;
337 	       tl = tl->tl_data_next;
338 	  }
339 	  break;
340 
341      case XDR_DECODE:
342 	  tl = NULL;
343 	  while (1) {
344 	       if (!xdr_bool(xdrs, &more))
345 		    return FALSE;
346 	       if (more == FALSE)
347 		    break;
348 	       tl2 = (krb5_tl_data *) malloc(sizeof(krb5_tl_data));
349 	       if (tl2 == NULL)
350 		    return FALSE;
351 	       memset((char *) tl2, 0, sizeof(krb5_tl_data));
352 	       if (!xdr_krb5_int16(xdrs, &tl2->tl_data_type))
353 		    return FALSE;
354 	       if (!xdr_bytes(xdrs, (char **)&tl2->tl_data_contents, &len, ~0))
355 		    return FALSE;
356 	       tl2->tl_data_length = len;
357 
358 	       tl2->tl_data_next = tl;
359 	       tl = tl2;
360 	  }
361 
362 	  *tl_data_head = tl;
363 	  break;
364      }
365 
366      return TRUE;
367 }
368 
369 bool_t
370 xdr_kadm5_ret_t(XDR *xdrs, kadm5_ret_t *objp)
371 {
372 	uint32_t tmp;
373 
374 	if (xdrs->x_op == XDR_ENCODE)
375 		tmp = (uint32_t) *objp;
376 
377 	if (!xdr_u_int(xdrs, &tmp))
378 		return (FALSE);
379 
380 	if (xdrs->x_op == XDR_DECODE)
381 		*objp = (kadm5_ret_t) tmp;
382 
383 	return (TRUE);
384 }
385 
386 bool_t xdr_kadm5_principal_ent_rec_v1(XDR *xdrs,
387 				      kadm5_principal_ent_rec *objp)
388 {
389      return _xdr_kadm5_principal_ent_rec(xdrs, objp, KADM5_API_VERSION_1);
390 }
391 
392 bool_t xdr_kadm5_principal_ent_rec(XDR *xdrs,
393 				   kadm5_principal_ent_rec *objp)
394 {
395      return _xdr_kadm5_principal_ent_rec(xdrs, objp, KADM5_API_VERSION_2);
396 }
397 
398 static bool_t
399 _xdr_kadm5_principal_ent_rec(XDR *xdrs, kadm5_principal_ent_rec *objp,
400 			     int v)
401 {
402      unsigned int n;
403 
404 	if (!xdr_krb5_principal(xdrs, &objp->principal)) {
405 		return (FALSE);
406 	}
407 	if (!xdr_krb5_timestamp(xdrs, &objp->princ_expire_time)) {
408 		return (FALSE);
409 	}
410 	if (!xdr_krb5_timestamp(xdrs, &objp->last_pwd_change)) {
411 		return (FALSE);
412 	}
413 	if (!xdr_krb5_timestamp(xdrs, &objp->pw_expiration)) {
414 		return (FALSE);
415 	}
416 	if (!xdr_krb5_deltat(xdrs, &objp->max_life)) {
417 		return (FALSE);
418 	}
419         if (v == KADM5_API_VERSION_1) {
420 	     if (!xdr_krb5_principal(xdrs, &objp->mod_name)) {
421 		  return (FALSE);
422 	     }
423 	} else {
424 	     if (!xdr_nulltype(xdrs, (void **) &objp->mod_name,
425 			       xdr_krb5_principal)) {
426 		  return (FALSE);
427 	     }
428 	}
429 	if (!xdr_krb5_timestamp(xdrs, &objp->mod_date)) {
430 		return (FALSE);
431 	}
432 	if (!xdr_krb5_flags(xdrs, &objp->attributes)) {
433 		return (FALSE);
434 	}
435 	if (!xdr_krb5_kvno(xdrs, &objp->kvno)) {
436 		return (FALSE);
437 	}
438 	if (!xdr_krb5_kvno(xdrs, &objp->mkvno)) {
439 		return (FALSE);
440 	}
441 	if (!xdr_nullstring(xdrs, &objp->policy)) {
442 		return (FALSE);
443 	}
444 	if (!xdr_long(xdrs, &objp->aux_attributes)) {
445 		return (FALSE);
446 	}
447 	if (v != KADM5_API_VERSION_1) {
448 	     if (!xdr_krb5_deltat(xdrs, &objp->max_renewable_life)) {
449 		  return (FALSE);
450 	     }
451 	     if (!xdr_krb5_timestamp(xdrs, &objp->last_success)) {
452 		  return (FALSE);
453 	     }
454 	     if (!xdr_krb5_timestamp(xdrs, &objp->last_failed)) {
455 		  return (FALSE);
456 	     }
457 	     if (!xdr_krb5_kvno(xdrs, &objp->fail_auth_count)) {
458 		  return (FALSE);
459 	     }
460 	     if (!xdr_krb5_int16(xdrs, &objp->n_key_data)) {
461 		  return (FALSE);
462 	     }
463 	     if (!xdr_krb5_int16(xdrs, &objp->n_tl_data)) {
464 		  return (FALSE);
465 	     }
466 	     if (!xdr_nulltype(xdrs, (void **) &objp->tl_data,
467 			       xdr_krb5_tl_data)) {
468 		  return FALSE;
469 	     }
470 	     n = objp->n_key_data;
471 	     if (!xdr_array(xdrs, (caddr_t *) &objp->key_data,
472 			    &n, ~0, sizeof(krb5_key_data),
473 			    xdr_krb5_key_data_nocontents)) {
474 		  return (FALSE);
475 	     }
476 	}
477 	return (TRUE);
478 }
479 
480 bool_t
481 xdr_kadm5_policy_ent_rec(XDR *xdrs, kadm5_policy_ent_rec *objp)
482 {
483 	if (!xdr_nullstring(xdrs, &objp->policy)) {
484 		return (FALSE);
485 	}
486 	/* these all used to be u_int32, but it's stupid for sized types
487 	   to be exposed at the api, and they're the same as longs on the
488 	   wire. */
489 	if (!xdr_long(xdrs, &objp->pw_min_life)) {
490 		return (FALSE);
491 	}
492 	if (!xdr_long(xdrs, &objp->pw_max_life)) {
493 		return (FALSE);
494 	}
495 	if (!xdr_long(xdrs, &objp->pw_min_length)) {
496 		return (FALSE);
497 	}
498 	if (!xdr_long(xdrs, &objp->pw_min_classes)) {
499 		return (FALSE);
500 	}
501 	if (!xdr_long(xdrs, &objp->pw_history_num)) {
502 		return (FALSE);
503 	}
504 	if (!xdr_long(xdrs, &objp->policy_refcnt)) {
505 		return (FALSE);
506 	}
507 	return (TRUE);
508 }
509 
510 bool_t
511 xdr_cprinc_arg(XDR *xdrs, cprinc_arg *objp)
512 {
513 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
514 		return (FALSE);
515 	}
516 	if (objp->api_version == KADM5_API_VERSION_1) {
517 	     if (!xdr_kadm5_principal_ent_rec_v1(xdrs, &objp->rec)) {
518 		  return (FALSE);
519 	     }
520 	} else {
521 	     if (!xdr_kadm5_principal_ent_rec(xdrs, &objp->rec)) {
522 		  return (FALSE);
523 	     }
524 	}
525 	if (!xdr_long(xdrs, &objp->mask)) {
526 		return (FALSE);
527 	}
528 	if (!xdr_nullstring(xdrs, &objp->passwd)) {
529 		return (FALSE);
530 	}
531 	return (TRUE);
532 }
533 
534 bool_t
535 xdr_cprinc3_arg(XDR *xdrs, cprinc3_arg *objp)
536 {
537 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
538 		return (FALSE);
539 	}
540 	if (objp->api_version == KADM5_API_VERSION_1) {
541 		if (!xdr_kadm5_principal_ent_rec_v1(xdrs, &objp->rec)) {
542 			return (FALSE);
543 		}
544 	} else {
545 		if (!xdr_kadm5_principal_ent_rec(xdrs, &objp->rec)) {
546 			return (FALSE);
547 		}
548 	}
549 	if (!xdr_long(xdrs, &objp->mask)) {
550 		return (FALSE);
551 	}
552 	if (!xdr_array(xdrs, (caddr_t *)&objp->ks_tuple,
553 		       (unsigned int *)&objp->n_ks_tuple, ~0,
554 		       sizeof(krb5_key_salt_tuple),
555 		       xdr_krb5_key_salt_tuple)) {
556 		return (FALSE);
557 	}
558 	if (!xdr_nullstring(xdrs, &objp->passwd)) {
559 		return (FALSE);
560 	}
561 	return (TRUE);
562 }
563 
564 bool_t
565 xdr_generic_ret(XDR *xdrs, generic_ret *objp)
566 {
567 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
568 		return (FALSE);
569 	}
570 	if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
571 		return (FALSE);
572 	}
573 
574 	return(TRUE);
575 }
576 
577 bool_t
578 xdr_dprinc_arg(XDR *xdrs, dprinc_arg *objp)
579 {
580 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
581 		return (FALSE);
582 	}
583 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
584 		return (FALSE);
585 	}
586 	return (TRUE);
587 }
588 
589 bool_t
590 xdr_mprinc_arg(XDR *xdrs, mprinc_arg *objp)
591 {
592 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
593 		return (FALSE);
594 	}
595 	if (objp->api_version == KADM5_API_VERSION_1) {
596 	     if (!xdr_kadm5_principal_ent_rec_v1(xdrs, &objp->rec)) {
597 		  return (FALSE);
598 	     }
599 	} else {
600 	     if (!xdr_kadm5_principal_ent_rec(xdrs, &objp->rec)) {
601 		  return (FALSE);
602 	     }
603 	}
604 	if (!xdr_long(xdrs, &objp->mask)) {
605 		return (FALSE);
606 	}
607 	return (TRUE);
608 }
609 
610 bool_t
611 xdr_rprinc_arg(XDR *xdrs, rprinc_arg *objp)
612 {
613 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
614 		return (FALSE);
615 	}
616 	if (!xdr_krb5_principal(xdrs, &objp->src)) {
617 		return (FALSE);
618 	}
619 	if (!xdr_krb5_principal(xdrs, &objp->dest)) {
620 		return (FALSE);
621 	}
622 	return (TRUE);
623 }
624 
625 bool_t
626 xdr_gprincs_arg(XDR *xdrs, gprincs_arg *objp)
627 {
628      if (!xdr_ui_4(xdrs, &objp->api_version)) {
629 	  return (FALSE);
630      }
631      if (!xdr_nullstring(xdrs, &objp->exp)) {
632 	  return (FALSE);
633      }
634      return (TRUE);
635 }
636 
637 bool_t
638 xdr_gprincs_ret(XDR *xdrs, gprincs_ret *objp)
639 {
640      if (!xdr_ui_4(xdrs, &objp->api_version)) {
641 	  return (FALSE);
642      }
643      if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
644 	  return (FALSE);
645      }
646      if (objp->code == KADM5_OK) {
647 	  if (!xdr_int(xdrs, &objp->count)) {
648 	       return (FALSE);
649 	  }
650 	  if (!xdr_array(xdrs, (caddr_t *) &objp->princs,
651 			 (unsigned int *) &objp->count, ~0,
652 			 sizeof(char *), xdr_nullstring)) {
653 	       return (FALSE);
654 	  }
655      }
656 
657      return (TRUE);
658 }
659 
660 bool_t
661 xdr_chpass_arg(XDR *xdrs, chpass_arg *objp)
662 {
663 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
664 		return (FALSE);
665 	}
666 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
667 		return (FALSE);
668 	}
669 	if (!xdr_nullstring(xdrs, &objp->pass)) {
670 		return (FALSE);
671 	}
672 	return (TRUE);
673 }
674 
675 bool_t
676 xdr_chpass3_arg(XDR *xdrs, chpass3_arg *objp)
677 {
678 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
679 		return (FALSE);
680 	}
681 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
682 		return (FALSE);
683 	}
684 	if (!xdr_bool(xdrs, (bool_t *) &objp->keepold)) { /* SUNWresync121 XXX */
685 		return (FALSE);
686 	}
687 	if (!xdr_array(xdrs, (caddr_t *)&objp->ks_tuple,
688 		       (unsigned int*)&objp->n_ks_tuple, ~0,
689 		       sizeof(krb5_key_salt_tuple),
690 		       xdr_krb5_key_salt_tuple)) {
691 		return (FALSE);
692 	}
693 	if (!xdr_nullstring(xdrs, &objp->pass)) {
694 		return (FALSE);
695 	}
696 	return (TRUE);
697 }
698 
699 bool_t
700 xdr_setv4key_arg(XDR *xdrs, setv4key_arg *objp)
701 {
702 	unsigned int n_keys = 1;
703 
704 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
705 		return (FALSE);
706 	}
707 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
708 		return (FALSE);
709 	}
710 	if (!xdr_array(xdrs, (caddr_t *) &objp->keyblock,
711 		       &n_keys, ~0,
712 		       sizeof(krb5_keyblock), xdr_krb5_keyblock)) {
713 	        return (FALSE);
714 	}
715 	return (TRUE);
716 }
717 
718 bool_t
719 xdr_setkey_arg(XDR *xdrs, setkey_arg *objp)
720 {
721 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
722 		return (FALSE);
723 	}
724 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
725 		return (FALSE);
726 	}
727 	if (!xdr_array(xdrs, (caddr_t *) &objp->keyblocks,
728 		       (unsigned int *) &objp->n_keys, ~0,
729 		       sizeof(krb5_keyblock), xdr_krb5_keyblock)) {
730 	        return (FALSE);
731 	}
732 	return (TRUE);
733 }
734 
735 bool_t
736 xdr_setkey3_arg(XDR *xdrs, setkey3_arg *objp)
737 {
738 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
739 		return (FALSE);
740 	}
741 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
742 		return (FALSE);
743 	}
744 	if (!xdr_bool(xdrs, (bool_t *) &objp->keepold)) { /* SUNWresync121 XXX */
745 		return (FALSE);
746 	}
747 	if (!xdr_array(xdrs, (caddr_t *) &objp->ks_tuple,
748 		       (unsigned int *) &objp->n_ks_tuple, ~0,
749 		       sizeof(krb5_key_salt_tuple), xdr_krb5_key_salt_tuple)) {
750 		return (FALSE);
751 	}
752 	if (!xdr_array(xdrs, (caddr_t *) &objp->keyblocks,
753 		       (unsigned int *) &objp->n_keys, ~0,
754 		       sizeof(krb5_keyblock), xdr_krb5_keyblock)) {
755 		return (FALSE);
756 	}
757 	return (TRUE);
758 }
759 
760 bool_t
761 xdr_chrand_arg(XDR *xdrs, chrand_arg *objp)
762 {
763 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
764 		return (FALSE);
765 	}
766 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
767 		return (FALSE);
768 	}
769 	return (TRUE);
770 }
771 
772 bool_t
773 xdr_chrand3_arg(XDR *xdrs, chrand3_arg *objp)
774 {
775 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
776 		return (FALSE);
777 	}
778 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
779 		return (FALSE);
780 	}
781 	if (!xdr_bool(xdrs, (bool_t *) &objp->keepold)) { /* SUNWresync121 XXX */
782 		return (FALSE);
783 	}
784 	if (!xdr_array(xdrs, (caddr_t *)&objp->ks_tuple,
785 		       (unsigned int*)&objp->n_ks_tuple, ~0,
786 		       sizeof(krb5_key_salt_tuple),
787 		       xdr_krb5_key_salt_tuple)) {
788 		return (FALSE);
789 	}
790 	return (TRUE);
791 }
792 
793 bool_t
794 xdr_chrand_ret(XDR *xdrs, chrand_ret *objp)
795 {
796 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
797 		return (FALSE);
798 	}
799 	if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
800 		return (FALSE);
801 	}
802 	if (objp->api_version == KADM5_API_VERSION_1) {
803 	     if(objp->code == KADM5_OK) {
804 		  if (!xdr_krb5_keyblock(xdrs, &objp->key)) {
805 		       return (FALSE);
806 		  }
807 	     }
808 	} else {
809 	     if (objp->code == KADM5_OK) {
810 		  if (!xdr_array(xdrs, (char **)&objp->keys, (unsigned int *)&objp->n_keys, ~0,
811 				 sizeof(krb5_keyblock),
812 				 xdr_krb5_keyblock))
813 		       return FALSE;
814 	     }
815 	}
816 
817 	return (TRUE);
818 }
819 
820 bool_t
821 xdr_gprinc_arg(XDR *xdrs, gprinc_arg *objp)
822 {
823 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
824 		return (FALSE);
825 	}
826 	if (!xdr_krb5_principal(xdrs, &objp->princ)) {
827 		return (FALSE);
828 	}
829 	if ((objp->api_version > KADM5_API_VERSION_1) &&
830 	    !xdr_long(xdrs, &objp->mask)) {
831 	     return FALSE;
832 	}
833 
834 	return (TRUE);
835 }
836 
837 bool_t
838 xdr_gprinc_ret(XDR *xdrs, gprinc_ret *objp)
839 {
840 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
841 		return (FALSE);
842 	}
843 	if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
844 		return (FALSE);
845 	}
846 	if(objp->code == KADM5_OK)  {
847 	     if (objp->api_version == KADM5_API_VERSION_1) {
848 		  if (!xdr_kadm5_principal_ent_rec_v1(xdrs, &objp->rec)) {
849 		       return (FALSE);
850 		  }
851 	     } else {
852 		  if (!xdr_kadm5_principal_ent_rec(xdrs, &objp->rec)) {
853 		       return (FALSE);
854 		  }
855 	     }
856 	}
857 
858 	return (TRUE);
859 }
860 
861 bool_t
862 xdr_cpol_arg(XDR *xdrs, cpol_arg *objp)
863 {
864 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
865 		return (FALSE);
866 	}
867 	if (!xdr_kadm5_policy_ent_rec(xdrs, &objp->rec)) {
868 		return (FALSE);
869 	}
870 	if (!xdr_long(xdrs, &objp->mask)) {
871 		return (FALSE);
872 	}
873 	return (TRUE);
874 }
875 
876 bool_t
877 xdr_dpol_arg(XDR *xdrs, dpol_arg *objp)
878 {
879 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
880 		return (FALSE);
881 	}
882 	if (!xdr_nullstring(xdrs, &objp->name)) {
883 		return (FALSE);
884 	}
885 	return (TRUE);
886 }
887 
888 bool_t
889 xdr_mpol_arg(XDR *xdrs, mpol_arg *objp)
890 {
891 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
892 		return (FALSE);
893 	}
894 	if (!xdr_kadm5_policy_ent_rec(xdrs, &objp->rec)) {
895 		return (FALSE);
896 	}
897 	if (!xdr_long(xdrs, &objp->mask)) {
898 		return (FALSE);
899 	}
900 	return (TRUE);
901 }
902 
903 bool_t
904 xdr_gpol_arg(XDR *xdrs, gpol_arg *objp)
905 {
906 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
907 		return (FALSE);
908 	}
909 	if (!xdr_nullstring(xdrs, &objp->name)) {
910 		return (FALSE);
911 	}
912 	return (TRUE);
913 }
914 
915 bool_t
916 xdr_gpol_ret(XDR *xdrs, gpol_ret *objp)
917 {
918 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
919 		return (FALSE);
920 	}
921 	if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
922 		return (FALSE);
923 	}
924 	if(objp->code == KADM5_OK) {
925 	    if (!xdr_kadm5_policy_ent_rec(xdrs, &objp->rec))
926 		return (FALSE);
927 	}
928 
929 	return (TRUE);
930 }
931 
932 bool_t
933 xdr_gpols_arg(XDR *xdrs, gpols_arg *objp)
934 {
935      if (!xdr_ui_4(xdrs, &objp->api_version)) {
936 	  return (FALSE);
937      }
938      if (!xdr_nullstring(xdrs, &objp->exp)) {
939 	  return (FALSE);
940      }
941      return (TRUE);
942 }
943 
944 bool_t
945 xdr_gpols_ret(XDR *xdrs, gpols_ret *objp)
946 {
947      if (!xdr_ui_4(xdrs, &objp->api_version)) {
948 	  return (FALSE);
949      }
950      if (!xdr_kadm5_ret_t(xdrs, &objp->code)) {
951 	  return (FALSE);
952      }
953      if (objp->code == KADM5_OK) {
954 	  if (!xdr_int(xdrs, &objp->count)) {
955 	       return (FALSE);
956 	  }
957 	  if (!xdr_array(xdrs, (caddr_t *) &objp->pols,
958 			 (unsigned int *) &objp->count, ~0,
959 			 sizeof(char *), xdr_nullstring)) {
960 	       return (FALSE);
961 	  }
962      }
963 
964      return (TRUE);
965 }
966 
967 bool_t xdr_getprivs_ret(XDR *xdrs, getprivs_ret *objp)
968 {
969 	if (!xdr_ui_4(xdrs, &objp->api_version)) {
970 		return (FALSE);
971 	}
972      if (! xdr_kadm5_ret_t(xdrs, &objp->code) ||
973 	 ! xdr_long(xdrs, &objp->privs))
974 	  return FALSE;
975 
976      return TRUE;
977 }
978 
979 bool_t
980 xdr_krb5_principal(XDR *xdrs, krb5_principal *objp)
981 {
982     int	    ret;
983     char	    *p = NULL;
984     krb5_principal  pr = NULL;
985     static krb5_context context = NULL;
986 
987     /* using a static context here is ugly, but should work
988        ok, and the other solutions are even uglier */
989 
990     if (!context &&
991 	kadm5_init_krb5_context(&context))
992        return(FALSE);
993 
994     switch(xdrs->x_op) {
995     case XDR_ENCODE:
996 	if (*objp) {
997 	     if((ret = krb5_unparse_name(context, *objp, &p)) != 0)
998 		  return FALSE;
999 	}
1000 	if(!xdr_nullstring(xdrs, &p))
1001 	    return FALSE;
1002 	if (p) free(p);
1003 	break;
1004     case XDR_DECODE:
1005 	if(!xdr_nullstring(xdrs, &p))
1006 	    return FALSE;
1007 	if (p) {
1008 	     ret = krb5_parse_name(context, p, &pr);
1009 	     if(ret != 0)
1010 		  return FALSE;
1011 	     *objp = pr;
1012 	     free(p);
1013 	} else
1014 	     *objp = NULL;
1015 	break;
1016     case XDR_FREE:
1017 	if(*objp != NULL)
1018 	    krb5_free_principal(context, *objp);
1019 	break;
1020     }
1021     return TRUE;
1022 }
1023 
1024 bool_t
1025 xdr_krb5_octet(XDR *xdrs, krb5_octet *objp)
1026 {
1027    if (!xdr_u_char(xdrs, objp))
1028 	return (FALSE);
1029    return (TRUE);
1030 }
1031 
1032 bool_t
1033 xdr_krb5_enctype(XDR *xdrs, krb5_enctype *objp)
1034 {
1035    /*
1036     * This used to be xdr_krb5_keytype, but keytypes and enctypes have
1037     * been merged into only enctypes.  However, randkey_principal
1038     * already ensures that only a key of ENCTYPE_DES_CBC_CRC will be
1039     * returned to v1 clients, and ENCTYPE_DES_CBC_CRC has the same
1040     * value as KEYTYPE_DES used too, which is what all v1 clients
1041     * expect.  Therefore, IMHO, just encoding whatever enctype we get
1042     * is safe.
1043     */
1044 
1045    if (!xdr_u_int(xdrs, (unsigned int *) objp))
1046 	return (FALSE);
1047    return (TRUE);
1048 }
1049 
1050 bool_t
1051 xdr_krb5_salttype(XDR *xdrs, krb5_int32 *objp)
1052 {
1053     if (!xdr_int(xdrs, (int32_t *) objp))
1054 	return FALSE;
1055     return TRUE;
1056 }
1057 
1058 bool_t
1059 xdr_krb5_keyblock(XDR *xdrs, krb5_keyblock *objp)
1060 {
1061    /* XXX This only works because free_keyblock assumes ->contents
1062       is allocated by malloc() */
1063 
1064    if(!xdr_krb5_enctype(xdrs, &objp->enctype))
1065       return FALSE;
1066    if(!xdr_bytes(xdrs, (char **) &objp->contents, (unsigned int *)
1067 		 &objp->length, ~0))
1068       return FALSE;
1069    return TRUE;
1070 }
1071