~sbalneav/ltsp/xexit

« back to all changes in this revision

Viewing changes to src/xexit.c

  • Committer: Scott Balneaves
  • Date: 2010-05-21 00:23:51 UTC
  • Revision ID: sbalneav@ltsp.org-20100521002351-c12p489u76rogdz1
Bit of code cleanup, run through indent

Show diffs side-by-side

added added

removed removed

Lines of Context:
24
24
#define XDIE 2
25
25
#define PING_INTERVAL 10
26
26
 
27
 
char *script;           /* Script to exit at logout */
28
 
char *d;                /* DISPLAY environment variable */
29
 
Display *dpy = NULL;    /* Display */
 
27
char *script;                   /* Script to exit at logout */
 
28
char *d;                        /* DISPLAY environment variable */
 
29
Display *dpy = NULL;            /* Display */
30
30
 
31
31
static int
32
 
handle_xerror(Display *display)
 
32
handle_xerror (Display * display)
33
33
{
34
 
    execlp(script, script, NULL);
 
34
  execlp (script, script, NULL);
35
35
}
36
36
 
37
37
void
38
 
run_script(void)
 
38
run_script (void)
39
39
{
40
 
    if (dpy != NULL) {
41
 
        handle_xerror(dpy);
 
40
  if (dpy != NULL)
 
41
    {
 
42
      handle_xerror (dpy);
42
43
    }
43
44
}
44
45
 
50
51
 */
51
52
 
52
53
void
53
 
ping_timeout(void *nothing)
54
 
{
55
 
    struct timespec ping_interval;
56
 
    Display *pd;
57
 
 
58
 
    while (1) {
59
 
        ping_interval.tv_sec = PING_INTERVAL;
60
 
        ping_interval.tv_nsec = 0;
61
 
        nanosleep(&ping_interval, NULL);
62
 
        if (!(pd = XOpenDisplay(d))) {
63
 
            run_script();
64
 
        }
65
 
        XCloseDisplay(pd);
66
 
    }
67
 
}
68
 
 
69
 
int
70
 
handle_propchange(Display *d, Window w, Atom a)
71
 
{
72
 
    char *result;
73
 
    Atom type;
74
 
    int format, res;
75
 
    unsigned long nitems, nleft;
76
 
    int return_val;
77
 
 
78
 
 
79
 
    res = XGetWindowProperty(d, w, a, 0, 512, 0, XA_STRING,
80
 
                             &type, &format, &nitems, &nleft,
81
 
                             (unsigned char **) &result);
82
 
 
83
 
    if (res != Success) {
84
 
        return;
85
 
    } else if (type != XA_STRING) {
86
 
        XFree(result);
87
 
        return;
88
 
    }
89
 
 
90
 
    /*
91
 
     * We now have a string (command).
92
 
     */
93
 
 
94
 
    if (!strcmp(result, "EXIT")) {
95
 
        return_val = XEXIT;
96
 
    } else if (!strcmp(result, "DIE")) {
97
 
        return_val = XDIE;
98
 
    } else {
99
 
        return_val = 0;
100
 
    }
101
 
 
102
 
    XFree(result);                  /* free up returned data */
103
 
    return return_val;
104
 
}
105
 
 
106
 
int
107
 
main(int argc, char *argv[])
108
 
{
109
 
    Atom prog_atom;                 /* Our atom */
110
 
    Window root;                    /* root window */
111
 
    char *atomname;                 /* Our atom to watch for */
112
 
    XEvent ev;
113
 
    int rv;
114
 
    pthread_t ping_thread;
115
 
 
116
 
    if (argc != 2) {
117
 
        fprintf(stderr, "usage: %s scriptname\n", argv[0]);
118
 
        exit(1);
119
 
    }
120
 
 
121
 
    script = argv[1];
122
 
 
123
 
    d = getenv("DISPLAY");
124
 
 
125
 
    /*
126
 
     * Daemonize.
127
 
     */
128
 
 
129
 
    if (daemon(0, 0) < 0) {
130
 
        fprintf(stderr, "Couldn't background!\n");
131
 
        exit(1);
132
 
    }
133
 
 
134
 
    /*
135
 
     * Kick off our pinger thread.
136
 
     */
137
 
 
138
 
    if (pthread_create(&ping_thread, NULL, (void *) &ping_timeout,
139
 
                                           (void *) NULL) < 0) {
140
 
        exit(1);
141
 
    }
142
 
 
143
 
    pthread_detach(ping_thread);
144
 
 
145
 
    /*
146
 
     * Open our display
147
 
     */
148
 
 
149
 
    if (!(dpy = XOpenDisplay(d))) {
150
 
        exit(2);
151
 
    }
152
 
 
153
 
    /*
154
 
     * Atom to control the program.
155
 
     */
156
 
 
157
 
    atomname = "LTSP_XEXIT";
158
 
 
159
 
    XSetIOErrorHandler(handle_xerror);
160
 
 
161
 
    root = RootWindow(dpy, DefaultScreen(dpy));
162
 
 
163
 
    /*
164
 
     * We've got the root window now.  First, register our needed atom.
165
 
     */
166
 
 
167
 
    prog_atom = XInternAtom(dpy, atomname, False);
168
 
 
169
 
    if (prog_atom == None) {
170
 
        exit(3);
171
 
    }
172
 
 
173
 
    /*
174
 
     * Declare our interest in obtaining PropertyChange events.
175
 
     */
176
 
 
177
 
    XSelectInput(dpy, root, PropertyChangeMask);
178
 
 
179
 
    /*
180
 
     * Finally, sit in our event loop, and search for the property changes.
181
 
     */
182
 
 
183
 
    for (;;) {
184
 
        if (XPending(dpy)){
185
 
            XNextEvent(dpy, &ev);
186
 
            if (ev.type == PropertyNotify) {
187
 
                if (ev.xproperty.atom == prog_atom) {
188
 
                    rv = handle_propchange(dpy, root, prog_atom);
189
 
                    if (rv != 0) {
190
 
                        break;
191
 
                    }
192
 
                }
193
 
            }
194
 
        }
195
 
        else {
196
 
            usleep(10000);
197
 
        }
198
 
    }
199
 
 
200
 
    if (rv == XEXIT) {
201
 
        XCloseDisplay(dpy);
202
 
        dpy = NULL;
203
 
    }
204
 
 
205
 
    run_script();
 
54
ping_timeout (void *nothing)
 
55
{
 
56
  Display *pd;
 
57
 
 
58
  for (;;)
 
59
    {
 
60
      sleep (PING_INTERVAL);
 
61
      if (!(pd = XOpenDisplay (d)))
 
62
        {
 
63
          run_script ();
 
64
        }
 
65
      XCloseDisplay (pd);
 
66
    }
 
67
}
 
68
 
 
69
int
 
70
handle_propchange (Display * d, Window w, Atom a)
 
71
{
 
72
  char *result;
 
73
  Atom type;
 
74
  int format, res;
 
75
  unsigned long nitems, nleft;
 
76
  int return_val = 0;
 
77
 
 
78
 
 
79
  res = XGetWindowProperty (d, w, a, 0, 512, 0, XA_STRING,
 
80
                            &type, &format, &nitems, &nleft,
 
81
                            (unsigned char **) &result);
 
82
 
 
83
  if (res != Success)
 
84
    {
 
85
      if (type == XA_STRING)
 
86
        {
 
87
          if (*result == 'E' || *result == 'e')
 
88
            {                   /* EXIT */
 
89
              return_val = XEXIT;
 
90
            }
 
91
          else
 
92
            {
 
93
              return_val = XDIE;
 
94
            }
 
95
          XFree (result);
 
96
        }
 
97
    }
 
98
 
 
99
  return return_val;
 
100
}
 
101
 
 
102
int
 
103
main (int argc, char *argv[])
 
104
{
 
105
  Window root;                  /* root window */
 
106
  Atom prog_atom;               /* Our atom */
 
107
  XEvent ev;
 
108
  pthread_t ping_thread;
 
109
  char *atomname;               /* Our atom to watch for */
 
110
  int rv;
 
111
 
 
112
  if (argc != 2)
 
113
    {
 
114
      fprintf (stderr, "usage: %s scriptname\n", argv[0]);
 
115
      exit (1);
 
116
    }
 
117
 
 
118
  script = argv[1];
 
119
 
 
120
  d = getenv ("DISPLAY");
 
121
 
 
122
  /*
 
123
   * Daemonize.
 
124
   */
 
125
 
 
126
  if (daemon (0, 0) < 0)
 
127
    {
 
128
      fprintf (stderr, "Couldn't background!\n");
 
129
      exit (1);
 
130
    }
 
131
 
 
132
  /*
 
133
   * Kick off our pinger thread.
 
134
   */
 
135
 
 
136
  if (pthread_create (&ping_thread, NULL, (void *) &ping_timeout,
 
137
                      (void *) NULL) < 0)
 
138
    {
 
139
      exit (1);
 
140
    }
 
141
 
 
142
  pthread_detach (ping_thread);
 
143
 
 
144
  /*
 
145
   * Open our display
 
146
   */
 
147
 
 
148
  if (!(dpy = XOpenDisplay (d)))
 
149
    {
 
150
      exit (2);
 
151
    }
 
152
 
 
153
  /*
 
154
   * Atom to control the program.
 
155
   */
 
156
 
 
157
  atomname = "LTSP_XEXIT";
 
158
 
 
159
  XSetIOErrorHandler (handle_xerror);
 
160
 
 
161
  root = RootWindow (dpy, DefaultScreen (dpy));
 
162
 
 
163
  /*
 
164
   * We've got the root window now.  First, register our needed atom.
 
165
   */
 
166
 
 
167
  prog_atom = XInternAtom (dpy, atomname, False);
 
168
 
 
169
  if (prog_atom == None)
 
170
    {
 
171
      exit (3);
 
172
    }
 
173
 
 
174
  /*
 
175
   * Declare our interest in obtaining PropertyChange events.
 
176
   */
 
177
 
 
178
  XSelectInput (dpy, root, PropertyChangeMask);
 
179
 
 
180
  /*
 
181
   * Finally, sit in our event loop, and search for the property changes.
 
182
   */
 
183
 
 
184
  for (;;)
 
185
    {
 
186
      if (XPending (dpy))
 
187
        {
 
188
          XNextEvent (dpy, &ev);
 
189
          if (ev.type == PropertyNotify)
 
190
            {
 
191
              if (ev.xproperty.atom == prog_atom)
 
192
                {
 
193
                  rv = handle_propchange (dpy, root, prog_atom);
 
194
                  if (rv != 0)
 
195
                    {
 
196
                      break;
 
197
                    }
 
198
                }
 
199
            }
 
200
        }
 
201
      else
 
202
        {
 
203
          usleep (100000);
 
204
        }
 
205
    }
 
206
 
 
207
  if (rv == XEXIT)
 
208
    {
 
209
      XCloseDisplay (dpy);
 
210
      dpy = NULL;
 
211
    }
 
212
 
 
213
  run_script ();
206
214
}