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