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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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