compiled-tools/xdpys.c

   1
   2 #include <X11/Xlib.h>
   3 #include <X11/Xos.h>
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <signal.h>
   8 #include <setjmp.h>
   9 #include <err.h>
  10 #include <dirent.h>
  11 #include <sys/types.h>
  12
  13 #define LISTSIZE(x) (sizeof(x)/sizeof(*x)-1)
  14 #define DPYNAME_MAXLEN 255
  15
  16
  17 static jmp_buf xopendpy;
  18 unsigned int timeout = 2;
  19 unsigned int verbose = 0;
  20 unsigned int found_a_valid_display = 0;
  21
  22
  23 void alarm_handler(int sig)
  24 {
  25         siglongjmp(xopendpy, 1);
  26 }
  27
  28 unsigned int is_valid_xdisplay(char* dpyname)
  29 {
  30         Display* dpy;
  31
  32         if(verbose) fprintf(stderr, "Opening X display %s\n", dpyname);
  33
  34         alarm(timeout);
  35         if(!sigsetjmp(xopendpy, 1))
  36         {
  37                 dpy = XOpenDisplay(dpyname);
  38         }
  39         else
  40         {
  41                 dpy = NULL;
  42         }
  43         alarm(0);
  44         if(dpy != NULL)
  45         {
  46                 XCloseDisplay(dpy);
  47                 found_a_valid_display = 1;
  48                 printf("%s\n", dpyname == NULL ? getenv("DISPLAY") : dpyname);
  49                 return 1;
  50         }
  51         return 0;
  52 }
  53
  54 int main(int argc, char** argv)
  55 {
  56         Display* dpy;
  57         char dpyname[DPYNAME_MAXLEN];
  58         unsigned int num;
  59         int c;
  60         int search_abstract = 1;
  61         int search_sockets = 1;
  62         int search_inet_max = 30;
  63         FILE* fh;
  64         char socksbuf[92];
  65         DIR* dh;
  66         struct dirent* dent;
  67         unsigned int u;
  68
  69
  70         while((c = getopt(argc, argv, "hvASt:x:")) != -1)
  71         {
  72                 switch(c)
  73                 {
  74                         case 't':
  75                                 timeout = atoi(optarg);
  76                         break;
  77                         case 'v':
  78                                 verbose = 1;
  79                         break;
  80                         case 'A':
  81                                 search_abstract = 0;
  82                         break;
  83                         case 'S':
  84                                 search_sockets = 0;
  85                         break;
  86                         case 'x':
  87                                 search_inet_max = atoi(optarg);
  88                         break;
  89                         case 'h':
  90                                 printf("Usage: xdpys [-h|-v|-A|-S] [-t <sec>] [-x <max>] [display [display [...]]]\n"
  91 " -h       this help\n"
  92 " -v       verbose output to stderr\n"
  93 " -A       don't test abstract unix sockets\n"
  94 " -S       don't test unix socket files\n"
  95 " -t <n>   timeout for individual XDisplay open calls (%d)\n"
  96 " -x <n>   search this many X.org display in INET namespace (%d)\n",
  97                                         timeout,
  98                                         search_inet_max);
  99                                 _exit(EXIT_SUCCESS);
 100                         break;
 101                         case '?':
 102                                 _exit(EXIT_FAILURE);
 103                         break;
 104                 }
 105         }
 106
 107
 108         signal(SIGALRM, alarm_handler);
 109
 110         if(optind >= argc)
 111         {
 112                 if(search_abstract)
 113                 {
 114                         fh = fopen("/proc/net/unix", "r");
 115                         if(fh != NULL)
 116                         {
 117                                 while(!feof(fh))
 118                                 {
 119                                         fgets(socksbuf, 91, fh);
 120                                         // e5d1fa40: 00000002 00000000 00010000 0001 01 187671 @/tmp/.X11-unix/X1003
 121                                         // e697ba80: 00000002 00000000 00010000 0001 01 20247 @/tmp/.X11-unix/X1000
 122                                         if(sscanf(socksbuf, "%*[^ ] %*[^ ] %*[^ ] %*[^ ] %*[^ ] 01 %*[^ ] @/tmp/.X11-unix/X%u", &u) == 1)
 123                                         {
 124                                                 snprintf(dpyname, DPYNAME_MAXLEN, ":%u", u);
 125                                                 is_valid_xdisplay(dpyname);
 126                                         }
 127                                         while(socksbuf[strlen(socksbuf)-1] != '\n')
 128                                         {
 129                                                 fgets(socksbuf, 91, fh);
 130                                         }
 131                                 }
 132                         }
 133                         fclose(fh);
 134                 }
 135
 136                 if(search_sockets)
 137                 {
 138                         dh = opendir("/tmp/.X11-unix");
 139                         while((dent = readdir(dh)) != NULL)
 140                         {
 141                                 if(dent->d_type == DT_SOCK && sscanf(dent->d_name, "X%u", &u) == 1)
 142                                 {
 143                                         snprintf(dpyname, DPYNAME_MAXLEN, ":%u", u);
 144                                         is_valid_xdisplay(dpyname);
 145                                 }
 146                         }
 147                         closedir(dh);
 148                 }
 149
 150                 for(num = 0; num < search_inet_max; num++)
 151                 {
 152                         snprintf(dpyname, DPYNAME_MAXLEN, "localhost:%d", num);
 153                         is_valid_xdisplay(dpyname);
 154                 }
 155         }
 156         else
 157         {
 158                 while(optind < argc)
 159                 {
 160                         is_valid_xdisplay(argv[optind]);
 161                         optind++;
 162                 }
 163         }
 164
 165         return found_a_valid_display ? EXIT_SUCCESS : EXIT_FAILURE;
 166 }