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 #include <rpc/rpc.h> /* SUNWresync121 XXX */
26 #include <kadm5/kadm_rpc.h>
27 #include <krb5.h>
28 #include <kadm5/admin.h>
29 #ifdef HAVE_MEMORY_H
30 #include <memory.h>
31 #endif
32 
33 /* Default timeout can be changed using clnt_control() */
34 static struct timeval TIMEOUT = { 25, 0 };
35 
36 generic_ret *
create_principal_2(cprinc_arg * argp,CLIENT * clnt)37 create_principal_2(cprinc_arg *argp, CLIENT *clnt)
38 {
39 	static generic_ret clnt_res;
40 
41 	/* Solaris Kerberos */
42 	if (clnt == NULL)
43 		return (NULL);
44 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
45 	if (clnt_call(clnt, CREATE_PRINCIPAL,
46 		      (xdrproc_t) xdr_cprinc_arg, (caddr_t) argp,
47 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
48 		      TIMEOUT) != RPC_SUCCESS) {
49 		return (NULL);
50 	}
51 	return (&clnt_res);
52 }
53 
54 generic_ret *
create_principal3_2(cprinc3_arg * argp,CLIENT * clnt)55 create_principal3_2(cprinc3_arg *argp, CLIENT *clnt)
56 {
57 	static generic_ret clnt_res;
58 
59 	/* Solaris Kerberos */
60 	if (clnt == NULL)
61 		return (NULL);
62 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
63 	if (clnt_call(clnt, CREATE_PRINCIPAL3,
64 		      (xdrproc_t) xdr_cprinc3_arg, (caddr_t) argp,
65 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
66 		      TIMEOUT) != RPC_SUCCESS) {
67 		return (NULL);
68 	}
69 	return (&clnt_res);
70 }
71 
72 generic_ret *
delete_principal_2(dprinc_arg * argp,CLIENT * clnt)73 delete_principal_2(dprinc_arg *argp, CLIENT *clnt)
74 {
75 	static generic_ret clnt_res;
76 
77 	/* Solaris Kerberos */
78 	if (clnt == NULL)
79 		return (NULL);
80 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
81 	if (clnt_call(clnt, DELETE_PRINCIPAL,
82 		      (xdrproc_t) xdr_dprinc_arg, (caddr_t) argp,
83 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
84 		      TIMEOUT) != RPC_SUCCESS) {
85 		return (NULL);
86 	}
87 	return (&clnt_res);
88 }
89 
90 generic_ret *
modify_principal_2(mprinc_arg * argp,CLIENT * clnt)91 modify_principal_2(mprinc_arg *argp, CLIENT *clnt)
92 {
93 	static generic_ret clnt_res;
94 
95 	/* Solaris Kerberos */
96 	if (clnt == NULL)
97 		return (NULL);
98 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
99 	if (clnt_call(clnt, MODIFY_PRINCIPAL,
100 		      (xdrproc_t) xdr_mprinc_arg, (caddr_t) argp,
101 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
102 		      TIMEOUT) != RPC_SUCCESS) {
103 		return (NULL);
104 	}
105 	return (&clnt_res);
106 }
107 
108 generic_ret *
rename_principal_2(rprinc_arg * argp,CLIENT * clnt)109 rename_principal_2(rprinc_arg *argp, CLIENT *clnt)
110 {
111 	static generic_ret clnt_res;
112 
113 	/* Solaris Kerberos */
114 	if (clnt == NULL)
115 		return (NULL);
116 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
117 	if (clnt_call(clnt, RENAME_PRINCIPAL,
118 		      (xdrproc_t) xdr_rprinc_arg, (caddr_t) argp,
119 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
120 		      TIMEOUT) != RPC_SUCCESS) {
121 		return (NULL);
122 	}
123 	return (&clnt_res);
124 }
125 
126 gprinc_ret *
get_principal_2(gprinc_arg * argp,CLIENT * clnt)127 get_principal_2(gprinc_arg *argp, CLIENT *clnt)
128 {
129 	static gprinc_ret clnt_res;
130 
131 	/* Solaris Kerberos */
132 	if (clnt == NULL)
133 		return (NULL);
134 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
135 	if (clnt_call(clnt, GET_PRINCIPAL,
136 		      (xdrproc_t) xdr_gprinc_arg, (caddr_t) argp,
137 		      (xdrproc_t) xdr_gprinc_ret, (caddr_t) &clnt_res,
138 		      TIMEOUT) != RPC_SUCCESS) {
139 		return (NULL);
140 	}
141 	return (&clnt_res);
142 }
143 
144 gprincs_ret *
get_princs_2(gprincs_arg * argp,CLIENT * clnt)145 get_princs_2(gprincs_arg *argp, CLIENT *clnt)
146 {
147 	static gprincs_ret clnt_res;
148 
149 	/* Solaris Kerberos */
150 	if (clnt == NULL)
151 		return (NULL);
152 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
153 	if (clnt_call(clnt, GET_PRINCS,
154 		      (xdrproc_t) xdr_gprincs_arg, (caddr_t) argp,
155 		      (xdrproc_t) xdr_gprincs_ret, (caddr_t) &clnt_res,
156 		      TIMEOUT) != RPC_SUCCESS) {
157 	     return (NULL);
158 	}
159 	return (&clnt_res);
160 }
161 
162 generic_ret *
chpass_principal_2(chpass_arg * argp,CLIENT * clnt)163 chpass_principal_2(chpass_arg *argp, CLIENT *clnt)
164 {
165 	static generic_ret clnt_res;
166 
167 	/* Solaris Kerberos */
168 	if (clnt == NULL)
169 		return (NULL);
170 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
171 	if (clnt_call(clnt, CHPASS_PRINCIPAL,
172 		      (xdrproc_t) xdr_chpass_arg, (caddr_t) argp,
173 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
174 		      TIMEOUT) != RPC_SUCCESS) {
175 		return (NULL);
176 	}
177 	return (&clnt_res);
178 }
179 
180 generic_ret *
chpass_principal3_2(chpass3_arg * argp,CLIENT * clnt)181 chpass_principal3_2(chpass3_arg *argp, CLIENT *clnt)
182 {
183 	static generic_ret clnt_res;
184 
185 	/* Solaris Kerberos */
186 	if (clnt == NULL)
187 		return (NULL);
188 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
189 	if (clnt_call(clnt, CHPASS_PRINCIPAL3,
190 		      (xdrproc_t) xdr_chpass3_arg, (caddr_t) argp,
191 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
192 		      TIMEOUT) != RPC_SUCCESS) {
193 		return (NULL);
194 	}
195 	return (&clnt_res);
196 }
197 
198 generic_ret *
setv4key_principal_2(setv4key_arg * argp,CLIENT * clnt)199 setv4key_principal_2(setv4key_arg *argp, CLIENT *clnt)
200 {
201 	static generic_ret clnt_res;
202 
203 	/* Solaris Kerberos */
204 	if (clnt == NULL)
205 		return (NULL);
206 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
207 	if (clnt_call(clnt, SETV4KEY_PRINCIPAL,
208 		      (xdrproc_t) xdr_setv4key_arg, (caddr_t) argp,
209 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
210 		      TIMEOUT) != RPC_SUCCESS) {
211 		return (NULL);
212 	}
213 	return (&clnt_res);
214 }
215 
216 generic_ret *
setkey_principal_2(setkey_arg * argp,CLIENT * clnt)217 setkey_principal_2(setkey_arg *argp, CLIENT *clnt)
218 {
219 	static generic_ret clnt_res;
220 
221 	/* Solaris Kerberos */
222 	if (clnt == NULL)
223 		return (NULL);
224 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
225 	if (clnt_call(clnt, SETKEY_PRINCIPAL,
226 		      (xdrproc_t) xdr_setkey_arg, (caddr_t) argp,
227 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
228 		      TIMEOUT) != RPC_SUCCESS) {
229 		return (NULL);
230 	}
231 	return (&clnt_res);
232 }
233 
234 generic_ret *
setkey_principal3_2(setkey3_arg * argp,CLIENT * clnt)235 setkey_principal3_2(setkey3_arg *argp, CLIENT *clnt)
236 {
237 	static generic_ret clnt_res;
238 
239 	/* Solaris Kerberos */
240 	if (clnt == NULL)
241 		return (NULL);
242 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
243 	if (clnt_call(clnt, SETKEY_PRINCIPAL3,
244 		      (xdrproc_t) xdr_setkey3_arg, (caddr_t) argp,
245 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
246 		      TIMEOUT) != RPC_SUCCESS) {
247 		return (NULL);
248 	}
249 	return (&clnt_res);
250 }
251 
252 chrand_ret *
chrand_principal_2(chrand_arg * argp,CLIENT * clnt)253 chrand_principal_2(chrand_arg *argp, CLIENT *clnt)
254 {
255 	static chrand_ret clnt_res;
256 
257 	/* Solaris Kerberos */
258 	if (clnt == NULL)
259 		return (NULL);
260 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
261 	if (clnt_call(clnt, CHRAND_PRINCIPAL,
262 		      (xdrproc_t) xdr_chrand_arg, (caddr_t) argp,
263 		      (xdrproc_t) xdr_chrand_ret, (caddr_t) &clnt_res,
264 		      TIMEOUT) != RPC_SUCCESS) {
265 		return (NULL);
266 	}
267 	return (&clnt_res);
268 }
269 
270 chrand_ret *
chrand_principal3_2(chrand3_arg * argp,CLIENT * clnt)271 chrand_principal3_2(chrand3_arg *argp, CLIENT *clnt)
272 {
273 	static chrand_ret clnt_res;
274 
275 	/* Solaris Kerberos */
276 	if (clnt == NULL)
277 		return (NULL);
278 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
279 	if (clnt_call(clnt, CHRAND_PRINCIPAL3,
280 		      (xdrproc_t) xdr_chrand3_arg, (caddr_t) argp,
281 		      (xdrproc_t) xdr_chrand_ret, (caddr_t) &clnt_res,
282 		      TIMEOUT) != RPC_SUCCESS) {
283 		return (NULL);
284 	}
285 	return (&clnt_res);
286 }
287 
288 generic_ret *
create_policy_2(cpol_arg * argp,CLIENT * clnt)289 create_policy_2(cpol_arg *argp, CLIENT *clnt)
290 {
291 	static generic_ret clnt_res;
292 
293 	/* Solaris Kerberos */
294 	if (clnt == NULL)
295 		return (NULL);
296 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
297 	if (clnt_call(clnt, CREATE_POLICY,
298 		      (xdrproc_t) xdr_cpol_arg, (caddr_t) argp,
299 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
300 		      TIMEOUT) != RPC_SUCCESS) {
301 		return (NULL);
302 	}
303 	return (&clnt_res);
304 }
305 
306 generic_ret *
delete_policy_2(dpol_arg * argp,CLIENT * clnt)307 delete_policy_2(dpol_arg *argp, CLIENT *clnt)
308 {
309 	static generic_ret clnt_res;
310 
311 	/* Solaris Kerberos */
312 	if (clnt == NULL)
313 		return (NULL);
314 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
315 	if (clnt_call(clnt, DELETE_POLICY,
316 		      (xdrproc_t) xdr_dpol_arg, (caddr_t) argp,
317 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
318 		      TIMEOUT) != RPC_SUCCESS) {
319 		return (NULL);
320 	}
321 	return (&clnt_res);
322 }
323 
324 generic_ret *
modify_policy_2(mpol_arg * argp,CLIENT * clnt)325 modify_policy_2(mpol_arg *argp, CLIENT *clnt)
326 {
327 	static generic_ret clnt_res;
328 
329 	/* Solaris Kerberos */
330 	if (clnt == NULL)
331 		return (NULL);
332 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
333 	if (clnt_call(clnt, MODIFY_POLICY,
334 		      (xdrproc_t) xdr_mpol_arg, (caddr_t) argp,
335 		      (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
336 		      TIMEOUT) != RPC_SUCCESS) {
337 		return (NULL);
338 	}
339 	return (&clnt_res);
340 }
341 
342 gpol_ret *
get_policy_2(gpol_arg * argp,CLIENT * clnt)343 get_policy_2(gpol_arg *argp, CLIENT *clnt)
344 {
345 	static gpol_ret clnt_res;
346 
347 	/* Solaris Kerberos */
348 	if (clnt == NULL)
349 		return (NULL);
350 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
351 	if (clnt_call(clnt, GET_POLICY,
352 		      (xdrproc_t) xdr_gpol_arg, (caddr_t) argp,
353 		      (xdrproc_t) xdr_gpol_ret, (caddr_t) &clnt_res,
354 		      TIMEOUT) != RPC_SUCCESS) {
355 		return (NULL);
356 	}
357 	return (&clnt_res);
358 }
359 
360 gpols_ret *
get_pols_2(gpols_arg * argp,CLIENT * clnt)361 get_pols_2(gpols_arg *argp, CLIENT *clnt)
362 {
363 	static gpols_ret clnt_res;
364 
365 	/* Solaris Kerberos */
366 	if (clnt == NULL)
367 		return (NULL);
368 	memset((char *)&clnt_res, 0, sizeof(clnt_res));
369 	if (clnt_call(clnt, GET_POLS,
370 		      (xdrproc_t) xdr_gpols_arg, (caddr_t) argp,
371 		      (xdrproc_t) xdr_gpols_ret, (caddr_t) &clnt_res,
372 		      TIMEOUT) != RPC_SUCCESS) {
373 	     return (NULL);
374 	}
375 	return (&clnt_res);
376 }
377 
378 getprivs_ret *
get_privs_2(void * argp,CLIENT * clnt)379 get_privs_2(void *argp, CLIENT *clnt)
380 {
381      static getprivs_ret clnt_res;
382 
383 	/* Solaris Kerberos */
384 	if (clnt == NULL)
385 		return (NULL);
386      memset((char *)&clnt_res, 0, sizeof(clnt_res));
387      if (clnt_call(clnt, GET_PRIVS,
388 		   (xdrproc_t) xdr_u_int, (caddr_t) argp,
389 		   (xdrproc_t) xdr_getprivs_ret, (caddr_t) &clnt_res,
390 		   TIMEOUT) != RPC_SUCCESS) {
391 	  return (NULL);
392      }
393      return (&clnt_res);
394 }
395 
396 generic_ret *
init_2(void * argp,CLIENT * clnt)397 init_2(void *argp, CLIENT *clnt)
398 {
399      static generic_ret clnt_res;
400 
401 	/* Solaris Kerberos */
402      if (clnt == NULL)
403          return (NULL);
404 
405      memset((char *)&clnt_res, 0, sizeof(clnt_res));
406      if (clnt_call(clnt, INIT,
407 		   (xdrproc_t) xdr_u_int, (caddr_t) argp,
408 		   (xdrproc_t) xdr_generic_ret, (caddr_t) &clnt_res,
409 		   TIMEOUT) != RPC_SUCCESS) {
410 	  return (NULL);
411      }
412      return (&clnt_res);
413 }
414