static void initializeGtk(QLibrary* module = 0) { // Ensures missing Gtk initialization in some versions of Adobe's flash player // plugin do not cause crashes. See BR# 40567, 44324, and 44405 for details. if (module) { typedef void *(*gtk_init_ptr)(int*, char***); gtk_init_ptr gtkInit = (gtk_init_ptr)module->resolve("gtk_init"); if (gtkInit) { // Prevent gtk_init() from replacing the X error handlers, since the Gtk // handlers abort when they receive an X error, thus killing the viewer. #ifdef Q_WS_X11 int (*old_error_handler)(Display*, XErrorEvent*) = XSetErrorHandler(0); int (*old_io_error_handler)(Display*) = XSetIOErrorHandler(0); #endif gtkInit(0, 0); #ifdef Q_WS_X11 XSetErrorHandler(old_error_handler); XSetIOErrorHandler(old_io_error_handler); #endif return; } } QLibrary library("libgtk-x11-2.0.so.0"); if (library.load()) { typedef void *(*gtk_init_check_ptr)(int*, char***); gtk_init_check_ptr gtkInitCheck = (gtk_init_check_ptr)library.resolve("gtk_init_check"); // NOTE: We're using gtk_init_check() since gtk_init() calls exit() on failure. if (gtkInitCheck) (void) gtkInitCheck(0, 0); } }
int PingServer( void ) { int (*oldError)(); SIGVAL (*oldSig)(); int oldAlarm; oldError = XSetIOErrorHandler ((XIOErrorHandler)PingLost); oldAlarm = alarm (0); oldSig = signal (SIGALRM, PingBlocked); alarm (pingTimeout * 60); if (!setjmp (pingTime)) { XSync (dpyinfo.dpy, 0); } else { if ( serverDead ) { LogError(ReadCatalog( MC_LOG_SET,MC_LOG_DEADSRV,MC_DEF_LOG_DEADSRV), dpyinfo.name); alarm (0); signal (SIGALRM, SIG_DFL); XSetIOErrorHandler (oldError); return 0; } } alarm (0); signal (SIGALRM, oldSig); alarm (oldAlarm); XSetIOErrorHandler (oldError); return 1; }
int PingServer (struct display *d, Display *alternateDpy) { int (*oldError)(Display *); SIGVAL (*oldSig)(int); int oldAlarm; static Display *aDpy; aDpy = (alternateDpy != NULL ? alternateDpy : dpy); oldError = XSetIOErrorHandler (PingLostIOErr); oldAlarm = alarm (0); oldSig = Signal (SIGALRM, PingLostSig); (void) alarm (d->pingTimeout * 60); if (!Setjmp (pingTime)) { Debug ("Ping server\n"); XSync (aDpy, 0); } else { Debug ("Server dead\n"); (void) alarm (0); (void) Signal (SIGALRM, SIG_DFL); XSetIOErrorHandler (oldError); return 0; } (void) alarm (0); (void) Signal (SIGALRM, oldSig); (void) alarm (oldAlarm); Debug ("Server alive\n"); XSetIOErrorHandler (oldError); return 1; }
void xconn_clean(xconn_t c) { Window dummy, parent; Window *children; unsigned int nchildren; unsigned int i; Window Root; if(!c) return; XSetErrorHandler(CatchErrors); XSetIOErrorHandler(CatchIOErrors); Root = DefaultRootWindow(c); nchildren = 0; if(!setjmp(XErrEnv)) XQueryTree(c, Root, &dummy, &parent, &children, &nchildren); else goto out; for( i = 0; i < nchildren; i++ ) { if(!setjmp(XErrEnv)) XKillClient(c, children[i]); } XFree((char *)children); if(!setjmp(XErrEnv)) XSync(c, 0); out: XSetErrorHandler(NULL); XSetIOErrorHandler(NULL); }
void xconn_close(xconn_t c) { if(!c) return; XSetErrorHandler(CatchErrors); XSetIOErrorHandler(CatchIOErrors); if(!setjmp(XErrEnv)) XCloseDisplay(c); XSetErrorHandler(NULL); XSetIOErrorHandler(NULL); }
static void x11IOErrorHandlerEnable(int onoff, JNIEnv * env) { if(onoff) { if(NULL==origIOErrorHandler) { setupJVMVars(env); origIOErrorHandler = XSetIOErrorHandler(x11IOErrorHandler); } } else { XSetIOErrorHandler(origIOErrorHandler); origIOErrorHandler = NULL; } }
static void x11IOErrorHandlerEnable(int onoff, JNIEnv * env) { if(onoff) { if(NULL==origIOErrorHandler) { x11ErrorHandlerJNIEnv = env; origIOErrorHandler = XSetIOErrorHandler(x11IOErrorHandler); } } else { XSetIOErrorHandler(origIOErrorHandler); origIOErrorHandler = NULL; } }
void xorg::testing::XServer::RegisterXIOErrorHandler() { XIOErrorHandler old_handler, def_handler; old_handler = XSetIOErrorHandler(NULL); def_handler = XSetIOErrorHandler(_x_io_error_handler); if (old_handler != def_handler && old_handler != _XDefaultIOError && old_handler != _x_io_error_handler) XSetIOErrorHandler(old_handler); }
int WaitForServer (struct display *d) { static int i; for (i = 0; i < (d->openRepeat > 0 ? d->openRepeat : 1); i++) { (void) Signal (SIGALRM, abortOpen); (void) alarm ((unsigned) d->openTimeout); if (!Setjmp (openAbort)) { Debug ("Before XOpenDisplay(%s)\n", d->name); errno = 0; (void) XSetIOErrorHandler (openErrorHandler); dpy = XOpenDisplay (d->name); #ifdef STREAMSCONN { /* For some reason, the next XOpenDisplay we do is going to fail, so we might as well get that out of the way. There is something broken here. */ Display *bogusDpy = XOpenDisplay (d->name); Debug ("bogus XOpenDisplay %s\n", bogusDpy ? "succeeded" : "failed"); if (bogusDpy) XCloseDisplay(bogusDpy); /* just in case */ } #endif (void) alarm ((unsigned) 0); (void) Signal (SIGALRM, SIG_DFL); (void) XSetIOErrorHandler ((int (*)(Display *)) 0); Debug ("After XOpenDisplay(%s)\n", d->name); if (dpy) { #ifdef XDMCP if (d->displayType.location == Foreign) GetRemoteAddress (d, ConnectionNumber (dpy)); #endif RegisterCloseOnFork (ConnectionNumber (dpy)); (void) fcntl (ConnectionNumber (dpy), F_SETFD, 0); return 1; } else { Debug ("OpenDisplay failed %d (%s) on \"%s\"\n", errno, strerror (errno), d->name); } Debug ("waiting for server to start %d\n", i); sleep ((unsigned) d->openDelay); } else { Debug ("hung in open, aborting\n"); LogError ("Hung in XOpenDisplay(%s), aborting\n", d->name); (void) Signal (SIGALRM, SIG_DFL); break; } } Debug ("giving up on server\n"); LogError ("server open failed for %s, giving up\n", d->name); return 0; }
bool X11Helper::OpenXConnection() { DEBUG_ASSERT( Dpy == nullptr && Win == None ); Dpy = XOpenDisplay(0); if( Dpy == nullptr ) return false; XSetIOErrorHandler( FatalCallback ); XSetErrorHandler( ErrorCallback ); int event_base, error_base; display_supports_dpms_extension= DPMSQueryExtension(Dpy, &event_base, &error_base); if(display_supports_dpms_extension) { LOG->Trace("DPMSQueryExtension returned true. Stepmania will disable power management, and restore the original state on exit."); CARD16 power_level; BOOL state; if(DPMSInfo(Dpy, &power_level, &state)) { dpms_state_at_startup= state; DPMSDisable(Dpy); } else { LOG->Trace("DPMSInfo returned false. Stepmania will not be able to disable power management."); } } else { LOG->Trace("DPMSQueryExtension returned false, which means this display does not support the DPMS extension. Stepmania will not be able to disable power management."); } return true; }
void rxvt_init () { ptytty::init (); if (!ev_default_loop (0)) rxvt_fatal ("cannot initialise libev (bad value for LIBEV_METHODS?)\n"); rxvt_environ = environ; signal (SIGHUP, SIG_IGN); signal (SIGPIPE, SIG_IGN); sig_handlers.sw_term.start (SIGTERM); ev_unref (); sig_handlers.sw_int.start (SIGINT); ev_unref (); /* need to trap SIGURG for SVR4 (Unixware) rlogin */ /* signal (SIGURG, SIG_DFL); */ old_xerror_handler = XSetErrorHandler ((XErrorHandler) rxvt_xerror_handler); // TODO: handle this with exceptions and tolerate the memory loss XSetIOErrorHandler (rxvt_xioerror_handler); XrmInitialize (); }
/* main: A C main function... */ int main (int argc, char *argv[]) { int err = 0; int screen = 0; char *title = NULL; Display *dsp = NULL; Window root; Window res = -1; if (argc < 2) { printf("(!)Error: Missing command line argument for the window Title!"); printf("\n\n"); exit(1); } title = argv[1]; printf("(*)Looking for window title: \"%s\"\n", title); dsp = XOpenDisplay(NULL); XSetIOErrorHandler(_IOErrorHandler); XSetErrorHandler(_XErrorHandler); screen = XDefaultScreen(dsp); root = XRootWindow(dsp, screen); res = findFireFoxWindows(dsp, root, title); printf("RES: %d\n", res); SaveFile(dsp, res); return err; }
/* signal handlers */ void initialize_signals(void) { signal(SIGHUP, interrupted); signal(SIGINT, interrupted); signal(SIGQUIT, interrupted); signal(SIGABRT, interrupted); signal(SIGTERM, interrupted); signal(SIGBUS, interrupted); signal(SIGSEGV, interrupted); signal(SIGFPE, interrupted); if (!sigpipe || *sigpipe == '\0' || !strcmp(sigpipe, "skip")) { ; } else if (strstr(sigpipe, "ignore:") == sigpipe) { ignore_sigs(sigpipe); } else if (strstr(sigpipe, "exit:") == sigpipe) { ignore_sigs(sigpipe); } else if (!strcmp(sigpipe, "ignore")) { #ifdef SIG_IGN signal(SIGPIPE, SIG_IGN); #endif } else if (!strcmp(sigpipe, "exit")) { rfbLog("initialize_signals: will exit on SIGPIPE\n"); signal(SIGPIPE, interrupted); } #if NO_X11 return; #else X_LOCK; Xerror_def = XSetErrorHandler(Xerror); XIOerr_def = XSetIOErrorHandler(XIOerr); X_UNLOCK; #endif /* NO_X11 */ }
void XInterface::FinishConnection() { // not to be confused with the FinnishConnection Window root; dprintf(D_ALWAYS, "Connected to X server: %s\n", _display_name); g_connected = true; dprintf(D_FULLDEBUG, "Reset timer: %d\n", _daemon_core_timer); daemonCore->Reset_Timer( _daemon_core_timer, 5 ,5 ); // See note above the function to see why we need to do this. XSetErrorHandler((XErrorHandler) CatchFalseAlarm); XSetIOErrorHandler((XIOErrorHandler) CatchIOFalseAlarm); //Select the events on each root window of each screen for (int s = 0; s < ScreenCount(_display); s++) { root = RootWindowOfScreen(ScreenOfDisplay(_display, s)); SelectEvents(root); } // Query pointer stuff _pointer_root = DefaultRootWindow(_display); _pointer_screen = ScreenOfDisplay(_display, DefaultScreen(_display)); _pointer_prev_x = -1; _pointer_prev_y = -1; _pointer_prev_mask = 0; // Newly connected display needs to see if it has the extension needsCheck = true; hasXss = false; // unset env needed here? set_condor_priv(); }
WebBrowserHost::WebBrowserHost(Context* context) : Object (context) { const Vector<String>& arguments = GetArguments(); #ifdef ATOMIC_PLATFORM_LINUX XSetErrorHandler(XErrorHandlerImpl); XSetIOErrorHandler(XIOErrorHandlerImpl); // Install a signal handler so we clean up after ourselves. signal(SIGINT, TerminationSignalHandler); signal(SIGTERM, TerminationSignalHandler); #endif // IMPORTANT: See flags being set in implementation of void WebAppBrowser::OnBeforeCommandLineProcessing // these include "--enable-media-stream", "--enable-usermedia-screen-capturing", "--off-screen-rendering-enabled", "--transparent-painting-enabled" #ifdef ATOMIC_PLATFORM_LINUX static const char* _argv[3] = { "AtomicWebView", "--disable-setuid-sandbox" }; CefMainArgs args(3, (char**) &_argv); #else CefMainArgs args; #endif CefSettings settings; settings.windowless_rendering_enabled = 1; // default background is white, add a setting // settings.background_color = 0; if (productVersion_.Length()) { CefString(&settings.product_version).FromASCII(productVersion_.CString()); } if (userAgent_.Length()) { CefString(&settings.user_agent).FromASCII(userAgent_.CString()); } settings.remote_debugging_port = debugPort_; d_ = new WebBrowserHostPrivate(this); // If losing OSX system menu, it means we're calling this // before initializing graphics subsystem if (!CefInitialize(args, settings, d_->app_, nullptr)) { LOGERROR("CefInitialize - Error"); } RegisterWebSchemeHandlers(this); SubscribeToEvent(E_UPDATE, HANDLER(WebBrowserHost, HandleUpdate)); instance_ = this; }
NPError NP_Initialize(NPNetscapeFuncs *aNPNFuncs, NPPluginFuncs *aNPPFuncs) { trace_info_f("[NP] %s aNPNFuncs=%p, aNPPFuncs=%p, browser API version = %u\n", __func__, aNPNFuncs, aNPPFuncs, aNPNFuncs->version); // set logging-only error handler. // Ignore a previous one, we have no plans to restore it (void)XSetErrorHandler(x_error_handler); (void)XSetIOErrorHandler(x_io_error_hanlder); memset(&npn, 0, sizeof(npn)); memcpy(&npn, aNPNFuncs, sizeof(npn) < aNPNFuncs->size ? sizeof(npn) : aNPNFuncs->size); NPPluginFuncs pf; memset(&pf, 0, sizeof(NPPluginFuncs)); pf.size = MIN(aNPPFuncs->size, sizeof(NPPluginFuncs)); // browser is supposed to fill .size and .version pf.newp = NPP_New; pf.destroy = NPP_Destroy; pf.setwindow = NPP_SetWindow; pf.newstream = NPP_NewStream; pf.destroystream = NPP_DestroyStream; pf.asfile = NPP_StreamAsFile; pf.writeready = NPP_WriteReady; pf.write = NPP_Write; pf.print = NPP_Print; pf.event = NPP_HandleEvent; pf.urlnotify = NPP_URLNotify; pf.getvalue = NPP_GetValue; pf.setvalue = NPP_SetValue; pf.gotfocus = NPP_GotFocus; pf.lostfocus = NPP_LostFocus; pf.urlredirectnotify = NPP_URLRedirectNotify; pf.clearsitedata = NPP_ClearSiteData; pf.getsiteswithdata = NPP_GetSitesWithData; pf.didComposite = NPP_DidComposite; memcpy(aNPPFuncs, &pf, pf.size); if (tables_open_display() != 0) return NPERR_GENERIC_ERROR; if (aNPNFuncs->version < NPVERS_HAS_PLUGIN_THREAD_ASYNC_CALL) { config.quirks.plugin_missing = 1; config.quirks.incompatible_npapi_version = 1; } load_ppp_module(); int res = call_plugin_init_module(); if (res != 0) { trace_error("%s, PPP_InitializeModule returned %d\n", __func__, res); return NPERR_GENERIC_ERROR; } return NPERR_NO_ERROR; }
void XIOError_Shutdown(ToolsAppCtx *ctx, ToolsPluginData *pdata) { XSetIOErrorHandler(gOrigHandler); gCtx = NULL; gOrigHandler = NULL; }
void meta_errors_init (void) { #if !GTK_CHECK_VERSION (3, 0, 0) XSetErrorHandler (x_error_handler); XSetIOErrorHandler (x_io_error_handler); #endif }
/*----------------------------------------------------------------------------*/ void VKStopXSession() { VKResetMode(); XSync(display, False); XSetIOErrorHandler(old_io_error_handler); XSetErrorHandler(old_error_handler); XCloseDisplay(display); }
static void Init_disp_prop(Display *d, Window win, unsigned w, unsigned h, int x, int y, int flags) { XClassHint xclh; XWMHints xwmh; XSizeHints xsh; xwmh.flags = InputHint|StateHint|IconPixmapHint; xwmh.input = True; xwmh.initial_state = NormalState; xwmh.icon_pixmap = XCreateBitmapFromData(d, win, (char *)icon_bits, icon_width, icon_height); xsh.flags = (flags|PMinSize|PMaxSize|PBaseSize|PResizeInc); xsh.width = w; xsh.base_width = xsh.min_width = MIN_TOP_WIDTH; xsh.max_width = MAX_TOP_WIDTH; xsh.width_inc = 1; xsh.height = h; xsh.base_height = xsh.min_height = MIN_TOP_HEIGHT; xsh.max_height = MAX_TOP_HEIGHT; xsh.height_inc = 1; xsh.x = x; xsh.y = y; xclh.res_name = NULL; /* NULL: Automatically uses Argv[0], */ xclh.res_class = myClass; /* stripped of directory prefixes. */ /* * Set the above properties. */ XSetWMProperties(d, win, NULL, NULL, Argv, Argc, &xsh, &xwmh, &xclh); /* * Now initialize icon and window title name. */ XStoreName(d, win, TITLE); XSetIconName(d, win, TITLE); if (d != dpy) return; /* * Specify IO error handler and the WM_DELETE_WINDOW atom in * an attempt to catch 'nasty' quits. */ ProtocolAtom = XInternAtom(d, "WM_PROTOCOLS", False); KillAtom = XInternAtom(d, "WM_DELETE_WINDOW", False); XSetWMProtocols(d, win, &KillAtom, 1); XSetIOErrorHandler(FatalError); }
void App::StopServer() { // Stop alars clock and ignore signals alarm(0); signal(SIGQUIT, SIG_IGN); signal(SIGINT, SIG_IGN); signal(SIGHUP, SIG_IGN); signal(SIGPIPE, SIG_IGN); signal(SIGTERM, SIG_DFL); signal(SIGKILL, SIG_DFL); signal(SIGALRM, SIG_DFL); // Catch X error XSetIOErrorHandler(IgnoreXIO); if(!setjmp(CloseEnv)) XCloseDisplay(Dpy); // Send HUP to process group errno = 0; if((killpg(getpid(), SIGHUP) != 0) && (errno != ESRCH)) cerr << APPNAME << ": can't send HUP to process group " << getpid() << endl; // Send TERM to server if(ServerPID < 0) return; errno = 0; if(killpg(ServerPID, SIGTERM) < 0) { if(errno == EPERM) { cerr << APPNAME << ": can't kill X server" << endl; exit(ERR_EXIT); } if(errno == ESRCH) return; } // Wait for server to shut down if(!ServerTimeout(10, "X server to shut down")) { cerr << endl; return; } cerr << endl << APPNAME << ": X server slow to shut down, sending KILL signal." << endl; // Send KILL to server errno = 0; if(killpg(ServerPID, SIGKILL) < 0) { if(errno == ESRCH) return; } // Wait for server to die if(ServerTimeout(3, "server to die")) { cerr << endl << APPNAME << ": can't kill server" << endl; exit(ERR_EXIT); } cerr << endl; }
void _gdk_windowing_init (void) { _gdk_x11_initialize_locale (); XSetErrorHandler (gdk_x_error); XSetIOErrorHandler (gdk_x_io_error); _gdk_selection_property = gdk_atom_intern_static_string ("GDK_SELECTION"); }
int WaitForServer (struct display *d) { static int i; for (i = 0; i < (d->openRepeat > 0 ? d->openRepeat : 1); i++) { (void) Signal (SIGALRM, abortOpen); (void) alarm ((unsigned) d->openTimeout); if (!Setjmp (openAbort)) { Debug ("Before XOpenDisplay(%s)\n", d->name); errno = 0; (void) XSetIOErrorHandler (openErrorHandler); d->dpy = XOpenDisplay (d->name); (void) alarm ((unsigned) 0); (void) Signal (SIGALRM, SIG_DFL); (void) XSetIOErrorHandler ((int (*)(Display *)) 0); Debug ("After XOpenDisplay(%s)\n", d->name); if (d->dpy) { #ifdef XDMCP if (d->displayType.location == Foreign) GetRemoteAddress (d, ConnectionNumber (d->dpy)); #endif RegisterCloseOnFork (ConnectionNumber (d->dpy)); (void) fcntl (ConnectionNumber (d->dpy), F_SETFD, 0); return 1; } else { Debug ("OpenDisplay failed %d (%s) on \"%s\"\n", errno, strerror (errno), d->name); } Debug ("waiting for server to start %d\n", i); sleep ((unsigned) d->openDelay); } else { Debug ("hung in open, aborting\n"); LogError ("Hung in XOpenDisplay(%s), aborting\n", d->name); (void) Signal (SIGALRM, SIG_DFL); break; } } Debug ("giving up on server\n"); LogError ("server open failed for %s, giving up\n", d->name); return 0; }
int main(int argc, char *argv[]) { GWindow::initX(); TextEdit *editor = new TextEdit(); if (argc > 1) { editor->loadFile(argv[1]); } editor->createWindow(); XSetIOErrorHandler(&IOErrorHandler); GWindow::messageLoop(); GWindow::closeX(); delete editor; }
static void removeXErrorHandlers() { if (JUCEApplication::isStandaloneApp()) { XSetIOErrorHandler (oldIOErrorHandler); oldIOErrorHandler = 0; XSetErrorHandler (oldErrorHandler); oldErrorHandler = 0; } }
void XApplication::Run(bool runOnce) { XSetIOErrorHandler(ErrorHandler); /* * This is where you will implement the event loop. The basic * logic of the event loop is as follows: * - You should service the CS349 Scheme interpreter to ensure it * progresses (executes any scripts, accepts any user keyboard * input) (already done for you) * - Check the return code for scheme_interpreter_service. If it * returns a non-zero value, the application should quit * - You need to determine whether there are any events pending in * X lib: call CheckForXEvents(). * - You should call EventQueue's ProcessNextEvent() method to * process events and service the timers. Note, you should call * this *even if there are no events pending*, since it will * service the timers. * - You can optionally call XFlush() to flush X's queue of * graphics commands to the X server, but it is likely * unnecessary given calls to other Xlib functions. See the * following for more information: * http://tronche.com/gui/x/xlib/event-handling/XFlush.html * - You should sleep if there is nothing left to do (i.e., there * are no events in our event queue or pending in X's event * queue -- check with XPending). Sleeping for a bit will ensure * the CPU is not throttled. * - If you sleep, sleep for a very small amount of time, say * 1/1000 of a second, to enable interactive typing rates on the * console. (See the usleep function for fine-grained sleep * amounts). * - We *will* check to ensure your app doesn't throttle the CPU * when idle, so make sure you sleep when there are no events. */ this->quit = false; do { int interpreterReturnCode = 0; interpreterReturnCode = scheme_interpreter_service(); if (interpreterReturnCode == 1) { this->Quit(); } // LOG_TODO << "TODO CS349: Implement event loop in XApplication::Run (remove when implemented)"; // TODO CS349 this->CheckForXEvents(); this->GetEventQueue()->ProcessNextEvent(); XFlush(this->display); if(!XPending(this->display)){ usleep(1000); } } while (!this->quit && !runOnce); }
/* To be called right after connecting */ void meta_xwayland_complete_init (void) { /* We install an X IO error handler in addition to the child watch, because after Xlib connects our child watch may not be called soon enough, and therefore we won't crash when X exits (and most important we won't reset the tty). */ XSetIOErrorHandler (x_io_error); meta_xwayland_init_selection (); }
static VALUE gdk_s_set_x_io_error_handler(VALUE self) { #ifdef HAVE_XGETERRORTEXT rb_x_io_error = rb_block_proc(); G_RELATIVE(self, rb_x_io_error); XSetIOErrorHandler(rbgdk_x_io_error); #else rb_warn("Not supported on this environment."); #endif return self; }
void gdm_xerrors_init (void) { static gboolean initialized = FALSE; if (initialized) { return; } XSetErrorHandler (gdm_x_error); XSetIOErrorHandler (gdm_x_io_error); initialized = TRUE; }
void _gdk_x11_windowing_init (void) { XSetErrorHandler (gdk_x_error); XSetIOErrorHandler (gdk_x_io_error); gdk_window_add_filter (NULL, _gdk_wm_protocols_filter, NULL); gdk_window_add_filter (NULL, _gdk_x11_dnd_filter, NULL); }