From http://www.jwz.org/xscreensaver/xscreensaver-5.16.tar.gz
[xscreensaver] / driver / remote.c
1 /* xscreensaver-command, Copyright (c) 1991-2009 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or 
9  * implied warranty.
10  */
11
12 #ifdef HAVE_CONFIG_H
13 # include "config.h"
14 #endif
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <time.h>
19 #include <sys/time.h>
20 #include <sys/types.h>
21
22 #ifdef HAVE_SYS_SELECT_H
23 # include <sys/select.h>
24 #endif /* HAVE_SYS_SELECT_H */
25
26 #ifdef HAVE_UNISTD_H
27 # include <unistd.h>
28 #endif
29
30 #include <X11/Xproto.h>         /* for CARD32 */
31 #include <X11/Xlib.h>
32 #include <X11/Xatom.h>
33 #include <X11/Xutil.h>          /* for XGetClassHint() */
34 #include <X11/Xos.h>
35
36 #include "remote.h"
37
38 #ifdef _VROOT_H_
39 ERROR! you must not include vroot.h in this file
40 #endif
41
42 extern char *progname;
43 extern Atom XA_SCREENSAVER, XA_SCREENSAVER_VERSION, XA_SCREENSAVER_RESPONSE;
44 extern Atom XA_SCREENSAVER_ID, XA_SCREENSAVER_STATUS, XA_EXIT;
45 extern Atom XA_VROOT, XA_SELECT, XA_DEMO, XA_BLANK, XA_LOCK;
46
47
48 static XErrorHandler old_handler = 0;
49 static Bool got_badwindow = False;
50 static int
51 BadWindow_ehandler (Display *dpy, XErrorEvent *error)
52 {
53   if (error->error_code == BadWindow)
54     {
55       got_badwindow = True;
56       return 0;
57     }
58   else
59     {
60       fprintf (stderr, "%s: ", progname);
61       if (!old_handler) abort();
62       return (*old_handler) (dpy, error);
63     }
64 }
65
66
67
68 static Window
69 find_screensaver_window (Display *dpy, char **version)
70 {
71   int i;
72   Window root = RootWindowOfScreen (DefaultScreenOfDisplay (dpy));
73   Window root2, parent, *kids;
74   unsigned int nkids;
75
76   if (version) *version = 0;
77
78   if (! XQueryTree (dpy, root, &root2, &parent, &kids, &nkids))
79     abort ();
80   if (root != root2)
81     abort ();
82   if (parent)
83     abort ();
84   if (! (kids && nkids))
85     return 0;
86   for (i = 0; i < nkids; i++)
87     {
88       Atom type;
89       int format;
90       unsigned long nitems, bytesafter;
91       unsigned char *v;
92       int status;
93
94       /* We're walking the list of root-level windows and trying to find
95          the one that has a particular property on it.  We need to trap
96          BadWindows errors while doing this, because it's possible that
97          some random window might get deleted in the meantime.  (That
98          window won't have been the one we're looking for.)
99        */
100       XSync (dpy, False);
101       if (old_handler) abort();
102       got_badwindow = False;
103       old_handler = XSetErrorHandler (BadWindow_ehandler);
104       status = XGetWindowProperty (dpy, kids[i],
105                                    XA_SCREENSAVER_VERSION,
106                                    0, 200, False, XA_STRING,
107                                    &type, &format, &nitems, &bytesafter,
108                                    &v);
109       XSync (dpy, False);
110       XSetErrorHandler (old_handler);
111       old_handler = 0;
112
113       if (got_badwindow)
114         {
115           status = BadWindow;
116           got_badwindow = False;
117         }
118
119       if (status == Success && type != None)
120         {
121           Window ret = kids[i];
122           if (version)
123             *version = (char *) v;
124           XFree (kids);
125           return ret;
126         }
127     }
128
129   if (kids) XFree (kids);
130   return 0;
131 }
132
133
134 static int
135 send_xscreensaver_command (Display *dpy, Atom command, long arg,
136                            Window *window_ret, char **error_ret)
137 {
138   int status = -1;
139   char *v = 0;
140   Window window = find_screensaver_window (dpy, &v);
141   XWindowAttributes xgwa;
142   char err[2048];
143
144   if (window_ret)
145     *window_ret = window;
146
147   if (!window)
148     {
149       sprintf (err, "no screensaver is running on display %s",
150                DisplayString (dpy));
151
152       if (error_ret)
153         {
154           *error_ret = strdup (err);
155           status = -1;
156           goto DONE;
157         }
158
159       if (command == XA_EXIT)
160         {
161           /* Don't print an error if xscreensaver is already dead. */
162           status = 1;
163           goto DONE;
164         }
165
166       fprintf (stderr, "%s: %s\n", progname, err);
167       status = -1;
168       goto DONE;
169     }
170
171   /* Select for property change events, so that we can read the response. */
172   XGetWindowAttributes (dpy, window, &xgwa);
173   XSelectInput (dpy, window, xgwa.your_event_mask | PropertyChangeMask);
174
175   if (command == XA_SCREENSAVER_STATUS ||
176       command == XA_SCREENSAVER_VERSION)
177     {
178       XClassHint hint;
179       memset (&hint, 0, sizeof(hint));
180       if (!v || !*v)
181         {
182           sprintf (err, "version property not set on window 0x%x?",
183                    (unsigned int) window);
184           if (error_ret)
185             *error_ret = strdup (err);
186           else
187             fprintf (stderr, "%s: %s\n", progname, err);
188
189           status = -1;
190           goto DONE;
191         }
192
193       XGetClassHint(dpy, window, &hint);
194       if (!hint.res_class)
195         {
196           sprintf (err, "class hints not set on window 0x%x?",
197                    (unsigned int) window);
198           if (error_ret)
199             *error_ret = strdup (err);
200           else
201             fprintf (stderr, "%s: %s\n", progname, err);
202
203           status = -1;
204           goto DONE;
205         }
206
207       fprintf (stdout, "%s %s", hint.res_class, v);
208
209       if (command != XA_SCREENSAVER_STATUS)
210         {
211           fprintf (stdout, "\n");
212         }
213       else
214         {
215           Atom type;
216           int format;
217           unsigned long nitems, bytesafter;
218           unsigned char *dataP = 0;
219
220           if (XGetWindowProperty (dpy,
221                                   RootWindow (dpy, 0),
222                                   XA_SCREENSAVER_STATUS,
223                                   0, 999, False, XA_INTEGER,
224                                   &type, &format, &nitems, &bytesafter,
225                                   &dataP)
226               == Success
227               && type
228               && dataP)
229             {
230               Atom blanked;
231               time_t tt;
232               char *s;
233               Atom *data = (Atom *) dataP;
234
235               if (type != XA_INTEGER || nitems < 3)
236                 {
237                 STATUS_LOSE:
238                   if (data) free (data);
239                   fprintf (stdout, "\n");
240                   fflush (stdout);
241                   fprintf (stderr, "bad status format on root window.\n");
242                   status = -1;
243                   goto DONE;
244                 }
245                   
246               blanked = (Atom) data[0];
247               tt = (time_t) data[1];
248
249               if (tt <= (time_t) 666000000L) /* early 1991 */
250                 goto STATUS_LOSE;
251
252               if (blanked == XA_BLANK)
253                 fputs (": screen blanked since ", stdout);
254               else if (blanked == XA_LOCK)
255                 fputs (": screen locked since ", stdout);
256               else if (blanked == 0)
257                 /* suggestions for a better way to phrase this are welcome. */
258                 fputs (": screen non-blanked since ", stdout);
259               else
260                 /* `blanked' has an unknown value - fail. */
261                 goto STATUS_LOSE;
262
263               s = ctime(&tt);
264               if (s[strlen(s)-1] == '\n')
265                 s[strlen(s)-1] = 0;
266               fputs (s, stdout);
267
268               {
269                 int nhacks = nitems - 2;
270                 Bool any = False;
271                 int i;
272                 for (i = 0; i < nhacks; i++)
273                   if (data[i + 2] > 0)
274                     {
275                       any = True;
276                       break;
277                     }
278
279                 if (any && nhacks == 1)
280                   fprintf (stdout, " (hack #%d)\n", (int) data[2]);
281                 else if (any)
282                   {
283                     fprintf (stdout, " (hacks: ");
284                     for (i = 0; i < nhacks; i++)
285                       {
286                         fprintf (stdout, "#%d", (int) data[2 + i]);
287                         if (i != nhacks-1)
288                           fputs (", ", stdout);
289                       }
290                     fputs (")\n", stdout);
291                   }
292                 else
293                   fputs ("\n", stdout);
294               }
295
296               if (data) free (data);
297             }
298           else
299             {
300               if (dataP) XFree (dataP);
301               fprintf (stdout, "\n");
302               fflush (stdout);
303               fprintf (stderr, "no saver status on root window.\n");
304               status = -1;
305               goto DONE;
306             }
307         }
308
309       /* No need to read a response for these commands. */
310       status = 1;
311       goto DONE;
312     }
313   else
314     {
315       XEvent event;
316       long arg1 = arg;
317       long arg2 = 0;
318
319       if (arg < 0)
320         abort();
321       else if (arg == 0 && command == XA_SELECT)
322         abort();
323       else if (arg != 0 && command == XA_DEMO)
324         {
325           arg1 = 5000;  /* version number of the XA_DEMO protocol, */
326           arg2 = arg;   /* since it didn't use to take an argument. */
327         }
328
329       event.xany.type = ClientMessage;
330       event.xclient.display = dpy;
331       event.xclient.window = window;
332       event.xclient.message_type = XA_SCREENSAVER;
333       event.xclient.format = 32;
334       memset (&event.xclient.data, 0, sizeof(event.xclient.data));
335       event.xclient.data.l[0] = (long) command;
336       event.xclient.data.l[1] = arg1;
337       event.xclient.data.l[2] = arg2;
338       if (! XSendEvent (dpy, window, False, 0L, &event))
339         {
340           sprintf (err, "XSendEvent(dpy, 0x%x ...) failed.\n",
341                    (unsigned int) window);
342           if (error_ret)
343             *error_ret = strdup (err);
344           else
345             fprintf (stderr, "%s: %s\n", progname, err);
346           status = -1;
347           goto DONE;
348         }
349     }
350
351   status = 0;
352
353  DONE:
354   if (v) free (v);
355   XSync (dpy, 0);
356   return status;
357 }
358
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
369 static int
370 xscreensaver_command_response (Display *dpy, Window window,
371                                Bool verbose_p, Bool exiting_p,
372                                char **error_ret)
373 {
374   int sleep_count = 0;
375   char err[2048];
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 # if defined(HAVE_SELECT)
384       /* Wait for an event, but don't wait longer than 1 sec.  Note that we
385          might do this multiple times if an event comes in, but it wasn't
386          the event we're waiting for.
387        */
388       int fd = XConnectionNumber(dpy);
389       fd_set rset;
390       struct timeval tv;
391       tv.tv_sec  = 1;
392       tv.tv_usec = 0;
393       FD_ZERO (&rset);
394       FD_SET (fd, &rset);
395       select (fd+1, &rset, 0, 0, &tv);
396 # else  /* !HAVE_SELECT */
397       sleep(1);
398 # endif /* !HAVE_SELECT */
399     }
400
401   if (!got_event)
402     {
403       sprintf (err, "no response to command.");
404       if (error_ret)
405         *error_ret = strdup (err);
406       else
407         fprintf (stderr, "%s: %s\n", progname, err);
408
409       return -1;
410     }
411   else
412     {
413       Status st2;
414       Atom type;
415       int format;
416       unsigned long nitems, bytesafter;
417       unsigned char *msg = 0;
418
419       XSync (dpy, False);
420       if (old_handler) abort();
421       old_handler = XSetErrorHandler (BadWindow_ehandler);
422       st2 = XGetWindowProperty (dpy, window,
423                                 XA_SCREENSAVER_RESPONSE,
424                                 0, 1024, True,
425                                 AnyPropertyType,
426                                 &type, &format, &nitems, &bytesafter,
427                                 &msg);
428       XSync (dpy, False);
429       XSetErrorHandler (old_handler);
430       old_handler = 0;
431
432       if (got_badwindow)
433         {
434           if (exiting_p)
435             return 0;
436
437           sprintf (err, "xscreensaver window unexpectedly deleted.");
438
439           if (error_ret)
440             *error_ret = strdup (err);
441           else
442             fprintf (stderr, "%s: %s\n", progname, err);
443
444           return -1;
445         }
446
447       if (st2 == Success && type != None)
448         {
449           if (type != XA_STRING || format != 8)
450             {
451               sprintf (err, "unrecognized response property.");
452
453               if (error_ret)
454                 *error_ret = strdup (err);
455               else
456                 fprintf (stderr, "%s: %s\n", progname, err);
457
458               if (msg) XFree (msg);
459               return -1;
460             }
461           else if (!msg || (msg[0] != '+' && msg[0] != '-'))
462             {
463               sprintf (err, "unrecognized response message.");
464
465               if (error_ret)
466                 *error_ret = strdup (err);
467               else  
468                 fprintf (stderr, "%s: %s\n", progname, err);
469
470               if (msg) XFree (msg);
471               return -1;
472             }
473           else
474             {
475               int ret = (msg[0] == '+' ? 0 : -1);
476               sprintf (err, "%s: %s\n", progname, (char *) msg+1);
477
478               if (error_ret)
479                 *error_ret = strdup (err);
480               else if (verbose_p || ret != 0)
481                 fprintf ((ret < 0 ? stderr : stdout), "%s\n", err);
482
483               XFree (msg);
484               return ret;
485             }
486         }
487     }
488
489   return -1;  /* warning suppression: not actually reached */
490 }
491
492
493 int
494 xscreensaver_command (Display *dpy, Atom command, long arg, Bool verbose_p,
495                       char **error_ret)
496 {
497   Window w = 0;
498   int status = send_xscreensaver_command (dpy, command, arg, &w, error_ret);
499   if (status == 0)
500     status = xscreensaver_command_response (dpy, w, verbose_p,
501                                             (command == XA_EXIT),
502                                             error_ret);
503
504   fflush (stdout);
505   fflush (stderr);
506   return (status < 0 ? status : 0);
507 }
508
509
510 void
511 server_xscreensaver_version (Display *dpy,
512                              char **version_ret,
513                              char **user_ret,
514                              char **host_ret)
515 {
516   Window window = find_screensaver_window (dpy, 0);
517
518   Atom type;
519   int format;
520   unsigned long nitems, bytesafter;
521
522   if (version_ret)
523     *version_ret = 0;
524   if (user_ret)
525     *user_ret = 0;
526   if (host_ret)
527     *host_ret = 0;
528
529   if (!window)
530     return;
531
532   if (version_ret)
533     {
534       unsigned char *v = 0;
535       XGetWindowProperty (dpy, window, XA_SCREENSAVER_VERSION, 0, 1,
536                           False, XA_STRING, &type, &format, &nitems,
537                           &bytesafter, &v);
538       if (v)
539         {
540           *version_ret = strdup ((char *) v);
541           XFree (v);
542         }
543     }
544
545   if (user_ret || host_ret)
546     {
547       unsigned char *id = 0;
548       const char *user = 0;
549       const char *host = 0;
550
551       XGetWindowProperty (dpy, window, XA_SCREENSAVER_ID, 0, 512,
552                           False, XA_STRING, &type, &format, &nitems,
553                           &bytesafter, &id);
554       if (id && *id)
555         {
556           const char *old_tag = " on host ";
557           const char *s = strstr ((char *) id, old_tag);
558           if (s)
559             {
560               /* found ID of the form "1234 on host xyz". */
561               user = 0;
562               host = s + strlen (old_tag);
563             }
564           else
565             {
566               char *o = 0, *p = 0, *c = 0;
567               o = strchr ((char *) id, '(');
568               if (o) p = strchr (o, '@');
569               if (p) c = strchr (p, ')');
570               if (c)
571                 {
572                   /* found ID of the form "1234 (user@host)". */
573                   user = o+1;
574                   host = p+1;
575                   *p = 0;
576                   *c = 0;
577                 }
578             }
579
580         }
581
582       if (user && *user && *user != '?')
583         *user_ret = strdup (user);
584       else
585         *user_ret = 0;
586
587       if (host && *host && *host != '?')
588         *host_ret = strdup (host);
589       else
590         *host_ret = 0;
591
592       if (id)
593         XFree (id);
594     }
595 }