1 /*        $NetBSD: deprecated.c,v 1.4 2023/06/19 21:41:44 christos Exp $        */
2 
3 /*
4  * Copyright (c) 1997 - 2009 Kungliga Tekniska H�gskolan
5  * (Royal Institute of Technology, Stockholm, Sweden).
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * 3. Neither the name of the Institute nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 
36 #ifdef __GNUC__
37 /* For some GCCs there's no way to shut them up about deprecated functions */
38 #define KRB5_DEPRECATED_FUNCTION(x)
39 #endif
40 
41 #include "krb5_locl.h"
42 
43 
44 #undef __attribute__
45 #define __attribute__(x)
46 
47 #ifndef HEIMDAL_SMALLER
48 
49 /**
50  * Same as krb5_data_free(). MIT compat.
51  *
52  * Deprecated: use krb5_data_free().
53  *
54  * @param context Kerberos 5 context.
55  * @param data krb5_data to free.
56  *
57  * @ingroup krb5_deprecated
58  */
59 
60 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_data_contents(krb5_context context,krb5_data * data)61 krb5_free_data_contents(krb5_context context, krb5_data *data)
62     KRB5_DEPRECATED_FUNCTION("Use X instead")
63 {
64     krb5_data_free(data);
65 }
66 
67 /**
68  * Deprecated: keytypes doesn't exists, they are really enctypes.
69  *
70  * @ingroup krb5_deprecated
71  */
72 
73 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keytype_to_enctypes_default(krb5_context context,krb5_keytype keytype,unsigned * len,krb5_enctype ** val)74 krb5_keytype_to_enctypes_default (krb5_context context,
75                                           krb5_keytype keytype,
76                                           unsigned *len,
77                                           krb5_enctype **val)
78     KRB5_DEPRECATED_FUNCTION("Use X instead")
79 {
80     unsigned int i, n;
81     krb5_enctype *ret;
82 
83     if (keytype != (krb5_keytype)KEYTYPE_DES || context->etypes_des == NULL)
84           return krb5_keytype_to_enctypes (context, keytype, len, val);
85 
86     for (n = 0; context->etypes_des[n]; ++n)
87           ;
88     ret = malloc (n * sizeof(*ret));
89     if (ret == NULL && n != 0)
90           return krb5_enomem(context);
91     for (i = 0; i < n; ++i)
92           ret[i] = context->etypes_des[i];
93     *len = n;
94     *val = ret;
95     return 0;
96 }
97 
98 
99 static struct {
100     const char *name;
101     krb5_keytype type;
102 } keys[] = {
103     { "null", KRB5_ENCTYPE_NULL },
104     { "des", KRB5_ENCTYPE_DES_CBC_CRC },
105     { "des3", KRB5_ENCTYPE_OLD_DES3_CBC_SHA1 },
106     { "aes-128", KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96 },
107     { "aes-256", KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96 },
108     { "arcfour", KRB5_ENCTYPE_ARCFOUR_HMAC_MD5 },
109     { "arcfour-56", KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56 }
110 };
111 
112 static int num_keys = sizeof(keys) / sizeof(keys[0]);
113 
114 /**
115  * Deprecated: keytypes doesn't exists, they are really enctypes in
116  * most cases, use krb5_enctype_to_string().
117  *
118  * @ingroup krb5_deprecated
119  */
120 
121 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_keytype_to_string(krb5_context context,krb5_keytype keytype,char ** string)122 krb5_keytype_to_string(krb5_context context,
123                            krb5_keytype keytype,
124                            char **string)
125     KRB5_DEPRECATED_FUNCTION("Use X instead")
126 {
127     const char *name = NULL;
128     int i;
129 
130     for(i = 0; i < num_keys; i++) {
131           if(keys[i].type == keytype) {
132               name = keys[i].name;
133               break;
134           }
135     }
136 
137     if(i >= num_keys) {
138           krb5_set_error_message(context, KRB5_PROG_KEYTYPE_NOSUPP,
139                                      "key type %d not supported", keytype);
140           return KRB5_PROG_KEYTYPE_NOSUPP;
141     }
142     *string = strdup(name);
143     if (*string == NULL)
144           return krb5_enomem(context);
145     return 0;
146 }
147 
148 /**
149  * Deprecated: keytypes doesn't exists, they are really enctypes in
150  * most cases, use krb5_string_to_enctype().
151  *
152  * @ingroup krb5_deprecated
153  */
154 
155 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_string_to_keytype(krb5_context context,const char * string,krb5_keytype * keytype)156 krb5_string_to_keytype(krb5_context context,
157                            const char *string,
158                            krb5_keytype *keytype)
159     KRB5_DEPRECATED_FUNCTION("Use X instead")
160 {
161     char *end;
162     int i;
163 
164     for(i = 0; i < num_keys; i++)
165           if(strcasecmp(keys[i].name, string) == 0){
166               *keytype = keys[i].type;
167               return 0;
168           }
169 
170     /* check if the enctype is a number */
171     *keytype = strtol(string, &end, 0);
172     if(*end == '\0' && *keytype != 0) {
173           if (krb5_enctype_valid(context, *keytype) == 0)
174               return 0;
175     }
176 
177     krb5_set_error_message(context, KRB5_PROG_KEYTYPE_NOSUPP,
178                                  "key type %s not supported", string);
179     return KRB5_PROG_KEYTYPE_NOSUPP;
180 }
181 
182 /**
183  * Deprecated: use krb5_get_init_creds() and friends.
184  *
185  * @ingroup krb5_deprecated
186  */
187 
188 KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV
krb5_password_key_proc(krb5_context context,krb5_enctype type,krb5_salt salt,krb5_const_pointer keyseed,krb5_keyblock ** key)189 krb5_password_key_proc (krb5_context context,
190                               krb5_enctype type,
191                               krb5_salt salt,
192                               krb5_const_pointer keyseed,
193                               krb5_keyblock **key)
194     KRB5_DEPRECATED_FUNCTION("Use X instead")
195 {
196     krb5_error_code ret;
197     const char *password = (const char *)keyseed;
198     char buf[BUFSIZ];
199 
200     *key = malloc (sizeof (**key));
201     if (*key == NULL)
202           return krb5_enomem(context);
203     if (password == NULL) {
204           if(UI_UTIL_read_pw_string (buf, sizeof(buf), "Password: ", 0)) {
205               free (*key);
206               krb5_clear_error_message(context);
207               return KRB5_LIBOS_PWDINTR;
208           }
209           password = buf;
210     }
211     ret = krb5_string_to_key_salt (context, type, password, salt, *key);
212     memset_s(buf, sizeof(buf), 0, sizeof(buf));
213     return ret;
214 }
215 
216 /**
217  * Deprecated: use krb5_get_init_creds() and friends.
218  *
219  * @ingroup krb5_deprecated
220  */
221 
222 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_password(krb5_context context,krb5_flags options,krb5_addresses * addrs,const krb5_enctype * etypes,const krb5_preauthtype * pre_auth_types,const char * password,krb5_ccache ccache,krb5_creds * creds,krb5_kdc_rep * ret_as_reply)223 krb5_get_in_tkt_with_password (krb5_context context,
224                                      krb5_flags options,
225                                      krb5_addresses *addrs,
226                                      const krb5_enctype *etypes,
227                                      const krb5_preauthtype *pre_auth_types,
228                                      const char *password,
229                                      krb5_ccache ccache,
230                                      krb5_creds *creds,
231                                      krb5_kdc_rep *ret_as_reply)
232     KRB5_DEPRECATED_FUNCTION("Use X instead")
233 {
234      return krb5_get_in_tkt (context,
235                                    options,
236                                    addrs,
237                                    etypes,
238                                    pre_auth_types,
239                                    krb5_password_key_proc,
240                                    password,
241                                    NULL,
242                                    NULL,
243                                    creds,
244                                    ccache,
245                                    ret_as_reply);
246 }
247 
248 static krb5_error_code KRB5_CALLCONV
krb5_skey_key_proc(krb5_context context,krb5_enctype type,krb5_salt salt,krb5_const_pointer keyseed,krb5_keyblock ** key)249 krb5_skey_key_proc (krb5_context context,
250                         krb5_enctype type,
251                         krb5_salt salt,
252                         krb5_const_pointer keyseed,
253                         krb5_keyblock **key)
254 {
255     return krb5_copy_keyblock (context, keyseed, key);
256 }
257 
258 /**
259  * Deprecated: use krb5_get_init_creds() and friends.
260  *
261  * @ingroup krb5_deprecated
262  */
263 
264 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_skey(krb5_context context,krb5_flags options,krb5_addresses * addrs,const krb5_enctype * etypes,const krb5_preauthtype * pre_auth_types,const krb5_keyblock * key,krb5_ccache ccache,krb5_creds * creds,krb5_kdc_rep * ret_as_reply)265 krb5_get_in_tkt_with_skey (krb5_context context,
266                                  krb5_flags options,
267                                  krb5_addresses *addrs,
268                                  const krb5_enctype *etypes,
269                                  const krb5_preauthtype *pre_auth_types,
270                                  const krb5_keyblock *key,
271                                  krb5_ccache ccache,
272                                  krb5_creds *creds,
273                                  krb5_kdc_rep *ret_as_reply)
274     KRB5_DEPRECATED_FUNCTION("Use X instead")
275 {
276     if(key == NULL)
277           return krb5_get_in_tkt_with_keytab (context,
278                                                       options,
279                                                       addrs,
280                                                       etypes,
281                                                       pre_auth_types,
282                                                       NULL,
283                                                       ccache,
284                                                       creds,
285                                                       ret_as_reply);
286     else
287           return krb5_get_in_tkt (context,
288                                         options,
289                                         addrs,
290                                         etypes,
291                                         pre_auth_types,
292                                         krb5_skey_key_proc,
293                                         key,
294                                         NULL,
295                                         NULL,
296                                         creds,
297                                         ccache,
298                                         ret_as_reply);
299 }
300 
301 /**
302  * Deprecated: use krb5_get_init_creds() and friends.
303  *
304  * @ingroup krb5_deprecated
305  */
306 
307 KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV
krb5_keytab_key_proc(krb5_context context,krb5_enctype enctype,krb5_salt salt,krb5_const_pointer keyseed,krb5_keyblock ** key)308 krb5_keytab_key_proc (krb5_context context,
309                           krb5_enctype enctype,
310                           krb5_salt salt,
311                           krb5_const_pointer keyseed,
312                           krb5_keyblock **key)
313     KRB5_DEPRECATED_FUNCTION("Use X instead")
314 {
315     krb5_keytab_key_proc_args *args  = rk_UNCONST(keyseed);
316     krb5_keytab keytab = args->keytab;
317     krb5_principal principal  = args->principal;
318     krb5_error_code ret;
319     krb5_keytab real_keytab;
320     krb5_keytab_entry entry;
321 
322     if(keytab == NULL)
323           krb5_kt_default(context, &real_keytab);
324     else
325           real_keytab = keytab;
326 
327     ret = krb5_kt_get_entry (context, real_keytab, principal,
328                                    0, enctype, &entry);
329     if (ret == 0) {
330         ret = krb5_copy_keyblock (context, &entry.keyblock, key);
331         krb5_kt_free_entry(context, &entry);
332     }
333 
334     if (keytab == NULL)
335           krb5_kt_close (context, real_keytab);
336     return ret;
337 }
338 
339 /**
340  * Deprecated: use krb5_get_init_creds() and friends.
341  *
342  * @ingroup krb5_deprecated
343  */
344 
345 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_in_tkt_with_keytab(krb5_context context,krb5_flags options,krb5_addresses * addrs,const krb5_enctype * etypes,const krb5_preauthtype * pre_auth_types,krb5_keytab keytab,krb5_ccache ccache,krb5_creds * creds,krb5_kdc_rep * ret_as_reply)346 krb5_get_in_tkt_with_keytab (krb5_context context,
347                                    krb5_flags options,
348                                    krb5_addresses *addrs,
349                                    const krb5_enctype *etypes,
350                                    const krb5_preauthtype *pre_auth_types,
351                                    krb5_keytab keytab,
352                                    krb5_ccache ccache,
353                                    krb5_creds *creds,
354                                    krb5_kdc_rep *ret_as_reply)
355     KRB5_DEPRECATED_FUNCTION("Use X instead")
356 {
357     krb5_keytab_key_proc_args a;
358 
359     a.principal = creds->client;
360     a.keytab    = keytab;
361 
362     return krb5_get_in_tkt (context,
363                                   options,
364                                   addrs,
365                                   etypes,
366                                   pre_auth_types,
367                                   krb5_keytab_key_proc,
368                                   &a,
369                                   NULL,
370                                   NULL,
371                                   creds,
372                                   ccache,
373                                   ret_as_reply);
374 }
375 
376 /**
377  * Generate a new ccache of type `ops' in `id'.
378  *
379  * Deprecated: use krb5_cc_new_unique() instead.
380  *
381  * @return Return an error code or 0, see krb5_get_error_message().
382  *
383  * @ingroup krb5_ccache
384  */
385 
386 
387 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_cc_gen_new(krb5_context context,const krb5_cc_ops * ops,krb5_ccache * id)388 krb5_cc_gen_new(krb5_context context,
389                     const krb5_cc_ops *ops,
390                     krb5_ccache *id)
391     KRB5_DEPRECATED_FUNCTION("Use X instead")
392 {
393     return krb5_cc_new_unique(context, ops->prefix, NULL, id);
394 }
395 
396 /**
397  * Deprecated: use krb5_principal_get_realm()
398  *
399  * @ingroup krb5_deprecated
400  */
401 
402 KRB5_LIB_FUNCTION krb5_realm * KRB5_LIB_CALL
krb5_princ_realm(krb5_context context,krb5_principal principal)403 krb5_princ_realm(krb5_context context,
404                      krb5_principal principal)
405     KRB5_DEPRECATED_FUNCTION("Use X instead")
406 {
407     return &principal->realm;
408 }
409 
410 
411 /**
412  * Deprecated: use krb5_principal_set_realm()
413  *
414  * @ingroup krb5_deprecated
415  */
416 
417 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_princ_set_realm(krb5_context context,krb5_principal principal,krb5_realm * realm)418 krb5_princ_set_realm(krb5_context context,
419                          krb5_principal principal,
420                          krb5_realm *realm)
421     KRB5_DEPRECATED_FUNCTION("Use X instead")
422 {
423     principal->realm = *realm;
424 }
425 
426 /**
427  * Deprecated: use krb5_free_cred_contents()
428  *
429  * @ingroup krb5_deprecated
430  */
431 
432 /* keep this for compatibility with older code */
433 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_free_creds_contents(krb5_context context,krb5_creds * c)434 krb5_free_creds_contents (krb5_context context, krb5_creds *c)
435     KRB5_DEPRECATED_FUNCTION("Use X instead")
436 {
437     return krb5_free_cred_contents (context, c);
438 }
439 
440 /**
441  * Free the error message returned by krb5_get_error_string().
442  *
443  * Deprecated: use krb5_free_error_message()
444  *
445  * @param context Kerberos context
446  * @param str error message to free
447  *
448  * @ingroup krb5_deprecated
449  */
450 
451 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_error_string(krb5_context context,char * str)452 krb5_free_error_string(krb5_context context, char *str)
453     KRB5_DEPRECATED_FUNCTION("Use X instead")
454 {
455     krb5_free_error_message(context, str);
456 }
457 
458 /**
459  * Set the error message returned by krb5_get_error_string().
460  *
461  * Deprecated: use krb5_get_error_message()
462  *
463  * @param context Kerberos context
464  * @param fmt error message to free
465  *
466  * @return Return an error code or 0.
467  *
468  * @ingroup krb5_deprecated
469  */
470 
471 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_error_string(krb5_context context,const char * fmt,...)472 krb5_set_error_string(krb5_context context, const char *fmt, ...)
473     __attribute__ ((__format__ (__printf__, 2, 3)))
474     KRB5_DEPRECATED_FUNCTION("Use X instead")
475 {
476     va_list ap;
477 
478     va_start(ap, fmt);
479     krb5_vset_error_message (context, 0, fmt, ap);
480     va_end(ap);
481     return 0;
482 }
483 
484 /**
485  * Set the error message returned by krb5_get_error_string(),
486  * deprecated, use krb5_set_error_message().
487  *
488  * Deprecated: use krb5_vset_error_message()
489  *
490  * @param context Kerberos context
491  * @param fmt error message to free
492  * @param args variable argument list vector
493  *
494  * @return Return an error code or 0.
495  *
496  * @ingroup krb5_deprecated
497  */
498 
499 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_vset_error_string(krb5_context context,const char * fmt,va_list args)500 krb5_vset_error_string(krb5_context context, const char *fmt, va_list args)
501     __attribute__ ((__format__ (__printf__, 2, 0)))
502     KRB5_DEPRECATED_FUNCTION("Use X instead")
503 {
504     krb5_vset_error_message(context, 0, fmt, args);
505     return 0;
506 }
507 
508 /**
509  * Clear the error message returned by krb5_get_error_string().
510  *
511  * Deprecated: use krb5_clear_error_message()
512  *
513  * @param context Kerberos context
514  *
515  * @ingroup krb5_deprecated
516  */
517 
518 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_clear_error_string(krb5_context context)519 krb5_clear_error_string(krb5_context context)
520     KRB5_DEPRECATED_FUNCTION("Use X instead")
521 {
522     krb5_clear_error_message(context);
523 }
524 
525 /**
526  * Deprecated: use krb5_get_credentials_with_flags().
527  *
528  * @ingroup krb5_deprecated
529  */
530 
531 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_cred_from_kdc_opt(krb5_context context,krb5_ccache ccache,krb5_creds * in_creds,krb5_creds ** out_creds,krb5_creds *** ret_tgts,krb5_flags flags)532 krb5_get_cred_from_kdc_opt(krb5_context context,
533                                  krb5_ccache ccache,
534                                  krb5_creds *in_creds,
535                                  krb5_creds **out_creds,
536                                  krb5_creds ***ret_tgts,
537                                  krb5_flags flags)
538     KRB5_DEPRECATED_FUNCTION("Use X instead")
539 {
540     krb5_kdc_flags f;
541     f.i = flags;
542     return _krb5_get_cred_kdc_any(context, f, ccache,
543                                           in_creds, NULL, NULL,
544                                           out_creds, ret_tgts);
545 }
546 
547 /**
548  * Deprecated: use krb5_get_credentials_with_flags().
549  *
550  * @ingroup krb5_deprecated
551  */
552 
553 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_get_cred_from_kdc(krb5_context context,krb5_ccache ccache,krb5_creds * in_creds,krb5_creds ** out_creds,krb5_creds *** ret_tgts)554 krb5_get_cred_from_kdc(krb5_context context,
555                            krb5_ccache ccache,
556                            krb5_creds *in_creds,
557                            krb5_creds **out_creds,
558                            krb5_creds ***ret_tgts)
559     KRB5_DEPRECATED_FUNCTION("Use X instead")
560 {
561     return krb5_get_cred_from_kdc_opt(context, ccache,
562                                               in_creds, out_creds, ret_tgts, 0);
563 }
564 
565 /**
566  * Deprecated: use krb5_xfree().
567  *
568  * @ingroup krb5_deprecated
569  */
570 
571 KRB5_LIB_FUNCTION void KRB5_LIB_CALL
krb5_free_unparsed_name(krb5_context context,char * str)572 krb5_free_unparsed_name(krb5_context context, char *str)
573     KRB5_DEPRECATED_FUNCTION("Use X instead")
574 {
575     krb5_xfree(str);
576 }
577 
578 /**
579  * Deprecated: use krb5_generate_subkey_extended()
580  *
581  * @ingroup krb5_deprecated
582  */
583 
584 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_generate_subkey(krb5_context context,const krb5_keyblock * key,krb5_keyblock ** subkey)585 krb5_generate_subkey(krb5_context context,
586                          const krb5_keyblock *key,
587                          krb5_keyblock **subkey)
588     KRB5_DEPRECATED_FUNCTION("Use X instead")
589 {
590     return krb5_generate_subkey_extended(context, key, ETYPE_NULL, subkey);
591 }
592 
593 /**
594  * Deprecated: use krb5_auth_con_getremoteseqnumber()
595  *
596  * @ingroup krb5_deprecated
597  */
598 
599 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_auth_getremoteseqnumber(krb5_context context,krb5_auth_context auth_context,int32_t * seqnumber)600 krb5_auth_getremoteseqnumber(krb5_context context,
601                                    krb5_auth_context auth_context,
602                                    int32_t *seqnumber)
603     KRB5_DEPRECATED_FUNCTION("Use X instead")
604 {
605   *seqnumber = auth_context->remote_seqnumber;
606   return 0;
607 }
608 
609 /**
610  * Return the error message in context. On error or no error string,
611  * the function returns NULL.
612  *
613  * @param context Kerberos 5 context
614  *
615  * @return an error string, needs to be freed with
616  * krb5_free_error_message(). The functions return NULL on error.
617  *
618  * @ingroup krb5_error
619  */
620 
621 KRB5_LIB_FUNCTION char * KRB5_LIB_CALL
krb5_get_error_string(krb5_context context)622 krb5_get_error_string(krb5_context context)
623     KRB5_DEPRECATED_FUNCTION("Use krb5_get_error_message instead")
624 {
625     char *ret = NULL;
626 
627     HEIMDAL_MUTEX_lock(&context->mutex);
628     if (context->error_string)
629           ret = strdup(context->error_string);
630     HEIMDAL_MUTEX_unlock(&context->mutex);
631     return ret;
632 }
633 
634 KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
krb5_have_error_string(krb5_context context)635 krb5_have_error_string(krb5_context context)
636     KRB5_DEPRECATED_FUNCTION("Use krb5_get_error_message instead")
637 {
638     char *str;
639     HEIMDAL_MUTEX_lock(&context->mutex);
640     str = context->error_string;
641     HEIMDAL_MUTEX_unlock(&context->mutex);
642     return str != NULL;
643 }
644 
645 struct send_to_kdc {
646     krb5_send_to_kdc_func func;
647     void *data;
648 };
649 
650 /*
651  * Send the data `send' to one host from `handle` and get back the reply
652  * in `receive'.
653  */
654 
655 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto(krb5_context context,const krb5_data * send_data,krb5_krbhst_handle handle,krb5_data * receive)656 krb5_sendto (krb5_context context,
657                const krb5_data *send_data,
658                krb5_krbhst_handle handle,
659                krb5_data *receive)
660 {
661     krb5_error_code ret;
662     krb5_sendto_ctx ctx;
663 
664     ret = krb5_sendto_ctx_alloc(context, &ctx);
665     if (ret)
666           return ret;
667     _krb5_sendto_ctx_set_krb5hst(context, ctx, handle);
668 
669     ret = krb5_sendto_context(context, ctx, send_data, (char *)_krb5_krbhst_get_realm(handle), receive);
670     krb5_sendto_ctx_free(context, ctx);
671     return ret;
672 }
673 
674 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_kdc(krb5_context context,const krb5_data * send_data,const krb5_realm * realm,krb5_data * receive)675 krb5_sendto_kdc(krb5_context context,
676                     const krb5_data *send_data,
677                     const krb5_realm *realm,
678                     krb5_data *receive)
679 {
680     return krb5_sendto_kdc_flags(context, send_data, realm, receive, 0);
681 }
682 
683 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_sendto_kdc_flags(krb5_context context,const krb5_data * send_data,const krb5_realm * realm,krb5_data * receive,int flags)684 krb5_sendto_kdc_flags(krb5_context context,
685                           const krb5_data *send_data,
686                           const krb5_realm *realm,
687                           krb5_data *receive,
688                           int flags)
689 {
690     krb5_error_code ret;
691     krb5_sendto_ctx ctx;
692 
693     ret = krb5_sendto_ctx_alloc(context, &ctx);
694     if (ret)
695           return ret;
696     krb5_sendto_ctx_add_flags(ctx, flags);
697     krb5_sendto_ctx_set_func(ctx, _krb5_kdc_retry, NULL);
698 
699     ret = krb5_sendto_context(context, ctx, send_data, *realm, receive);
700     krb5_sendto_ctx_free(context, ctx);
701     return ret;
702 }
703 
704 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
krb5_set_send_to_kdc_func(krb5_context context,krb5_send_to_kdc_func func,void * data)705 krb5_set_send_to_kdc_func(krb5_context context,
706                                 krb5_send_to_kdc_func func,
707                                 void *data)
708 {
709     free(context->send_to_kdc);
710     if (func == NULL) {
711           context->send_to_kdc = NULL;
712           return 0;
713     }
714 
715     context->send_to_kdc = malloc(sizeof(*context->send_to_kdc));
716     if (context->send_to_kdc == NULL) {
717           krb5_set_error_message(context, ENOMEM,
718                                      N_("malloc: out of memory", ""));
719           return ENOMEM;
720     }
721 
722     context->send_to_kdc->func = func;
723     context->send_to_kdc->data = data;
724     return 0;
725 }
726 
727 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
_krb5_copy_send_to_kdc_func(krb5_context context,krb5_context to)728 _krb5_copy_send_to_kdc_func(krb5_context context, krb5_context to)
729 {
730     if (context->send_to_kdc)
731           return krb5_set_send_to_kdc_func(to,
732                                                    context->send_to_kdc->func,
733                                                    context->send_to_kdc->data);
734     else
735           return krb5_set_send_to_kdc_func(to, NULL, NULL);
736 }
737 
738 #endif /* HEIMDAL_SMALLER */
739