← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xscreensaver/trusty

« back to all changes in this revision

Viewing changes to driver/remote.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-11-30 13:33:13 UTC
  • mfrom: (1.1.8 upstream) (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091130133313-3b5nz2e7hvbb8h3l
Tags: 5.10-3ubuntu1
https://launchpad.net/bugs/489062
* Merge with Debian unstable, remaining changes: (LP: #489062)
  - debian/control: add Build-Depends on ubuntu-artwork
  - debian/rules: use /usr/share/backgrounds
  - debian/control: Move xli | xloadimage recommends to suggests
  - debian/split-hacks.config: Use different set of default hacks to Debian
  - debian/source_xscreensaver.py: Add apport hook
  - debian/patches/53_XScreenSaver.ad.in.patch: Use Ubuntu branding

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver/remote.c
1
 
/* xscreensaver-command, Copyright (c) 1991-2005 Jamie Zawinski <jwz@jwz.org>
 
1
/* xscreensaver-command, Copyright (c) 1991-2009 Jamie Zawinski <jwz@jwz.org>
2
2
 *
3
3
 * Permission to use, copy, modify, distribute, and sell this software and its
4
4
 * documentation for any purpose is hereby granted without fee, provided that
357
357
}
358
358
 
359
359
 
 
360
static Bool
 
361
xscreensaver_command_event_p (Display *dpy, XEvent *event, XPointer arg)
 
362
{
 
363
  return (event->xany.type == PropertyNotify &&
 
364
          event->xproperty.state == PropertyNewValue &&
 
365
          event->xproperty.atom == XA_SCREENSAVER_RESPONSE);
 
366
}
 
367
 
 
368
 
360
369
static int
361
370
xscreensaver_command_response (Display *dpy, Window window,
362
371
                               Bool verbose_p, Bool exiting_p,
363
372
                               char **error_ret)
364
373
{
365
 
  int fd = ConnectionNumber (dpy);
366
 
  int timeout = 10;
367
 
  int status;
368
 
  fd_set fds;
369
 
  struct timeval tv;
 
374
  int sleep_count = 0;
370
375
  char err[2048];
371
 
 
372
 
  while (1)
373
 
    {
374
 
      FD_ZERO(&fds);
375
 
      FD_SET(fd, &fds);
376
 
      memset(&tv, 0, sizeof(tv));
377
 
      tv.tv_sec = timeout;
378
 
      status = select (fd+1, &fds, 0, &fds, &tv);
379
 
 
380
 
      if (status < 0)
381
 
        {
382
 
          char buf[1024];
383
 
          if (error_ret)
384
 
            {
385
 
              sprintf (buf, "error waiting for reply");
386
 
              *error_ret = strdup (buf);
387
 
            }
388
 
          else
389
 
            {
390
 
              sprintf (buf, "%s: error waiting for reply", progname);
391
 
              perror (buf);
392
 
            }
393
 
          return status;
394
 
        }
395
 
      else if (status == 0)
396
 
        {
397
 
          sprintf (err, "no response to command.");
398
 
          if (error_ret)
399
 
            *error_ret = strdup (err);
400
 
          else
401
 
            fprintf (stderr, "%s: %s\n", progname, err);
 
376
  XEvent event;
 
377
  Bool got_event = False;
 
378
 
 
379
  while (!(got_event = XCheckIfEvent(dpy, &event,
 
380
                                     &xscreensaver_command_event_p, 0)) &&
 
381
         sleep_count++ < 10)
 
382
    {
 
383
      sleep(1);
 
384
    }
 
385
 
 
386
  if (!got_event)
 
387
    {
 
388
      sprintf (err, "no response to command.");
 
389
      if (error_ret)
 
390
        *error_ret = strdup (err);
 
391
      else
 
392
        fprintf (stderr, "%s: %s\n", progname, err);
 
393
 
 
394
      return -1;
 
395
    }
 
396
  else
 
397
    {
 
398
      Status st2;
 
399
      Atom type;
 
400
      int format;
 
401
      unsigned long nitems, bytesafter;
 
402
      unsigned char *msg = 0;
 
403
 
 
404
      XSync (dpy, False);
 
405
      if (old_handler) abort();
 
406
      old_handler = XSetErrorHandler (BadWindow_ehandler);
 
407
      st2 = XGetWindowProperty (dpy, window,
 
408
                                XA_SCREENSAVER_RESPONSE,
 
409
                                0, 1024, True,
 
410
                                AnyPropertyType,
 
411
                                &type, &format, &nitems, &bytesafter,
 
412
                                &msg);
 
413
      XSync (dpy, False);
 
414
      XSetErrorHandler (old_handler);
 
415
      old_handler = 0;
 
416
 
 
417
      if (got_badwindow)
 
418
        {
 
419
          if (exiting_p)
 
420
            return 0;
 
421
 
 
422
          sprintf (err, "xscreensaver window unexpectedly deleted.");
 
423
 
 
424
          if (error_ret)
 
425
            *error_ret = strdup (err);
 
426
          else
 
427
            fprintf (stderr, "%s: %s\n", progname, err);
 
428
 
402
429
          return -1;
403
430
        }
404
 
      else
 
431
 
 
432
      if (st2 == Success && type != None)
405
433
        {
406
 
          XEvent event;
407
 
          XNextEvent (dpy, &event);
408
 
          if (event.xany.type == PropertyNotify &&
409
 
              event.xproperty.state == PropertyNewValue &&
410
 
              event.xproperty.atom == XA_SCREENSAVER_RESPONSE)
411
 
            {
412
 
              Status st2;
413
 
              Atom type;
414
 
              int format;
415
 
              unsigned long nitems, bytesafter;
416
 
              unsigned char *msg = 0;
417
 
 
418
 
              XSync (dpy, False);
419
 
              if (old_handler) abort();
420
 
              old_handler = XSetErrorHandler (BadWindow_ehandler);
421
 
              st2 = XGetWindowProperty (dpy, window,
422
 
                                        XA_SCREENSAVER_RESPONSE,
423
 
                                        0, 1024, True,
424
 
                                        AnyPropertyType,
425
 
                                        &type, &format, &nitems, &bytesafter,
426
 
                                        &msg);
427
 
              XSync (dpy, False);
428
 
              XSetErrorHandler (old_handler);
429
 
              old_handler = 0;
430
 
 
431
 
              if (got_badwindow)
432
 
                {
433
 
                  if (exiting_p)
434
 
                    return 0;
435
 
 
436
 
                  sprintf (err, "xscreensaver window unexpectedly deleted.");
437
 
 
438
 
                  if (error_ret)
439
 
                    *error_ret = strdup (err);
440
 
                  else
441
 
                    fprintf (stderr, "%s: %s\n", progname, err);
442
 
 
443
 
                  return -1;
444
 
                }
445
 
 
446
 
              if (st2 == Success && type != None)
447
 
                {
448
 
                  if (type != XA_STRING || format != 8)
449
 
                    {
450
 
                      sprintf (err, "unrecognized response property.");
451
 
 
452
 
                      if (error_ret)
453
 
                        *error_ret = strdup (err);
454
 
                      else
455
 
                        fprintf (stderr, "%s: %s\n", progname, err);
456
 
 
457
 
                      if (msg) XFree (msg);
458
 
                      return -1;
459
 
                    }
460
 
                  else if (!msg || (msg[0] != '+' && msg[0] != '-'))
461
 
                    {
462
 
                      sprintf (err, "unrecognized response message.");
463
 
 
464
 
                      if (error_ret)
465
 
                        *error_ret = strdup (err);
466
 
                      else  
467
 
                        fprintf (stderr, "%s: %s\n", progname, err);
468
 
 
469
 
                      if (msg) XFree (msg);
470
 
                      return -1;
471
 
                    }
472
 
                  else
473
 
                    {
474
 
                      int ret = (msg[0] == '+' ? 0 : -1);
475
 
                      sprintf (err, "%s: %s\n", progname, (char *) msg+1);
476
 
 
477
 
                      if (error_ret)
478
 
                        *error_ret = strdup (err);
479
 
                      else if (verbose_p || ret != 0)
480
 
                        fprintf ((ret < 0 ? stderr : stdout), "%s\n", err);
481
 
 
482
 
                      XFree (msg);
483
 
                      return ret;
484
 
                    }
485
 
                }
 
434
          if (type != XA_STRING || format != 8)
 
435
            {
 
436
              sprintf (err, "unrecognized response property.");
 
437
 
 
438
              if (error_ret)
 
439
                *error_ret = strdup (err);
 
440
              else
 
441
                fprintf (stderr, "%s: %s\n", progname, err);
 
442
 
 
443
              if (msg) XFree (msg);
 
444
              return -1;
 
445
            }
 
446
          else if (!msg || (msg[0] != '+' && msg[0] != '-'))
 
447
            {
 
448
              sprintf (err, "unrecognized response message.");
 
449
 
 
450
              if (error_ret)
 
451
                *error_ret = strdup (err);
 
452
              else  
 
453
                fprintf (stderr, "%s: %s\n", progname, err);
 
454
 
 
455
              if (msg) XFree (msg);
 
456
              return -1;
 
457
            }
 
458
          else
 
459
            {
 
460
              int ret = (msg[0] == '+' ? 0 : -1);
 
461
              sprintf (err, "%s: %s\n", progname, (char *) msg+1);
 
462
 
 
463
              if (error_ret)
 
464
                *error_ret = strdup (err);
 
465
              else if (verbose_p || ret != 0)
 
466
                fprintf ((ret < 0 ? stderr : stdout), "%s\n", err);
 
467
 
 
468
              XFree (msg);
 
469
              return ret;
486
470
            }
487
471
        }
488
472
    }
 
473
 
 
474
  return -1;  /* warning suppression: not actually reached */
489
475
}
490
476
 
491
477