1/*
2 * Copyright (c) 2001, 2003, 2005 - 2006 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include "krb5_locl.h"
35
36#undef __attribute__
37#define __attribute__(x)
38
39/**
40 * Clears the error message from the Kerberos 5 context.
41 *
42 * @param context The Kerberos 5 context to clear
43 *
44 * @ingroup krb5_error
45 */
46
47KRB5_LIB_FUNCTION void KRB5_LIB_CALL
48krb5_clear_error_message(krb5_context context)
49{
50    HEIMDAL_MUTEX_lock(context->mutex);
51    if (context->error_string)
52	free(context->error_string);
53    context->error_code = 0;
54    context->error_string = NULL;
55    HEIMDAL_MUTEX_unlock(context->mutex);
56}
57
58/**
59 * Set the context full error string for a specific error code.
60 * The error that is stored should be internationalized.
61 *
62 * The if context is NULL, no error string is stored.
63 *
64 * @param context Kerberos 5 context
65 * @param ret The error code
66 * @param fmt Error string for the error code
67 * @param ... printf(3) style parameters.
68 *
69 * @ingroup krb5_error
70 */
71
72KRB5_LIB_FUNCTION void KRB5_LIB_CALL
73krb5_set_error_message(krb5_context context, krb5_error_code ret,
74		       const char *fmt, ...)
75    __attribute__ ((format (printf, 3, 4)))
76{
77    va_list ap;
78
79    va_start(ap, fmt);
80    krb5_vset_error_message (context, ret, fmt, ap);
81    va_end(ap);
82}
83
84/**
85 * Set the context full error string for a specific error code.
86 *
87 * The if context is NULL, no error string is stored.
88 *
89 * @param context Kerberos 5 context
90 * @param ret The error code
91 * @param fmt Error string for the error code
92 * @param args printf(3) style parameters.
93 *
94 * @ingroup krb5_error
95 */
96
97
98KRB5_LIB_FUNCTION void KRB5_LIB_CALL
99krb5_vset_error_message (krb5_context context, krb5_error_code ret,
100			 const char *fmt, va_list args)
101    __attribute__ ((format (printf, 3, 0)))
102{
103    int r;
104
105    if (context == NULL)
106	return;
107
108    HEIMDAL_MUTEX_lock(context->mutex);
109    if (context->error_string) {
110	free(context->error_string);
111	context->error_string = NULL;
112    }
113    context->error_code = ret;
114    r = vasprintf(&context->error_string, fmt, args);
115    if (r < 0)
116	context->error_string = NULL;
117    HEIMDAL_MUTEX_unlock(context->mutex);
118}
119
120/**
121 * Prepend the context full error string for a specific error code.
122 * The error that is stored should be internationalized.
123 *
124 * The if context is NULL, no error string is stored.
125 *
126 * @param context Kerberos 5 context
127 * @param ret The error code
128 * @param fmt Error string for the error code
129 * @param ... printf(3) style parameters.
130 *
131 * @ingroup krb5_error
132 */
133
134KRB5_LIB_FUNCTION void KRB5_LIB_CALL
135krb5_prepend_error_message(krb5_context context, krb5_error_code ret,
136			   const char *fmt, ...)
137    __attribute__ ((format (printf, 3, 4)))
138{
139    va_list ap;
140
141    va_start(ap, fmt);
142    krb5_vprepend_error_message(context, ret, fmt, ap);
143    va_end(ap);
144}
145
146/**
147 * Prepend the contexts's full error string for a specific error code.
148 *
149 * The if context is NULL, no error string is stored.
150 *
151 * @param context Kerberos 5 context
152 * @param ret The error code
153 * @param fmt Error string for the error code
154 * @param args printf(3) style parameters.
155 *
156 * @ingroup krb5_error
157 */
158
159KRB5_LIB_FUNCTION void KRB5_LIB_CALL
160krb5_vprepend_error_message(krb5_context context, krb5_error_code ret,
161			    const char *fmt, va_list args)
162    __attribute__ ((format (printf, 3, 0)))
163{
164    char *str = NULL, *str2 = NULL;
165
166    if (context == NULL)
167	return;
168
169    HEIMDAL_MUTEX_lock(context->mutex);
170    if (context->error_code != ret) {
171	HEIMDAL_MUTEX_unlock(context->mutex);
172	return;
173    }
174    if (vasprintf(&str, fmt, args) < 0 || str == NULL) {
175	HEIMDAL_MUTEX_unlock(context->mutex);
176	return;
177    }
178    if (context->error_string) {
179	int e;
180
181	e = asprintf(&str2, "%s: %s", str, context->error_string);
182	free(context->error_string);
183	if (e < 0 || str2 == NULL)
184	    context->error_string = NULL;
185	else
186	    context->error_string = str2;
187	free(str);
188    } else
189	context->error_string = str;
190    HEIMDAL_MUTEX_unlock(context->mutex);
191}
192
193
194/**
195 * Return the error message in context. On error or no error string,
196 * the function returns NULL.
197 *
198 * @param context Kerberos 5 context
199 *
200 * @return an error string, needs to be freed with
201 * krb5_free_error_message(). The functions return NULL on error.
202 *
203 * @ingroup krb5_error
204 */
205
206KRB5_LIB_FUNCTION char * KRB5_LIB_CALL
207krb5_get_error_string(krb5_context context)
208{
209    char *ret = NULL;
210
211    HEIMDAL_MUTEX_lock(context->mutex);
212    if (context->error_string)
213	ret = strdup(context->error_string);
214    HEIMDAL_MUTEX_unlock(context->mutex);
215    return ret;
216}
217
218KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL
219krb5_have_error_string(krb5_context context)
220{
221    char *str;
222    HEIMDAL_MUTEX_lock(context->mutex);
223    str = context->error_string;
224    HEIMDAL_MUTEX_unlock(context->mutex);
225    return str != NULL;
226}
227
228/**
229 * Return the error message for `code' in context. On memory
230 * allocation error the function returns NULL.
231 *
232 * @param context Kerberos 5 context
233 * @param code Error code related to the error
234 *
235 * @return an error string, needs to be freed with
236 * krb5_free_error_message(). The functions return NULL on error.
237 *
238 * @ingroup krb5_error
239 */
240
241KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL
242krb5_get_error_message(krb5_context context, krb5_error_code code)
243{
244    char *str = NULL;
245    const char *cstr = NULL;
246    char buf[128];
247    int free_context = 0;
248
249    if (code == 0)
250	return strdup("Success");
251
252    /*
253     * The MIT version of this function ignores the krb5_context
254     * and several widely deployed applications call krb5_get_error_message()
255     * with a NULL context in order to translate an error code as a
256     * replacement for error_message().  Another reason a NULL context
257     * might be provided is if the krb5_init_context() call itself
258     * failed.
259     */
260    if (context)
261    {
262        HEIMDAL_MUTEX_lock(context->mutex);
263        if (context->error_string &&
264            (code == context->error_code || context->error_code == 0))
265        {
266            str = strdup(context->error_string);
267        }
268        HEIMDAL_MUTEX_unlock(context->mutex);
269
270        if (str)
271            return str;
272    }
273    else
274    {
275        if (krb5_init_context(&context) == 0)
276            free_context = 1;
277    }
278
279    if (context)
280        cstr = com_right_r(context->et_list, code, buf, sizeof(buf));
281
282    if (free_context)
283        krb5_free_context(context);
284
285    if (cstr)
286        return strdup(cstr);
287
288    cstr = error_message(code);
289    if (cstr)
290        return strdup(cstr);
291
292    if (asprintf(&str, "<unknown error: %d>", (int)code) == -1 || str == NULL)
293	return NULL;
294
295    return str;
296}
297
298
299/**
300 * Free the error message returned by krb5_get_error_message().
301 *
302 * @param context Kerberos context
303 * @param msg error message to free, returned byg
304 *        krb5_get_error_message().
305 *
306 * @ingroup krb5_error
307 */
308
309KRB5_LIB_FUNCTION void KRB5_LIB_CALL
310krb5_free_error_message(krb5_context context, const char *msg)
311{
312    free(rk_UNCONST(msg));
313}
314
315
316/**
317 * Return the error string for the error code. The caller must not
318 * free the string.
319 *
320 * This function is deprecated since its not threadsafe.
321 *
322 * @param context Kerberos 5 context.
323 * @param code Kerberos error code.
324 *
325 * @return the error message matching code
326 *
327 * @ingroup krb5
328 */
329
330KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL
331krb5_get_err_text(krb5_context context, krb5_error_code code)
332    KRB5_DEPRECATED_FUNCTION("Use X instead")
333{
334    const char *p = NULL;
335    if(context != NULL)
336	p = com_right(context->et_list, code);
337    if(p == NULL)
338	p = strerror(code);
339    if (p == NULL)
340	p = "Unknown error";
341    return p;
342}
343