1 /* $NetBSD: warn.c,v 1.1.1.2 2014/04/24 12:45:51 pettai Exp $ */ 2 3 /* 4 * Copyright (c) 1997 - 2001 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 #include "krb5_locl.h" 37 #include <err.h> 38 39 static krb5_error_code _warnerr(krb5_context context, int do_errtext, 40 krb5_error_code code, int level, const char *fmt, va_list ap) 41 __attribute__((__format__(__printf__, 5, 0))); 42 43 static krb5_error_code 44 _warnerr(krb5_context context, int do_errtext, 45 krb5_error_code code, int level, const char *fmt, va_list ap) 46 { 47 char xfmt[7] = ""; 48 const char *args[2], **arg; 49 char *msg = NULL; 50 const char *err_str = NULL; 51 krb5_error_code ret; 52 53 args[0] = args[1] = NULL; 54 arg = args; 55 if(fmt){ 56 strlcat(xfmt, "%s", sizeof(xfmt)); 57 if(do_errtext) 58 strlcat(xfmt, ": ", sizeof(xfmt)); 59 ret = vasprintf(&msg, fmt, ap); 60 if(ret < 0 || msg == NULL) 61 return ENOMEM; 62 *arg++ = msg; 63 } 64 if(context && do_errtext){ 65 strlcat(xfmt, "%s", sizeof(xfmt)); 66 67 err_str = krb5_get_error_message(context, code); 68 if (err_str != NULL) { 69 *arg = err_str; 70 } else { 71 *arg= "<unknown error>"; 72 } 73 } 74 75 if(context && context->warn_dest) 76 krb5_log(context, context->warn_dest, level, xfmt, args[0], args[1]); 77 else 78 warnx(xfmt, args[0], args[1]); 79 free(msg); 80 krb5_free_error_message(context, err_str); 81 return 0; 82 } 83 84 #define FUNC(ETEXT, CODE, LEVEL) \ 85 krb5_error_code ret; \ 86 va_list ap; \ 87 va_start(ap, fmt); \ 88 ret = _warnerr(context, ETEXT, CODE, LEVEL, fmt, ap); \ 89 va_end(ap); 90 91 #undef __attribute__ 92 #define __attribute__(X) 93 94 /** 95 * Log a warning to the log, default stderr, include the error from 96 * the last failure. 97 * 98 * @param context A Kerberos 5 context. 99 * @param code error code of the last error 100 * @param fmt message to print 101 * @param ap arguments 102 * 103 * @ingroup krb5_error 104 */ 105 106 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 107 krb5_vwarn(krb5_context context, krb5_error_code code, 108 const char *fmt, va_list ap) 109 __attribute__ ((format (printf, 3, 0))) 110 { 111 return _warnerr(context, 1, code, 1, fmt, ap); 112 } 113 114 /** 115 * Log a warning to the log, default stderr, include the error from 116 * the last failure. 117 * 118 * @param context A Kerberos 5 context. 119 * @param code error code of the last error 120 * @param fmt message to print 121 * 122 * @ingroup krb5_error 123 */ 124 125 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 126 krb5_warn(krb5_context context, krb5_error_code code, const char *fmt, ...) 127 __attribute__ ((format (printf, 3, 4))) 128 { 129 FUNC(1, code, 1); 130 return ret; 131 } 132 133 /** 134 * Log a warning to the log, default stderr. 135 * 136 * @param context A Kerberos 5 context. 137 * @param fmt message to print 138 * @param ap arguments 139 * 140 * @ingroup krb5_error 141 */ 142 143 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 144 krb5_vwarnx(krb5_context context, const char *fmt, va_list ap) 145 __attribute__ ((format (printf, 2, 0))) 146 { 147 return _warnerr(context, 0, 0, 1, fmt, ap); 148 } 149 150 /** 151 * Log a warning to the log, default stderr. 152 * 153 * @param context A Kerberos 5 context. 154 * @param fmt message to print 155 * 156 * @ingroup krb5_error 157 */ 158 159 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 160 krb5_warnx(krb5_context context, const char *fmt, ...) 161 __attribute__ ((format (printf, 2, 3))) 162 { 163 FUNC(0, 0, 1); 164 return ret; 165 } 166 167 /** 168 * Log a warning to the log, default stderr, include bthe error from 169 * the last failure and then exit. 170 * 171 * @param context A Kerberos 5 context 172 * @param eval the exit code to exit with 173 * @param code error code of the last error 174 * @param fmt message to print 175 * @param ap arguments 176 * 177 * @ingroup krb5_error 178 */ 179 180 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 181 krb5_verr(krb5_context context, int eval, krb5_error_code code, 182 const char *fmt, va_list ap) 183 __attribute__ ((noreturn, format (printf, 4, 0))) 184 { 185 _warnerr(context, 1, code, 0, fmt, ap); 186 exit(eval); 187 UNREACHABLE(return 0); 188 } 189 190 /** 191 * Log a warning to the log, default stderr, include bthe error from 192 * the last failure and then exit. 193 * 194 * @param context A Kerberos 5 context 195 * @param eval the exit code to exit with 196 * @param code error code of the last error 197 * @param fmt message to print 198 * 199 * @ingroup krb5_error 200 */ 201 202 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 203 krb5_err(krb5_context context, int eval, krb5_error_code code, 204 const char *fmt, ...) 205 __attribute__ ((noreturn, format (printf, 4, 5))) 206 { 207 FUNC(1, code, 0); 208 exit(eval); 209 UNREACHABLE(return 0); 210 } 211 212 /** 213 * Log a warning to the log, default stderr, and then exit. 214 * 215 * @param context A Kerberos 5 context 216 * @param eval the exit code to exit with 217 * @param fmt message to print 218 * @param ap arguments 219 * 220 * @ingroup krb5_error 221 */ 222 223 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 224 krb5_verrx(krb5_context context, int eval, const char *fmt, va_list ap) 225 __attribute__ ((noreturn, format (printf, 3, 0))) 226 { 227 _warnerr(context, 0, 0, 0, fmt, ap); 228 exit(eval); 229 UNREACHABLE(return 0); 230 } 231 232 /** 233 * Log a warning to the log, default stderr, and then exit. 234 * 235 * @param context A Kerberos 5 context 236 * @param eval the exit code to exit with 237 * @param fmt message to print 238 * 239 * @ingroup krb5_error 240 */ 241 242 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 243 krb5_errx(krb5_context context, int eval, const char *fmt, ...) 244 __attribute__ ((noreturn, format (printf, 3, 4))) 245 { 246 FUNC(0, 0, 0); 247 exit(eval); 248 UNREACHABLE(return 0); 249 } 250 251 /** 252 * Log a warning to the log, default stderr, include bthe error from 253 * the last failure and then abort. 254 * 255 * @param context A Kerberos 5 context 256 * @param code error code of the last error 257 * @param fmt message to print 258 * @param ap arguments 259 * 260 * @ingroup krb5_error 261 */ 262 263 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 264 krb5_vabort(krb5_context context, krb5_error_code code, 265 const char *fmt, va_list ap) 266 __attribute__ ((noreturn, format (printf, 3, 0))) 267 { 268 _warnerr(context, 1, code, 0, fmt, ap); 269 abort(); 270 UNREACHABLE(return 0); 271 } 272 273 /** 274 * Log a warning to the log, default stderr, include the error from 275 * the last failure and then abort. 276 * 277 * @param context A Kerberos 5 context 278 * @param code error code of the last error 279 * @param fmt message to print 280 * 281 * @ingroup krb5_error 282 */ 283 284 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 285 krb5_abort(krb5_context context, krb5_error_code code, const char *fmt, ...) 286 __attribute__ ((noreturn, format (printf, 3, 4))) 287 { 288 FUNC(1, code, 0); 289 abort(); 290 UNREACHABLE(return 0); 291 } 292 293 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 294 krb5_vabortx(krb5_context context, const char *fmt, va_list ap) 295 __attribute__ ((noreturn, format (printf, 2, 0))) 296 { 297 _warnerr(context, 0, 0, 0, fmt, ap); 298 abort(); 299 UNREACHABLE(return 0); 300 } 301 302 /** 303 * Log a warning to the log, default stderr, and then abort. 304 * 305 * @param context A Kerberos 5 context 306 * @param code error code of the last error 307 * @param fmt message to print 308 * 309 * @ingroup krb5_error 310 */ 311 312 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 313 krb5_abortx(krb5_context context, const char *fmt, ...) 314 __attribute__ ((noreturn, format (printf, 2, 3))) 315 { 316 FUNC(0, 0, 0); 317 abort(); 318 UNREACHABLE(return 0); 319 } 320 321 /** 322 * Set the default logging facility. 323 * 324 * @param context A Kerberos 5 context 325 * @param fac Facility to use for logging. 326 * 327 * @ingroup krb5_error 328 */ 329 330 KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL 331 krb5_set_warn_dest(krb5_context context, krb5_log_facility *fac) 332 { 333 context->warn_dest = fac; 334 return 0; 335 } 336 337 /** 338 * Get the default logging facility. 339 * 340 * @param context A Kerberos 5 context 341 * 342 * @ingroup krb5_error 343 */ 344 345 KRB5_LIB_FUNCTION krb5_log_facility * KRB5_LIB_CALL 346 krb5_get_warn_dest(krb5_context context) 347 { 348 return context->warn_dest; 349 } 350