static int xerror_handler(Display *d, XErrorEvent *e) {
if(e->request_code == X_GetImage)
return 0;
char buf[128];
/*
* construct the similar message format like X11 is using by default, but again, little
* bit different so we knows it comes from here
*/
snprintf(buf, sizeof(buf), "%d", e->request_code);
XGetErrorDatabaseText(d, "XRequest", buf, "%d", buf, sizeof(buf));
fprintf(stderr, "%s: ", buf);
XGetErrorText(d, e->error_code, buf, sizeof(buf));
fprintf(stderr, "%s\n", buf);
XGetErrorDatabaseText(d, "XlibMessage", "ResourceID", "%d", buf, sizeof(buf));
fprintf(stderr, " ");
fprintf(stderr, buf, e->resourceid);
fprintf(stderr, "\n");
return 0;
}
static int
x_error_handler( Display *d, XErrorEvent *ev)
{
int tail = guts. ri_tail;
int prev = tail;
char *name = "Prima";
char buf[BUFSIZ];
char mesg[BUFSIZ];
char number[32];
while ( tail != guts. ri_head) {
if ( guts. ri[ tail]. request > ev-> serial)
break;
prev = tail;
tail++;
if ( tail >= REQUEST_RING_SIZE)
tail = 0;
}
switch ( ev-> request_code) {
case 38: /* X_QueryPointer - apc_event uses sequence of XQueryPointer calls,
to find where the pointer belongs. The error is raised when one
of the windows disappears . */
case 42: /* X_SetInputFocus */
return 0;
}
#ifdef NEED_X11_EXTENSIONS_XRENDER_H
if ( ev-> request_code == guts. xft_xrender_major_opcode &&
ev-> request_code > 127 &&
ev-> error_code == BadLength)
/* Xrender large polygon request failed */
guts. xft_disable_large_fonts = 1;
#endif
XGetErrorText( d, ev-> error_code, buf, BUFSIZ);
XGetErrorDatabaseText( d, name, "XError", "X Error", mesg, BUFSIZ);
fprintf( stderr, "%s: %s, request: %d", mesg, buf, ev->request_code);
if ( ev->request_code < 128) {
sprintf( number, "%d", ev->request_code);
XGetErrorDatabaseText( d, "XRequest", number, "", buf, BUFSIZ);
fprintf( stderr, "(%s)", buf);
}
if ( tail == guts. ri_head && prev == guts. ri_head);
else if ( tail == guts. ri_head)
fprintf( stderr, ", after %s:%d\n",
guts. ri[ prev]. file, guts. ri[ prev]. line);
else
fprintf( stderr, ", between %s:%d and %s:%d\n",
guts. ri[ prev]. file, guts. ri[ prev]. line,
guts. ri[ tail]. file, guts. ri[ tail]. line);
return 0;
}
static int x11ErrorHandler(Display *d, XErrorEvent *e)
{
char msg[80], req[80], number[80];
bool ignore_badwindow = TRUE; // maybe temporary
if(initting && (e->request_code == X_ChangeWindowAttributes || e->request_code == X_GrabKey) && (e->error_code == BadAccess))
{
fputs(i18n("kwin: it looks like there's already a window manager running. kwin not started.\n").local8Bit(), stderr);
exit(1);
}
if(ignore_badwindow && (e->error_code == BadWindow || e->error_code == BadColor))
return 0;
XGetErrorText(d, e->error_code, msg, sizeof(msg));
sprintf(number, "%d", e->request_code);
XGetErrorDatabaseText(d, "XRequest", number, "<unknown>", req, sizeof(req));
fprintf(stderr, "kwin: %s(0x%lx): %s\n", req, e->resourceid, msg);
if(initting)
{
fputs(i18n("kwin: failure during initialization; aborting").local8Bit(), stderr);
exit(1);
}
return 0;
}
static int
x_error_handler(Display *display, XErrorEvent *error)
{ if ( !catchedErrorPce(PCE, NAME_xError) )
{ char msg[1024];
char request[100];
char buf[100];
/* XSetInputFocus() can generate a */
/* BadMatch that is hard to avoid */
if ( error->request_code == X_SetInputFocus &&
error->error_code == BadMatch )
return 0;
XGetErrorText(display, error->error_code, msg, 1024);
sprintf(buf, "%d", error->request_code);
XGetErrorDatabaseText(display, "XRequest", buf,
"Unknown request", request, 100);
Cprintf("X error of failed request: %s\n", msg);
Cprintf("Major opcode of failed request: %d (%s)\n",
error->request_code, request);
Cprintf("Minor opcode of failed request: %d\n", error->minor_code);
Cprintf("Resource id in failed request: 0x%x\n",
(unsigned int) error->resourceid);
Cprintf("Serial number of failed request: %ld\n", error->serial);
errorPce(NIL, NAME_xError);
}
return 0; /* what to return here? */
}
int xerrors(Display *d, XErrorEvent *event)
{
char msg[100];
char req[100];
char nmb[100];
if(wm_init == TRUE && event->error_code == BadAccess)
{
logmsg << "Another WM is already running\n";
exit(1);
}
#ifndef DEBUGMSG
if(event->error_code == BadWindow || event->error_code == BadMatch)
return 0;
#endif
XGetErrorText(d, event->error_code, msg, sizeof(msg));
sprintf(nmb, "%d", event->request_code);
XGetErrorDatabaseText(d, "XRequest", nmb, nmb, req, sizeof(req));
logmsg << "WM: " << req << " on resource " << event->resourceid
<< " failed: " << msg << '\n';
return 0;
}
int
errorHandler(Display *d, XErrorEvent *e) {
char msg[80];
char req[80];
char number[80];
if (mode == wm_initialising &&
e->request_code == X_ChangeWindowAttributes &&
e->error_code == BadAccess)
panic("another window manager is already running.");
if (ignore_badwindow &&
(e->error_code == BadWindow || e->error_code == BadColor))
return 0;
XGetErrorText(d, e->error_code, msg, sizeof(msg));
sprintf(number, "%d", e->request_code);
XGetErrorDatabaseText(d, "XRequest", number, number, req, sizeof(req));
fprintf(stderr, "%s: protocol request %s on resource %#x failed: %s\n",
argv0, req, (unsigned int) e->resourceid, msg);
if (mode == wm_initialising)
panic("can't initialise.");
return 0;
}
static int x_error_handler(Display *disp, XErrorEvent *evt)
{
char err_buf[256], mesg[256], number[256];
char *mtype = "XlibMessage";
XGetErrorText(disp, evt->error_code, err_buf, sizeof(err_buf));
(void)fprintf(stderr, "X Error: %s\n", err_buf);
XGetErrorDatabaseText(disp, mtype, "MajorCode",
"Request Major code %d", mesg, sizeof(mesg));
(void)fprintf(stderr, mesg, evt->request_code);
(void)sprintf(number, "%d", evt->request_code);
XGetErrorDatabaseText(disp, "XRequest", number, "", err_buf,
sizeof(err_buf));
(void)fprintf(stderr, " (%s)\n", err_buf);
abort();
}
static int xerror_handler(Display *dpy, XErrorEvent *e) {
if (verbose < 1)
return 0;
char msg[64] = {0};
char op[32] = {0};
sprintf(msg, "%d", e->request_code);
XGetErrorDatabaseText(dpy, "XRequest", msg, "", op, sizeof(op));
XGetErrorText(dpy, e->error_code, msg, sizeof(msg));
error("%s (%s)", msg, op);
return 0;
}
int xerror_handler(Display* d, XErrorEvent* e)
{
if(e->request_code == X_ChangeWindowAttributes &&
e->error_code == BadAccess &&
e->resourceid == RootWindow(fl_display, DefaultScreen(fl_display)))
{
// force cleaning data
WindowManager::shutdown();
Fl::fatal(_("Another window manager is running. You must exit it before running edewm."));
}
x_errors++;
char buff[128];
EPRINTF("\n");
XGetErrorDatabaseText(fl_display, "XlibMessage", "XError", "", buff, 128);
EPRINTF("%s: ", buff);
XGetErrorText(fl_display, e->error_code, buff, 128);
EPRINTF("%s \n", buff);
XGetErrorDatabaseText(fl_display, "XlibMessage", "MajorCode", "%d", buff, 128);
EPRINTF(" ");
EPRINTF(buff, e->request_code);
sprintf(buff, "%d", e->request_code);
XGetErrorDatabaseText(fl_display, "XRequest", buff, "%d", buff, 128);
EPRINTF(" (%s)\n", buff);
XGetErrorDatabaseText(fl_display, "XlibMessage", "MinorCode", "%d", buff, 128);
EPRINTF(" ");
EPRINTF(buff, e->minor_code);
EPRINTF(" ");
XGetErrorDatabaseText(fl_display, "XlibMessage", "ResourceID", "%d", buff, 128);
EPRINTF(buff, e->resourceid);
EPRINTF("\n");
EPRINTF("\n");
return 0;
}
int TutorApplication::handleXError(Display *display, XErrorEvent *event)
{
char buffer[BUFSIZ];
char mesg[BUFSIZ];
char number[32];
XGetErrorText(display, event->error_code, buffer, BUFSIZ);
XGetErrorDatabaseText(display, "XlibMessage", "XError",
"X Error", mesg, BUFSIZ);
fprintf(stderr, "%s: %s\n", mesg, buffer);
XGetErrorDatabaseText(display, "XlibMessage", "MajorCode",
"Request Major code %d", mesg, BUFSIZ);
fprintf(stderr, mesg, event->request_code);
if (event->request_code < 128) {
sprintf(number, "%d", event->request_code);
XGetErrorDatabaseText(display, "XRequest", number, "", buffer, BUFSIZ);
} else {
sprintf(buffer, "Extension %d", event->request_code);
}
fprintf(stderr, " (%s)\n ", buffer);
XGetErrorDatabaseText(display, "XlibMessage", "MinorCode",
"Request Minor code %d", mesg, BUFSIZ);
fprintf(stderr, mesg, event->minor_code);
if (event->request_code >= 128) {
sprintf(mesg, "Extension %d.%d",
event->request_code, event->minor_code);
XGetErrorDatabaseText(display, "XRequest", mesg, "", buffer, BUFSIZ);
fprintf(stderr, " (%s)", buffer);
}
fputs("\n ", stderr);
XGetErrorDatabaseText(display, "XlibMessage", "ResourceID",
"ResourceID 0x%x", mesg, BUFSIZ);
fprintf(stderr, mesg, event->resourceid);
fputs("\n ", stderr);
XGetErrorDatabaseText(display, "XlibMessage", "ErrorSerial",
"Error Serial #%d", mesg, BUFSIZ);
fprintf(stderr, mesg, event->serial);
fputs("\n ", stderr);
#if defined(XlibSpecificationRelease) && XlibSpecificationRelease <= 4
// R5 does not allow one to get at display->request.
XGetErrorDatabaseText(display, "XlibMessage", "CurrentSerial",
"Current Serial #%d", mesg, BUFSIZ);
fprintf(stderr, mesg, display->request);
fputs("\n", stderr);
#endif
if (event->error_code == BadImplementation) return 0;
return 1;
}
// A protocol error has occurred
static int juce_XErrorHandler (Display* display, XErrorEvent* event)
{
#if JUCE_DEBUG_XERRORS
char errorStr[64] = { 0 };
char requestStr[64] = { 0 };
XGetErrorText (display, event->error_code, errorStr, 64);
XGetErrorDatabaseText (display, "XRequest", String (event->request_code).toUTF8(), "Unknown", requestStr, 64);
DBG ("ERROR: X returned " + String (errorStr) + " for operation " + String (requestStr));
#endif
return 0;
}
int
xErrorHandler ( Display *dsp, XErrorEvent *err )
{
char buf[128];
char key[64];
/*
* If there are clueless apps using resident Graphics objects in
* asnyc drawing ops (without checking for window visibility first),
* we might get BadDrawable errors. Since this is clearly a bug
* of the app (which has to clean up resident Graphics objects
* before closing windows), we don't want to add costly checks
* on every Graphics op (which couldn't be safe, anyway).
* The only way to handle this safely would be to link Graphics
* objects to their targets, and this would add the danger of
* severe memory leaks in case the Graphics objects aren't disposed
* (for efficiency reasons, we cach Graphics instances).
* Ignoring BadDrawables is not very nice, but reasonably safe.
*/
/*
if ( err->error_code == BadDrawable )
return 0;
*/
UNIMPLEMENTED((
sprintf( key, "%d", err->error_code);
XGetErrorDatabaseText( dsp, "XProtoError", key, "", buf, sizeof( buf));
DBG( AWT, printf("X error: %s\n", buf));
sprintf( key, "%d", err->request_code);
XGetErrorDatabaseText( dsp, "XRequest", key, "", buf, sizeof( buf));
DBG( AWT, printf(" request: %s\n", buf));
DBG( AWT, printf(" resource: %X\n", err->resourceid));
//DBG( AWT, (*JniEnv)->ThrowNew( JniEnv, AWTError, "X error occured"));
));
static int
x_errorhandler(Display *dpy, XErrorEvent *e)
{
#ifdef DEBUG
char msg[80], number[80], req[80];
XGetErrorText(X_Dpy, e->error_code, msg, sizeof(msg));
(void)snprintf(number, sizeof(number), "%d", e->request_code);
XGetErrorDatabaseText(X_Dpy, "XRequest", number,
"<unknown>", req, sizeof(req));
warnx("%s(0x%x): %s", req, (unsigned int)e->resourceid, msg);
#endif
return (0);
}
int
XGetErrorText(
register Display *dpy,
register int code,
char *buffer,
int nbytes)
{
char buf[150];
register _XExtension *ext;
_XExtension *bext = (_XExtension *)NULL;
if (nbytes == 0) return 0;
if (code <= BadImplementation && code > 0) {
sprintf(buf, "%d", code);
(void) XGetErrorDatabaseText(dpy, "XProtoError", buf,
_XErrorList + _XErrorOffsets[code],
buffer, nbytes);
} else
buffer[0] = '\0';
/* call out to any extensions interested */
for (ext = dpy->ext_procs; ext; ext = ext->next) {
if (ext->error_string)
(*ext->error_string)(dpy, code, &ext->codes, buffer, nbytes);
if (ext->codes.first_error &&
ext->codes.first_error <= code &&
(!bext || ext->codes.first_error > bext->codes.first_error))
bext = ext;
}
if (!buffer[0] && bext) {
sprintf(buf, "%s.%d", bext->name, code - bext->codes.first_error);
(void) XGetErrorDatabaseText(dpy, "XProtoError", buf, "", buffer, nbytes);
}
if (!buffer[0])
sprintf(buffer, "%d", code);
return 0;
}
static void
print_x_error (Display *dpy, XErrorEvent *event)
{
char buffer[BUFSIZ];
char mesg[BUFSIZ];
char number[32];
char *mtype = "XlibMessage";
XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
rxvt_warn ("An X Error occured, trying to continue after report.\n");
rxvt_warn ("%s: %s\n", mesg, buffer);
XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d", mesg, BUFSIZ);
rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->request_code);
sprintf(number, "%d", event->request_code);
XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
rxvt_warn ("(which is %s)\n", buffer);
if (event->request_code >= 128) {
XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
mesg, BUFSIZ);
rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->minor_code);
}
if ((event->error_code == BadWindow) ||
(event->error_code == BadPixmap) ||
(event->error_code == BadCursor) ||
(event->error_code == BadFont) ||
(event->error_code == BadDrawable) ||
(event->error_code == BadColor) ||
(event->error_code == BadGC) ||
(event->error_code == BadIDChoice) ||
(event->error_code == BadValue) ||
(event->error_code == BadAtom)) {
if (event->error_code == BadValue)
XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
mesg, BUFSIZ);
else if (event->error_code == BadAtom)
XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
mesg, BUFSIZ);
else
XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
mesg, BUFSIZ);
rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->resourceid);
}
XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
mesg, BUFSIZ);
rxvt_warn (strncat (mesg, "\n", BUFSIZ), event->serial);
}
static int
errorHandler(Display *dpy, XErrorEvent *error)
{
char buffer[512];
XGetErrorText(dpy, error->error_code, buffer, sizeof buffer);
std::cerr << "error: xlib: " << buffer;
if (error->request_code < 128) {
std::string request_code = std::to_string(error->request_code);
XGetErrorDatabaseText(dpy, "XRequest", request_code.c_str(), "", buffer, sizeof buffer);
std::cerr << " in " << buffer;
}
std::cerr << "\n";
return 0;
}
static int x11ErrorHandler(Display *dpy, XErrorEvent *e)
{
if(!errorHandlerQuiet) {
const char * errnoStr = strerror(errno);
char threadName[80];
char errCodeStr[80];
char reqCodeStr[80];
int shallBeDetached = 0;
JNIEnv *jniEnv = NativewindowCommon_GetJNIEnv(jvmHandle, jvmVersion, &shallBeDetached);
(void) NativewindowCommon_GetStaticStringMethod(jniEnv, X11UtilClazz, getCurrentThreadNameID, threadName, sizeof(threadName), "n/a");
snprintf(errCodeStr, sizeof(errCodeStr), "%d", e->request_code);
XGetErrorDatabaseText(dpy, "XRequest", errCodeStr, "Unknown", reqCodeStr, sizeof(reqCodeStr));
XGetErrorText(dpy, e->error_code, errCodeStr, sizeof(errCodeStr));
fprintf(stderr, "Info: Nativewindow X11 Error (Thread: %s): %d - %s, dpy %p, id %x, # %d: %d:%d %s\n",
threadName, e->error_code, errCodeStr, e->display, (int)e->resourceid, (int)e->serial,
(int)e->request_code, (int)e->minor_code, reqCodeStr);
if( errorHandlerDebug ) {
(*jniEnv)->CallStaticVoidMethod(jniEnv, X11UtilClazz, dumpStackID);
}
if(errorHandlerThrowException) {
if(NULL != jniEnv) {
NativewindowCommon_throwNewRuntimeException(jniEnv, "Nativewindow X11 Error (Thread: %s): %d - %s, dpy %p, id %x, # %d: %d:%d %s\n",
threadName, e->error_code, errCodeStr, e->display, (int)e->resourceid, (int)e->serial,
(int)e->request_code, (int)e->minor_code, reqCodeStr);
} else {
fprintf(stderr, "Nativewindow X11 Error: null JNIEnv");
#if 0
if(NULL!=origErrorHandler) {
origErrorHandler(dpy, e);
}
#endif
}
}
fflush(stderr);
if (NULL != jniEnv && shallBeDetached) {
(*jvmHandle)->DetachCurrentThread(jvmHandle);
}
}
return 0;
}
void
EventShowError(const XErrorEvent * ev)
{
Display *dpy = disp;
char buf[64], buf1[64];
if (ev->request_code < 128)
Esnprintf(buf, sizeof(buf), "%d", ev->request_code);
else
Esnprintf(buf, sizeof(buf), "%s.%d",
EventsGetExtensionName(ev->request_code), ev->minor_code);
XGetErrorDatabaseText(dpy, "XRequest", buf, "", buf1, sizeof(buf1));
XGetErrorText(dpy, ev->error_code, buf, sizeof(buf));
Eprintf("*** ERROR: xid=%#lx req=%i/%i err=%i: %s: %s\n",
ev->resourceid, ev->request_code, ev->minor_code,
ev->error_code, buf1, buf);
}
static int x11ErrorHandler(Display *dpy, XErrorEvent *e)
{
if( !errorHandlerQuiet || errorHandlerDebug ) {
const char * errnoStr = strerror(errno);
char errCodeStr[80];
char reqCodeStr[80];
int shallBeDetached = 0;
JNIEnv *jniEnv = NULL;
snprintf(errCodeStr, sizeof(errCodeStr), "%d", e->request_code);
XGetErrorDatabaseText(dpy, "XRequest", errCodeStr, "Unknown", reqCodeStr, sizeof(reqCodeStr));
XGetErrorText(dpy, e->error_code, errCodeStr, sizeof(errCodeStr));
fprintf(stderr, "Info: Nativewindow X11 Error: %d - %s, dpy %p, id %x, # %d: %d:%d %s\n",
e->error_code, errCodeStr, e->display, (int)e->resourceid, (int)e->serial,
(int)e->request_code, (int)e->minor_code, reqCodeStr);
fflush(stderr);
if( NULL != jvmHandle && ( errorHandlerDebug || errorHandlerThrowException ) ) {
jniEnv = NativewindowCommon_GetJNIEnv(jvmHandle, jvmVersion, 0 /* asDaemon */, &shallBeDetached);
if(NULL == jniEnv) {
fprintf(stderr, "Nativewindow X11 Error: null JNIEnv");
fflush(stderr);
}
}
if( NULL != jniEnv ) {
if( errorHandlerDebug ) {
(*jniEnv)->CallStaticVoidMethod(jniEnv, X11UtilClazz, dumpStackID);
}
if(errorHandlerThrowException) {
NativewindowCommon_throwNewRuntimeException(jniEnv, "Nativewindow X11 Error: %d - %s, dpy %p, id %x, # %d: %d:%d %s\n",
e->error_code, errCodeStr, e->display, (int)e->resourceid, (int)e->serial,
(int)e->request_code, (int)e->minor_code, reqCodeStr);
}
if (shallBeDetached) {
(*jvmHandle)->DetachCurrentThread(jvmHandle);
}
}
}
return 0;
}
static int
ccm_display_error_handler (Display * dpy, XErrorEvent * evt)
{
gchar str[128];
XGetErrorText (dpy, evt->error_code, str, 128);
ccm_debug ("ERROR: Xerror: %s", str);
sprintf (str, "%d", evt->request_code);
XGetErrorDatabaseText (dpy, "XRequest", str, "", str, 128);
if (strcmp (str, ""))
ccm_debug ("ERROR: XRequest: (%s)", str);
CCMLastXError = evt->error_code;
ccm_debug_backtrace ();
return 0;
}
/** Callback to handle errors from Xlib.
* Note that if debug output is directed to an X terminal, emitting too
* much output can cause a dead lock (this happens on HP-UX). Therefore
* ShowCheckpoint isn't used by default.
*/
int ErrorHandler(Display *d, XErrorEvent *e) {
#ifdef DEBUG
char buffer[64];
char code[32];
#endif
if(initializing) {
if(e->request_code == X_ChangeWindowAttributes
&& e->error_code == BadAccess) {
FatalError("display is already managed");
}
}
#ifdef DEBUG
if(!e) {
fprintf(stderr, "XError: [no information]\n");
return 0;
}
XGetErrorText(display, e->error_code, buffer, sizeof(buffer));
Debug("XError: %s", buffer);
snprintf(code, sizeof(code), "%d", e->request_code);
XGetErrorDatabaseText(display, "XRequest", code, "?",
buffer, sizeof(buffer));
Debug(" Request Code: %d (%s)", e->request_code, buffer);
Debug(" Minor Code: %d", e->minor_code);
Debug(" Resource ID: 0x%lx", (unsigned long)e->resourceid);
Debug(" Error Serial: %lu", (unsigned long)e->serial);
#if 1
ShowCheckpoint();
#endif
#endif
return 0;
}
JNIEXPORT jstring JNICALL Java_org_apache_harmony_awt_nativebridge_linux_ErrorHandler_getInfo (JNIEnv * env, jclass self)
{
char buffer[1024];
char message[200];
char request[200];
char request_def[200];
char code[30];
if (isError) {
isError = JNI_FALSE;
XGetErrorText(info.display, info.error_code, message, 200);
sprintf(code, "%d", info.request_code);
sprintf(request_def, "Major opcode: %d", info.request_code);
XGetErrorDatabaseText(info.display, "XRequest", code, request_def, request, 200);
sprintf(buffer, "X Server Error: %s, %s, Minor opcode: %d", message, request, info.minor_code);
return env->NewStringUTF((const char *) buffer);
}
return NULL;
}
int xerror_handler(Display* d, XErrorEvent* e)
{
if(e->request_code == X_ChangeWindowAttributes &&
e->error_code == BadAccess &&
e->resourceid == RootWindow(fl_display, DefaultScreen(fl_display)))
Fl::fatal(_("Another window manager is running. You must exit it before running edewm."));
#ifndef DEBUG
if (e->error_code == BadWindow) return 0;
if (e->error_code == BadColor) return 0;
#endif
char buf1[128], buf2[128];
sprintf(buf1, "XRequest.%d", e->request_code);
XGetErrorDatabaseText(d,"",buf1,buf1,buf2,128);
XGetErrorText(d, e->error_code, buf1, 128);
Fl::warning("%s: %s: %s 0x%lx", program_name, buf2, buf1, e->resourceid);
return 0;
}
static int my_error_handler(Display *dpy, XErrorEvent *ev)
{
static char msg[128], request[64], num[32];
/* Just ignore bad window and similar errors; makes the rest of
* the code simpler.
*
* Apparently XGetWindowProperty can return BadMatch on a race
* condition where the server is already reusing the XID for a
* non-window drawable, so let's just ignore BadMatch entirely...
*/
if((ev->error_code==BadWindow ||
(ev->error_code==BadMatch /*&& ev->request_code==X_SetInputFocus*/) ||
(ev->error_code==BadDrawable && ev->request_code==X_GetGeometry)) &&
ignore_badwindow)
return 0;
#if 0
XmuPrintDefaultErrorMessage(dpy, ev, stderr);
#else
XGetErrorText(dpy, ev->error_code, msg, 128);
snprintf(num, 32, "%d", ev->request_code);
XGetErrorDatabaseText(dpy, "XRequest", num, "", request, 64);
if(request[0]=='\0')
snprintf(request, 64, "<unknown request>");
if(ev->minor_code!=0){
warn("[%d] %s (%d.%d) %#lx: %s", ev->serial, request,
ev->request_code, ev->minor_code, ev->resourceid,msg);
}else{
warn("[%d] %s (%d) %#lx: %s", ev->serial, request,
ev->request_code, ev->resourceid,msg);
}
#endif
kill(getpid(), SIGTRAP);
return 0;
}
static int
errorHandler(
Display *dpy,
XErrorEvent *err)
{
char msg[256];
char buf[256];
XGetErrorText(dpy, err->error_code, msg, sizeof(msg));
wsdebug("\n\nWSDEBUG Vim: X Error of failed request: %s\n", msg);
sprintf(buf, "%d", err->request_code);
XGetErrorDatabaseText(dpy,
"XRequest", buf, "Unknown", msg, sizeof(msg));
wsdebug("\tMajor opcode of failed request: %d (%s)\n",
err->request_code, msg);
if (err->request_code > 128) {
wsdebug("\tMinor opcode of failed request: %d\n",
err->minor_code);
}
return 0;
}
/*
* XmuPrintDefaultErrorMessage - print a nice error that looks like the usual
* message. Returns 1 if the caller should consider exitting else 0.
*/
int
XmuPrintDefaultErrorMessage(Display *dpy, XErrorEvent *event, FILE *fp)
{
char buffer[BUFSIZ];
char mesg[BUFSIZ];
char number[32];
_Xconst char *mtype = "XlibMessage";
register _XExtension *ext = (_XExtension *)NULL;
_XExtension *bext = (_XExtension *)NULL;
XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
(void) fprintf(fp, "%s: %s\n ", mesg, buffer);
XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d",
mesg, BUFSIZ);
(void) fprintf(fp, mesg, event->request_code);
if (event->request_code < 128) {
XmuSnprintf(number, sizeof(number), "%d", event->request_code);
XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
} else {
/* XXX this is non-portable */
for (ext = dpy->ext_procs;
ext && (ext->codes.major_opcode != event->request_code);
ext = ext->next)
;
if (ext)
XmuSnprintf(buffer, sizeof(buffer), "%s", ext->name);
else
buffer[0] = '\0';
}
(void) fprintf(fp, " (%s)", buffer);
fputs("\n ", fp);
if (event->request_code >= 128) {
XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
mesg, BUFSIZ);
(void) fprintf(fp, mesg, event->minor_code);
if (ext) {
XmuSnprintf(mesg, sizeof(mesg),
"%s.%d", ext->name, event->minor_code);
XGetErrorDatabaseText(dpy, "XRequest", mesg, "", buffer, BUFSIZ);
(void) fprintf(fp, " (%s)", buffer);
}
fputs("\n ", fp);
}
if (event->error_code >= 128) {
/* kludge, try to find the extension that caused it */
buffer[0] = '\0';
for (ext = dpy->ext_procs; ext; ext = ext->next) {
if (ext->error_string)
(*ext->error_string)(dpy, event->error_code, &ext->codes,
buffer, BUFSIZ);
if (buffer[0]) {
bext = ext;
break;
}
if (ext->codes.first_error &&
ext->codes.first_error < event->error_code &&
(!bext || ext->codes.first_error > bext->codes.first_error))
bext = ext;
}
if (bext)
XmuSnprintf(buffer, sizeof(buffer), "%s.%d", bext->name,
event->error_code - bext->codes.first_error);
else
strcpy(buffer, "Value");
XGetErrorDatabaseText(dpy, mtype, buffer, "", mesg, BUFSIZ);
if (mesg[0]) {
fputs(" ", fp);
(void) fprintf(fp, mesg, event->resourceid);
fputs("\n", fp);
}
/* let extensions try to print the values */
for (ext = dpy->ext_procs; ext; ext = ext->next) {
if (ext->error_values)
(*ext->error_values)(dpy, event, fp);
}
} else if ((event->error_code == BadWindow) ||
(event->error_code == BadPixmap) ||
(event->error_code == BadCursor) ||
(event->error_code == BadFont) ||
(event->error_code == BadDrawable) ||
(event->error_code == BadColor) ||
(event->error_code == BadGC) ||
(event->error_code == BadIDChoice) ||
(event->error_code == BadValue) ||
(event->error_code == BadAtom)) {
if (event->error_code == BadValue)
XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
mesg, BUFSIZ);
else if (event->error_code == BadAtom)
XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
mesg, BUFSIZ);
else
XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
mesg, BUFSIZ);
(void) fprintf(fp, mesg, event->resourceid);
fputs("\n ", fp);
}
XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
mesg, BUFSIZ);
(void) fprintf(fp, mesg, event->serial);
fputs("\n ", fp);
XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
mesg, BUFSIZ);
(void) fprintf(fp, mesg, NextRequest(dpy)-1);
fputs("\n", fp);
if (event->error_code == BadImplementation) return 0;
return 1;
}
static int qt_x_errhandler(Display *dpy, XErrorEvent *err)
{
qDebug() << "qt_x_errhandler" << err->error_code;
switch (err->error_code) {
case BadAtom:
#if 0
if (err->request_code == 20 /* X_GetProperty */
&& (err->resourceid == XA_RESOURCE_MANAGER
|| err->resourceid == XA_RGB_DEFAULT_MAP
|| err->resourceid == ATOM(_NET_SUPPORTED)
|| err->resourceid == ATOM(_NET_SUPPORTING_WM_CHECK)
|| err->resourceid == ATOM(KDE_FULL_SESSION)
|| err->resourceid == ATOM(KWIN_RUNNING)
|| err->resourceid == ATOM(XdndProxy)
|| err->resourceid == ATOM(XdndAware))
) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
#endif
qDebug() << "BadAtom";
break;
case BadWindow:
if (err->request_code == 2 /* X_ChangeWindowAttributes */
|| err->request_code == 38 /* X_QueryPointer */) {
for (int i = 0; i < ScreenCount(dpy); ++i) {
if (err->resourceid == RootWindow(dpy, i)) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
}
}
seen_badwindow = true;
if (err->request_code == 25 /* X_SendEvent */) {
for (int i = 0; i < ScreenCount(dpy); ++i) {
if (err->resourceid == RootWindow(dpy, i)) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
}
#if 0
if (X11->xdndHandleBadwindow()) {
qDebug("xdndHandleBadwindow returned true");
return 0;
}
#endif
}
#if 0
if (X11->ignore_badwindow)
return 0;
#endif
break;
case BadMatch:
if (err->request_code == 42 /* X_SetInputFocus */)
return 0;
break;
default:
#if 0 //!defined(QT_NO_XINPUT)
if (err->request_code == X11->xinput_major
&& err->error_code == (X11->xinput_errorbase + XI_BadDevice)
&& err->minor_code == 3 /* X_OpenDevice */) {
return 0;
}
#endif
break;
}
char errstr[256];
XGetErrorText( dpy, err->error_code, errstr, 256 );
char buffer[256];
char request_str[256];
qsnprintf(buffer, 256, "%d", err->request_code);
XGetErrorDatabaseText(dpy, "XRequest", buffer, "", request_str, 256);
if (err->request_code < 128) {
// X error for a normal protocol request
qWarning( "X Error: %s %d\n"
" Major opcode: %d (%s)\n"
" Resource id: 0x%lx",
errstr, err->error_code,
err->request_code,
request_str,
err->resourceid );
} else {
// X error for an extension request
const char *extensionName = 0;
#if 0
if (err->request_code == X11->xrender_major)
extensionName = "RENDER";
else if (err->request_code == X11->xrandr_major)
extensionName = "RANDR";
else if (err->request_code == X11->xinput_major)
extensionName = "XInputExtension";
else if (err->request_code == X11->mitshm_major)
extensionName = "MIT-SHM";
#endif
char minor_str[256];
if (extensionName) {
qsnprintf(buffer, 256, "%s.%d", extensionName, err->minor_code);
XGetErrorDatabaseText(dpy, "XRequest", buffer, "", minor_str, 256);
} else {
extensionName = "Uknown extension";
qsnprintf(minor_str, 256, "Unknown request");
}
qWarning( "X Error: %s %d\n"
" Extension: %d (%s)\n"
" Minor opcode: %d (%s)\n"
" Resource id: 0x%lx",
errstr, err->error_code,
err->request_code,
extensionName,
err->minor_code,
minor_str,
err->resourceid );
}
// ### we really should distinguish between severe, non-severe and
// ### application specific errors
return 0;
}
static int
X11Error(Display *display, XErrorEvent *event) {
// Get an indication of how long ago the request that caused the error was
// made.
unsigned long age = NextRequest(display) - event->serial;
// Get a string to represent the request that caused the error.
nsAutoCString message;
if (event->request_code < 128) {
// Core protocol request
message.AppendInt(event->request_code);
} else {
// Extension request
// man XSetErrorHandler says "the error handler should not call any
// functions (directly or indirectly) on the display that will generate
// protocol requests or that will look for input events" so we use another
// temporary Display to request extension information. This assumes on
// the DISPLAY environment variable has been set and matches what was used
// to open |display|.
Display *tmpDisplay = XOpenDisplay(NULL);
if (tmpDisplay) {
int nExts;
char** extNames = XListExtensions(tmpDisplay, &nExts);
int first_error;
if (extNames) {
for (int i = 0; i < nExts; ++i) {
int major_opcode, first_event;
if (XQueryExtension(tmpDisplay, extNames[i],
&major_opcode, &first_event, &first_error)
&& major_opcode == event->request_code) {
message.Append(extNames[i]);
message.Append('.');
message.AppendInt(event->minor_code);
break;
}
}
XFreeExtensionList(extNames);
}
XCloseDisplay(tmpDisplay);
#ifdef MOZ_WIDGET_GTK2
// GDK2 calls XCloseDevice the devices that it opened on startup, but
// the XI protocol no longer ensures that the devices will still exist.
// If they have been removed, then a BadDevice error results. Ignore
// this error.
if (message.EqualsLiteral("XInputExtension.4") &&
event->error_code == first_error + 0) {
return 0;
}
#endif
}
}
char buffer[BUFSIZE];
if (message.IsEmpty()) {
buffer[0] = '\0';
} else {
XGetErrorDatabaseText(display, "XRequest", message.get(), "",
buffer, sizeof(buffer));
}
nsAutoCString notes;
if (buffer[0]) {
notes.Append(buffer);
} else {
notes.Append("Request ");
notes.AppendInt(event->request_code);
notes.Append('.');
notes.AppendInt(event->minor_code);
}
notes.Append(": ");
// Get a string to describe the error.
XGetErrorText(display, event->error_code, buffer, sizeof(buffer));
notes.Append(buffer);
// For requests where Xlib gets the reply synchronously, |age| will be 1
// and the stack will include the function making the request. For
// asynchronous requests, the current stack will often be unrelated to the
// point of making the request, even if |age| is 1, but sometimes this may
// help us count back to the point of the request. With XSynchronize on,
// the stack will include the function making the request, even though
// |age| will be 2 for asynchronous requests because XSynchronize is
// implemented by an empty request from an XSync, which has not yet been
// processed.
if (age > 1) {
// XSynchronize returns the previous "after function". If a second
// XSynchronize call returns the same function after an enable call then
// synchronization must have already been enabled.
if (XSynchronize(display, True) == XSynchronize(display, False)) {
notes.Append("; sync");
} else {
notes.Append("; ");
notes.AppendInt(uint32_t(age));
notes.Append(" requests ago");
}
}
#ifdef MOZ_CRASHREPORTER
switch (XRE_GetProcessType()) {
case GeckoProcessType_Default:
case GeckoProcessType_Plugin:
case GeckoProcessType_Content:
CrashReporter::AppendAppNotesToCrashReport(notes);
break;
default:
; // crash report notes not supported.
}
#endif
#ifdef DEBUG
// The resource id is unlikely to be useful in a crash report without
// context of other ids, but add it to the debug console output.
notes.Append("; id=0x");
notes.AppendInt(uint32_t(event->resourceid), 16);
#ifdef MOZ_X11
// Actually, for requests where Xlib gets the reply synchronously,
// MOZ_X_SYNC=1 will not be necessary, but we don't have a table to tell us
// which requests get a synchronous reply.
if (!PR_GetEnv("MOZ_X_SYNC")) {
notes.Append("\nRe-running with MOZ_X_SYNC=1 in the environment may give a more helpful backtrace.");
}
#endif
#endif
#ifdef MOZ_WIDGET_QT
// We should not abort here if MOZ_X_SYNC is not set
// until http://bugreports.qt.nokia.com/browse/QTBUG-4042
// not fixed, just print error value
if (!PR_GetEnv("MOZ_X_SYNC")) {
fprintf(stderr, "XError: %s\n", notes.get());
return 0; // temporary workaround for bug 161472
}
#endif
NS_RUNTIMEABORT(notes.get());
return 0; // not reached
}
int dummy_handler(Display * dpy, XErrorEvent * ev)
{
#define ERROR_BUF_SIZE 256
char buf[ERROR_BUF_SIZE];
char request[ERROR_BUF_SIZE];
_XExtension *ext = NULL;
if (!print_x11_errors)
return 0;
XGetErrorText(dpy, ev->error_code, buf, sizeof(buf));
fprintf(stderr, "ErrorHandler: %s\n", buf);
/* Find major opcode name */
if (ev->request_code < 128) {
snprintf(request, sizeof(request), "%d", ev->request_code);
XGetErrorDatabaseText(dpy, "XRequest", request, "", buf,
sizeof(buf));
} else {
for (ext = dpy->ext_procs;
ext && ext->codes.major_opcode != ev->request_code;
ext = ext->next);
if (ext)
strncpy(buf, ext->name, sizeof(buf));
else
buf[0] = '\0';
}
fprintf(stderr, " Major opcode: %d (%s)\n",
ev->request_code, buf);
/* Find minor opcode name */
if (ev->request_code >= 128 && ext) {
snprintf(request, sizeof(request), "%d", ev->request_code);
snprintf(request, sizeof(request), "%s.%d",
ext->name, ev->minor_code);
XGetErrorDatabaseText(dpy, "XRequest", request, "", buf,
sizeof(buf));
fprintf(stderr, " Minor opcode: %d (%s)\n",
ev->minor_code, buf);
}
/* Provide value information */
switch (ev->error_code) {
case BadValue:
fprintf(stderr, " Value: 0x%x\n",
(int) ev->resourceid);
break;
case BadAtom:
fprintf(stderr, " AtomID: 0x%x\n",
(int) ev->resourceid);
break;
default:
fprintf(stderr, " ResourceID: 0x%x\n",
(int) ev->resourceid);
break;
}
/* Provide serial number information */
fprintf(stderr, " Failed serial number: %ld\n",
ev->serial);
fprintf(stderr, " Current serial number: %ld\n",
dpy->request);
return 0;
}
static int
errorHandler (Display *dpy,
XErrorEvent *e)
{
#ifdef DEBUG
char str[128];
char *name = 0;
int o;
#endif
errors++;
if (e->request_code == compDisplays->compositeOpcode &&
e->minor_code == X_CompositeRedirectSubwindows)
{
redirectFailed = 1;
return 0;
}
#ifdef DEBUG
XGetErrorDatabaseText (dpy, "XlibMessage", "XError", "", str, 128);
fprintf (stderr, "%s", str);
o = e->error_code - compDisplays->damageError;
switch (o) {
case BadDamage:
name = "BadDamage";
break;
default:
break;
}
if (name)
{
fprintf (stderr, ": %s\n ", name);
}
else
{
XGetErrorText (dpy, e->error_code, str, 128);
fprintf (stderr, ": %s\n ", str);
}
XGetErrorDatabaseText (dpy, "XlibMessage", "MajorCode", "%d", str, 128);
fprintf (stderr, str, e->request_code);
sprintf (str, "%d", e->request_code);
XGetErrorDatabaseText (dpy, "XRequest", str, "", str, 128);
if (strcmp (str, ""))
fprintf (stderr, " (%s)", str);
fprintf (stderr, "\n ");
XGetErrorDatabaseText (dpy, "XlibMessage", "MinorCode", "%d", str, 128);
fprintf (stderr, str, e->minor_code);
fprintf (stderr, "\n ");
XGetErrorDatabaseText (dpy, "XlibMessage", "ResourceID", "%d", str, 128);
fprintf (stderr, str, e->resourceid);
fprintf (stderr, "\n");
/* abort (); */
#endif
return 0;
}
