1 /***********************************************************
2 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
3 
4 Permission is hereby granted, free of charge, to any person obtaining a
5 copy of this software and associated documentation files (the "Software"),
6 to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 and/or sell copies of the Software, and to permit persons to whom the
9 Software is furnished to do so, subject to the following conditions:
10 
11 The above copyright notice and this permission notice (including the next
12 paragraph) shall be included in all copies or substantial portions of the
13 Software.
14 
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 DEALINGS IN THE SOFTWARE.
22 
23 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
24 
25                         All Rights Reserved
26 
27 Permission to use, copy, modify, and distribute this software and its
28 documentation for any purpose and without fee is hereby granted,
29 provided that the above copyright notice appear in all copies and that
30 both that copyright notice and this permission notice appear in
31 supporting documentation, and that the name of Digital not be
32 used in advertising or publicity pertaining to distribution of the
33 software without specific, written prior permission.
34 
35 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
36 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
37 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
38 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
39 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
40 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
41 SOFTWARE.
42 
43 ******************************************************************/
44 
45 /*
46 
47 Copyright 1987, 1988, 1998  The Open Group
48 
49 Permission to use, copy, modify, distribute, and sell this software and its
50 documentation for any purpose is hereby granted without fee, provided that
51 the above copyright notice appear in all copies and that both that
52 copyright notice and this permission notice appear in supporting
53 documentation.
54 
55 The above copyright notice and this permission notice shall be included in
56 all copies or substantial portions of the Software.
57 
58 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
59 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
60 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
61 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
62 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
63 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
64 
65 Except as contained in this notice, the name of The Open Group shall not be
66 used in advertising or otherwise to promote the sale, use or other dealings
67 in this Software without prior written authorization from The Open Group.
68 
69 */
70 
71 #ifdef HAVE_CONFIG_H
72 #include <config.h>
73 #endif
74 #include "IntrinsicI.h"
75 #include <stdio.h>
76 #include <stdlib.h>
77 
78 /* The error handlers in the application context aren't used since we can't
79    come up with a uniform way of using them.  If you can, define
80    GLOBALERRORS to be FALSE (or 0). */
81 
82 #ifndef GLOBALERRORS
83 #define GLOBALERRORS 1
84 #endif
85 
86 static void InitErrorHandling(XrmDatabase *);
87 
88 #if GLOBALERRORS
89 static XrmDatabase errorDB = NULL;
90 static Boolean error_inited = FALSE;
91 void _XtDefaultErrorMsg(String, String, String, String, String *, Cardinal *);
92 void _XtDefaultWarningMsg(String, String, String, String, String *, Cardinal *);
93 void
94 _XtDefaultError(String)
95     _X_NORETURN;
96 void
97 _XtDefaultWarning(String);
98 static XtErrorMsgHandler errorMsgHandler = _XtDefaultErrorMsg;
99 static XtErrorMsgHandler warningMsgHandler = _XtDefaultWarningMsg;
100 static XtErrorHandler errorHandler _X_NORETURN = _XtDefaultError;
101 static XtErrorHandler warningHandler = _XtDefaultWarning;
102 #endif                          /* GLOBALERRORS */
103 
104 XrmDatabase *
XtGetErrorDatabase(void)105 XtGetErrorDatabase(void)
106 {
107     XrmDatabase *retval;
108 
109 #if GLOBALERRORS
110     LOCK_PROCESS;
111     retval = &errorDB;
112     UNLOCK_PROCESS;
113 #else
114     retval = XtAppGetErrorDatabase(_XtDefaultAppContext());
115 #endif                          /* GLOBALERRORS */
116     return retval;
117 }
118 
119 XrmDatabase *
XtAppGetErrorDatabase(XtAppContext app _X_UNUSED)120 XtAppGetErrorDatabase(XtAppContext app _X_UNUSED)
121 {
122     XrmDatabase *retval;
123 
124 #if GLOBALERRORS
125     LOCK_PROCESS;
126     retval = &errorDB;
127     UNLOCK_PROCESS;
128 #else
129     LOCK_APP(app);
130     retval = &app->errorDB;
131     UNLOCK_APP(app);
132 #endif                          /* GLOBALERRORS */
133     return retval;
134 }
135 
136 void
XtGetErrorDatabaseText(register _Xconst char * name,register _Xconst char * type,register _Xconst char * class,_Xconst char * defaultp,_XtString buffer,int nbytes)137 XtGetErrorDatabaseText(register _Xconst char *name,
138                        register _Xconst char *type,
139                        register _Xconst char *class,
140                        _Xconst char *defaultp,
141                        _XtString buffer, int nbytes)
142 {
143 #if GLOBALERRORS
144     XtAppGetErrorDatabaseText(NULL,
145                               name, type, class, defaultp, buffer, nbytes,
146                               NULL);
147 #else
148     XtAppGetErrorDatabaseText(_XtDefaultAppContext(),
149                               name, type, class, defaultp, buffer, nbytes,
150                               NULL);
151 #endif                          /* GLOBALERRORS */
152 }
153 
154 void
XtAppGetErrorDatabaseText(XtAppContext app _X_UNUSED,register _Xconst char * name,register _Xconst char * type,register _Xconst char * class,_Xconst char * defaultp,_XtString buffer,int nbytes,XrmDatabase db)155 XtAppGetErrorDatabaseText(XtAppContext app _X_UNUSED,
156                           register _Xconst char *name,
157                           register _Xconst char *type,
158                           register _Xconst char *class,
159                           _Xconst char *defaultp,
160                           _XtString buffer,
161                           int nbytes,
162                           XrmDatabase db)
163 {
164     String str_class;
165     _XtString type_str;
166     XrmValue result;
167     char *str_name = NULL;
168     char *temp = NULL;
169 
170 #if GLOBALERRORS
171     LOCK_PROCESS;
172     if (error_inited == FALSE) {
173         InitErrorHandling(&errorDB);
174         error_inited = TRUE;
175     }
176 #else
177     LOCK_APP(app);
178     if (app->error_inited == FALSE) {
179         InitErrorHandling(&app->errorDB);
180         app->error_inited = TRUE;
181     }
182 #endif                          /* GLOBALERRORS */
183     if (!(str_name = ALLOCATE_LOCAL(strlen(name) + strlen(type) + 2)))
184         _XtAllocError(NULL);
185     (void) sprintf(str_name, "%s.%s", name, type);
186     /* XrmGetResource requires the name and class to be fully qualified
187      * and to have the same number of components. */
188     str_class = (String) class;
189     if (!strchr(class, '.')) {
190         if (!(temp = ALLOCATE_LOCAL(2 * strlen(class) + 2)))
191             _XtAllocError(NULL);
192         (void) sprintf(temp, "%s.%s", class, class);
193         str_class = temp;
194     }
195     if (db == NULL) {
196 #if GLOBALERRORS
197         (void) XrmGetResource(errorDB, str_name, str_class, &type_str, &result);
198 #else
199         (void) XrmGetResource(app->errorDB, str_name, str_class, &type_str,
200                               &result);
201 #endif                          /* GLOBALERRORS */
202     }
203     else
204         (void) XrmGetResource(db, str_name, str_class, &type_str, &result);
205     if (result.addr) {
206         (void) strncpy(buffer, result.addr, (size_t) nbytes);
207         if (result.size > (unsigned) nbytes)
208             buffer[nbytes - 1] = 0;
209     }
210     else {
211         int len = (int) strlen(defaultp);
212 
213         if (len >= nbytes)
214             len = nbytes - 1;
215         (void) memmove(buffer, defaultp, (size_t) len);
216         buffer[len] = '\0';
217     }
218     if (str_name)
219         DEALLOCATE_LOCAL(str_name);
220     if (temp)
221         DEALLOCATE_LOCAL(temp);
222 #if GLOBALERRORS
223     UNLOCK_PROCESS;
224 #else
225     UNLOCK_APP(app);
226 #endif
227 }
228 
229 static void
InitErrorHandling(XrmDatabase * db)230 InitErrorHandling(XrmDatabase *db)
231 {
232     XrmDatabase errordb;
233 
234     errordb = XrmGetFileDatabase(ERRORDB);
235     XrmMergeDatabases(errordb, db);
236 }
237 
238 static void
DefaultMsg(String name,String type,String class,String defaultp,String * params,Cardinal * num_params,Bool error,void (* fn)(_Xconst _XtString))239 DefaultMsg(String name,
240            String type,
241            String class,
242            String defaultp,
243            String *params,
244            Cardinal *num_params,
245            Bool error,
246            void (*fn) (_Xconst _XtString))
247 {
248 #define BIGBUF 1024
249     char buffer[BIGBUF];
250     char *message;
251 
252     XtGetErrorDatabaseText(name, type, class, defaultp, buffer, BIGBUF);
253 /*need better solution here, perhaps use lower level printf primitives? */
254     if (params == NULL || num_params == NULL || *num_params == 0)
255         (*fn) (buffer);
256 #ifndef WIN32                   /* and OS/2 */
257     else if ((getuid() != geteuid()) || getuid() == 0) {
258         if ((error && errorHandler == _XtDefaultError) ||
259             (!error && warningHandler == _XtDefaultWarning)) {
260             /*
261              * if it's just going to go to stderr anyway, then we'll
262              * fprintf to stderr ourselves and skip the insecure sprintf.
263              */
264             Cardinal i = *num_params;
265             String par[10];
266 
267             if (i > 10)
268                 i = 10;
269             (void) memmove((char *) par, (char *) params, i * sizeof(String));
270             memset(&par[i], 0, (10 - i) * sizeof(String));
271             (void) fprintf(stderr, "%s%s",
272                            error ? XTERROR_PREFIX : XTWARNING_PREFIX,
273                            error ? "Error: " : "Warning: ");
274             (void) fprintf(stderr, buffer,
275                            par[0], par[1], par[2], par[3], par[4],
276                            par[5], par[6], par[7], par[8], par[9]);
277             (void) fprintf(stderr, "%c", '\n');
278             if (i != *num_params)
279                 (*fn) ("Some arguments in previous message were lost");
280             else if (error)
281                 exit(1);
282         }
283         else {
284             /*
285              * can't tell what it might do, so we'll play it safe
286              */
287             XtWarning("\
288 This program is an suid-root program or is being run by the root user.\n\
289 The full text of the error or warning message cannot be safely formatted\n\
290 in this environment. You may get a more descriptive message by running the\n\
291 program as a non-root user or by removing the suid bit on the executable.");
292             (*fn) (buffer);     /* if *fn is an ErrorHandler it should exit */
293         }
294     }
295 #endif
296     else {
297         /*
298          * If you have snprintf the worst thing that could happen is you'd
299          * lose some information. Without snprintf you're probably going to
300          * scramble your heap and perhaps SEGV -- sooner or later.
301          * If it hurts when you go like this then don't go like this! :-)
302          */
303         Cardinal i = *num_params;
304         String par[10];
305 
306         if (i > 10)
307             i = 10;
308         (void) memmove((char *) par, (char *) params, i * sizeof(String));
309         memset(&par[i], 0, (10 - i) * sizeof(String));
310         if (i != *num_params)
311             XtWarning("Some arguments in following message were lost");
312         /*
313          * resist any temptation you might have to make `message' a
314          * local buffer on the stack. Doing so is a security hole
315          * in programs executing as root. Error and Warning
316          * messages shouldn't be called frequently enough for this
317          * to be a performance issue.
318          */
319         if ((message = __XtMalloc(BIGBUF))) {
320             (void) snprintf(message, BIGBUF, buffer,
321                             par[0], par[1], par[2], par[3], par[4],
322                             par[5], par[6], par[7], par[8], par[9]);
323             (*fn) (message);
324             XtFree(message);
325         }
326         else {
327             XtWarning
328                 ("Memory allocation failed, arguments in the following message were lost");
329             (*fn) (buffer);
330         }
331     }
332 }
333 
334 void
_XtDefaultErrorMsg(String name,String type,String class,String defaultp,String * params,Cardinal * num_params)335 _XtDefaultErrorMsg(String name,
336                    String type,
337                    String class,
338                    String defaultp,
339                    String *params,
340                    Cardinal *num_params)
341 {
342     DefaultMsg(name, type, class, defaultp, params, num_params, True, XtError);
343 }
344 
345 void
_XtDefaultWarningMsg(String name,String type,String class,String defaultp,String * params,Cardinal * num_params)346 _XtDefaultWarningMsg(String name,
347                      String type,
348                      String class,
349                      String defaultp,
350                      String *params,
351                      Cardinal *num_params)
352 {
353     DefaultMsg(name, type, class, defaultp, params, num_params, False,
354                XtWarning);
355 }
356 
357 void
XtErrorMsg(_Xconst char * name,_Xconst char * type,_Xconst char * class,_Xconst char * defaultp,String * params,Cardinal * num_params)358 XtErrorMsg(_Xconst char *name,
359            _Xconst char *type,
360            _Xconst char *class,
361            _Xconst char *defaultp,
362            String *params,
363            Cardinal *num_params)
364 {
365 #if GLOBALERRORS
366     LOCK_PROCESS;
367     (*errorMsgHandler) ((String) name, (String) type, (String) class,
368                         (String) defaultp, params, num_params);
369     UNLOCK_PROCESS;
370     exit(1);
371 #else
372     XtAppErrorMsg(_XtDefaultAppContext(), name, type, class,
373                   defaultp, params, num_params);
374 #endif                          /* GLOBALERRORS */
375 }
376 
377 void
XtAppErrorMsg(XtAppContext app _X_UNUSED,_Xconst char * name,_Xconst char * type,_Xconst char * class,_Xconst char * defaultp,String * params,Cardinal * num_params)378 XtAppErrorMsg(XtAppContext app _X_UNUSED,
379               _Xconst char *name,
380               _Xconst char *type,
381               _Xconst char *class,
382               _Xconst char *defaultp,
383               String *params,
384               Cardinal *num_params)
385 {
386 #if GLOBALERRORS
387     LOCK_PROCESS;
388     (*errorMsgHandler) ((String) name, (String) type, (String) class,
389                         (String) defaultp, params, num_params);
390     UNLOCK_PROCESS;
391     exit(1);
392 #else
393     LOCK_APP(app);
394     (*app->errorMsgHandler) (name, type, class, defaultp, params, num_params);
395     UNLOCK_APP(app);
396 #endif                          /* GLOBALERRORS */
397 }
398 
399 void
XtWarningMsg(_Xconst char * name,_Xconst char * type,_Xconst char * class,_Xconst char * defaultp,String * params,Cardinal * num_params)400 XtWarningMsg(_Xconst char *name,
401              _Xconst char *type,
402              _Xconst char *class,
403              _Xconst char *defaultp,
404              String *params,
405              Cardinal *num_params)
406 {
407 #if GLOBALERRORS
408     LOCK_PROCESS;
409     (*warningMsgHandler) ((String) name, (String) type, (String) class,
410                           (String) defaultp, params, num_params);
411     UNLOCK_PROCESS;
412 #else
413     XtAppWarningMsg(_XtDefaultAppContext(), name, type, class,
414                     defaultp, params, num_params);
415 #endif                          /* GLOBALERRORS */
416 }
417 
418 void
XtAppWarningMsg(XtAppContext app _X_UNUSED,_Xconst char * name,_Xconst char * type,_Xconst char * class,_Xconst char * defaultp,String * params,Cardinal * num_params)419 XtAppWarningMsg(XtAppContext app _X_UNUSED,
420                 _Xconst char *name,
421                 _Xconst char *type,
422                 _Xconst char *class,
423                 _Xconst char *defaultp,
424                 String *params,
425                 Cardinal *num_params)
426 {
427 #if GLOBALERRORS
428     LOCK_PROCESS;
429     (*warningMsgHandler) ((String) name, (String) type, (String) class,
430                           (String) defaultp, params, num_params);
431     UNLOCK_PROCESS;
432 #else
433     LOCK_APP(app);
434     (*app->warningMsgHandler) (name, type, class, defaultp, params, num_params);
435     UNLOCK_APP(app);
436 #endif                          /* GLOBALERRORS */
437 }
438 
439 void
XtSetErrorMsgHandler(XtErrorMsgHandler handler _X_NORETURN)440 XtSetErrorMsgHandler(XtErrorMsgHandler handler _X_NORETURN)
441 {
442 #if GLOBALERRORS
443     LOCK_PROCESS;
444     if (handler != NULL)
445         errorMsgHandler = handler;
446     else
447         errorMsgHandler = _XtDefaultErrorMsg;
448     UNLOCK_PROCESS;
449 #else
450     XtAppSetErrorMsgHandler(_XtDefaultAppContext(), handler);
451 #endif                          /* GLOBALERRORS */
452 }
453 
454 XtErrorMsgHandler
XtAppSetErrorMsgHandler(XtAppContext app _X_UNUSED,XtErrorMsgHandler handler _X_NORETURN)455 XtAppSetErrorMsgHandler(XtAppContext app _X_UNUSED,
456                         XtErrorMsgHandler handler _X_NORETURN)
457 {
458     XtErrorMsgHandler old;
459 
460 #if GLOBALERRORS
461     LOCK_PROCESS;
462     old = errorMsgHandler;
463     if (handler != NULL)
464         errorMsgHandler = handler;
465     else
466         errorMsgHandler = _XtDefaultErrorMsg;
467     UNLOCK_PROCESS;
468 #else
469     LOCK_APP(app);
470     old = app->errorMsgHandler;
471     if (handler != NULL)
472         app->errorMsgHandler = handler;
473     else
474         app->errorMsgHandler = _XtDefaultErrorMsg;
475     UNLOCK_APP(app);
476 #endif                          /* GLOBALERRORS */
477     return old;
478 }
479 
480 void
XtSetWarningMsgHandler(XtErrorMsgHandler handler)481 XtSetWarningMsgHandler(XtErrorMsgHandler handler)
482 {
483 #if GLOBALERRORS
484     LOCK_PROCESS;
485     if (handler != NULL)
486         warningMsgHandler = handler;
487     else
488         warningMsgHandler = _XtDefaultWarningMsg;
489     UNLOCK_PROCESS;
490 #else
491     XtAppSetWarningMsgHandler(_XtDefaultAppContext(), handler);
492 #endif                          /* GLOBALERRORS */
493 }
494 
495 XtErrorMsgHandler
XtAppSetWarningMsgHandler(XtAppContext app _X_UNUSED,XtErrorMsgHandler handler)496 XtAppSetWarningMsgHandler(XtAppContext app _X_UNUSED, XtErrorMsgHandler handler)
497 {
498     XtErrorMsgHandler old;
499 
500 #if GLOBALERRORS
501     LOCK_PROCESS;
502     old = warningMsgHandler;
503     if (handler != NULL)
504         warningMsgHandler = handler;
505     else
506         warningMsgHandler = _XtDefaultWarningMsg;
507     UNLOCK_PROCESS;
508 #else
509     LOCK_APP(app);
510     old = app->warningMsgHandler;
511     if (handler != NULL)
512         app->warningMsgHandler = handler;
513     else
514         app->warningMsgHandler = _XtDefaultWarningMsg;
515     UNLOCK_APP(app);
516 #endif                          /* GLOBALERRORS */
517     return old;
518 }
519 
520 void
_XtDefaultError(String message)521 _XtDefaultError(String message)
522 {
523     if (message && *message)
524         (void) fprintf(stderr, "%sError: %s\n", XTERROR_PREFIX, message);
525     exit(1);
526 }
527 
528 void
_XtDefaultWarning(String message)529 _XtDefaultWarning(String message)
530 {
531     if (message && *message)
532         (void) fprintf(stderr, "%sWarning: %s\n", XTWARNING_PREFIX, message);
533     return;
534 }
535 
536 void
XtError(_Xconst char * message)537 XtError(_Xconst char *message)
538 {
539 #if GLOBALERRORS
540     LOCK_PROCESS;
541     (*errorHandler) ((String) message);
542     UNLOCK_PROCESS;
543 #else
544     XtAppError(_XtDefaultAppContext(), message);
545 #endif                          /* GLOBALERRORS */
546 }
547 
548 void
XtAppError(XtAppContext app _X_UNUSED,_Xconst char * message)549 XtAppError(XtAppContext app _X_UNUSED, _Xconst char *message)
550 {
551 #if GLOBALERRORS
552     LOCK_PROCESS;
553     (*errorHandler) ((String) message);
554     UNLOCK_PROCESS;
555 #else
556     LOCK_APP(app);
557     (*app->errorHandler) (message);
558     UNLOCK_APP(app);
559 #endif                          /* GLOBALERRORS */
560 }
561 
562 void
XtWarning(_Xconst char * message)563 XtWarning(_Xconst char *message)
564 {
565 #if GLOBALERRORS
566     LOCK_PROCESS;
567     (*warningHandler) ((String) message);
568     UNLOCK_PROCESS;
569 #else
570     XtAppWarning(_XtDefaultAppContext(), message);
571 #endif                          /* GLOBALERRORS */
572 }
573 
574 void
XtAppWarning(XtAppContext app _X_UNUSED,_Xconst char * message)575 XtAppWarning(XtAppContext app _X_UNUSED, _Xconst char *message)
576 {
577 #if GLOBALERRORS
578     LOCK_PROCESS;
579     (*warningHandler) ((String) message);
580     UNLOCK_PROCESS;
581 #else
582     LOCK_APP(app);
583     (*app->warningHandler) (message);
584     UNLOCK_APP(app);
585 #endif                          /* GLOBALERRORS */
586 }
587 
588 void
XtSetErrorHandler(XtErrorHandler handler _X_NORETURN)589 XtSetErrorHandler(XtErrorHandler handler _X_NORETURN)
590 {
591 #if GLOBALERRORS
592     LOCK_PROCESS;
593     if (handler != NULL)
594         errorHandler = handler;
595     else
596         errorHandler = _XtDefaultError;
597     UNLOCK_PROCESS;
598 #else
599     XtAppSetErrorHandler(_XtDefaultAppContext(), handler);
600 #endif                          /* GLOBALERRORS */
601 }
602 
603 XtErrorHandler
XtAppSetErrorHandler(XtAppContext app _X_UNUSED,XtErrorHandler handler _X_NORETURN)604 XtAppSetErrorHandler(XtAppContext app _X_UNUSED,
605                      XtErrorHandler handler _X_NORETURN)
606 {
607     XtErrorHandler old;
608 
609 #if GLOBALERRORS
610     LOCK_PROCESS;
611     old = errorHandler;
612     if (handler != NULL)
613         errorHandler = handler;
614     else
615         errorHandler = _XtDefaultError;
616     UNLOCK_PROCESS;
617 #else
618     LOCK_APP(app);
619     old = app->errorHandler;
620     if (handler != NULL)
621         app->errorHandler = handler;
622     else
623         app->errorHandler = _XtDefaultError;
624     UNLOCK_APP(app);
625 #endif                          /* GLOBALERRORS */
626     return old;
627 }
628 
629 void
XtSetWarningHandler(XtErrorHandler handler)630 XtSetWarningHandler(XtErrorHandler handler)
631 {
632 #if GLOBALERRORS
633     LOCK_PROCESS;
634     if (handler != NULL)
635         warningHandler = handler;
636     else
637         warningHandler = _XtDefaultWarning;
638     UNLOCK_PROCESS;
639 #else
640     XtAppSetWarningHandler(_XtDefaultAppContext(), handler);
641 #endif                          /* GLOBALERRORS */
642 }
643 
644 XtErrorHandler
XtAppSetWarningHandler(XtAppContext app _X_UNUSED,XtErrorHandler handler)645 XtAppSetWarningHandler(XtAppContext app _X_UNUSED, XtErrorHandler handler)
646 {
647     XtErrorHandler old;
648 
649 #if GLOBALERRORS
650     LOCK_PROCESS;
651     old = warningHandler;
652     if (handler != NULL)
653         warningHandler = handler;
654     else
655         warningHandler = _XtDefaultWarning;
656     UNLOCK_PROCESS;
657 #else
658     LOCK_APP(app);
659     old = app->warningHandler;
660     if (handler != NULL)
661         app->warningHandler = handler;
662     else
663         app->warningHandler = _XtDefaultWarning;
664     UNLOCK_APP(app);
665 #endif                          /* GLOBALERRORS */
666     return old;
667 }
668 
669 void
_XtSetDefaultErrorHandlers(XtErrorMsgHandler * errMsg _X_UNUSED,XtErrorMsgHandler * warnMsg _X_UNUSED,XtErrorHandler * err _X_UNUSED,XtErrorHandler * warn _X_UNUSED)670 _XtSetDefaultErrorHandlers(XtErrorMsgHandler *errMsg _X_UNUSED,
671                            XtErrorMsgHandler *warnMsg _X_UNUSED,
672                            XtErrorHandler *err _X_UNUSED,
673                            XtErrorHandler *warn _X_UNUSED)
674 {
675 #ifndef GLOBALERRORS
676     LOCK_PROCESS;
677     *errMsg = _XtDefaultErrorMsg;
678     *warnMsg = _XtDefaultWarningMsg;
679     *err = _XtDefaultError;
680     *warn = _XtDefaultWarning;
681     UNLOCK_PROCESS;
682 #endif                          /* GLOBALERRORS */
683 }
684