Separated several classes into header files from tool main.cpp
[synfig.git] / synfig-osx / launcher / bundle-main.c
1 /* bundle-main.c -- X server launcher
2    $Id: bundle-main.c,v 1.17 2003/09/11 00:17:10 jharper Exp $
3
4    Copyright (c) 2002 Apple Computer, Inc. All rights reserved.
5
6    Permission is hereby granted, free of charge, to any person
7    obtaining a copy of this software and associated documentation files
8    (the "Software"), to deal in the Software without restriction,
9    including without limitation the rights to use, copy, modify, merge,
10    publish, distribute, sublicense, and/or sell copies of the Software,
11    and to permit persons to whom the Software is furnished to do so,
12    subject to the following conditions:
13
14    The above copyright notice and this permission notice shall be
15    included in all copies or substantial portions of the Software.
16
17    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20    NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT
21    HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24    DEALINGS IN THE SOFTWARE.
25
26    Except as contained in this notice, the name(s) of the above
27    copyright holders shall not be used in advertising or otherwise to
28    promote the sale, use or other dealings in this Software without
29    prior written authorization.
30
31    Parts of this file are derived from xdm, which has this copyright:
32
33    Copyright 1988, 1998  The Open Group
34
35    Permission to use, copy, modify, distribute, and sell this software
36    and its documentation for any purpose is hereby granted without fee,
37    provided that the above copyright notice appear in all copies and
38    that both that copyright notice and this permission notice appear in
39    supporting documentation.
40
41    The above copyright notice and this permission notice shall be
42    included in all copies or substantial portions of the Software.
43
44    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
45    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
46    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
47    NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY
48    CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
49    TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
50    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
51
52    Except as contained in this notice, the name of The Open Group shall
53    not be used in advertising or otherwise to promote the sale, use or
54    other dealings in this Software without prior written authorization
55    from The Open Group. */
56
57 #include <stdio.h>
58 #include <unistd.h>
59 #include <stdlib.h>
60 #include <fcntl.h>
61 #include <errno.h>
62 #include <sys/socket.h>
63 #include <sys/utsname.h>
64 #include <ifaddrs.h>
65 #include <netdb.h>
66 #include <netinet/in.h>
67 #include <time.h>
68 #include <sys/wait.h>
69 #include <setjmp.h>
70 #include <sys/ioctl.h>
71
72 #include <X11/Xlib.h>
73 #include <X11/Xauth.h>
74
75 #include <CoreFoundation/CoreFoundation.h>
76 #include <SystemConfiguration/SystemConfiguration.h>
77
78 #define X_SERVER "/usr/X11R6/bin/Xquartz"
79 #define XTERM_PATH "/usr/X11R6/bin/xterm"
80 #define WM_PATH "/usr/X11R6/bin/quartz-wm"
81 #define DEFAULT_XINITRC "/usr/X11R6/lib/X11/xinit/xinitrc"
82 #include <mach-o/dyld.h>
83
84 /* what xinit does */
85 #ifndef SHELL
86 # define SHELL "sh"
87 #endif
88
89 #undef FALSE
90 #define FALSE 0
91 #undef TRUE
92 #define TRUE 1
93
94 #define MAX_DISPLAYS 64
95
96 static int server_pid = -1, client_pid = -1;
97 static int xinit_kills_server = FALSE;
98 static jmp_buf exit_continuation;
99 static const char *server_name = NULL;
100 static Display *server_dpy;
101
102 static char *auth_file;
103
104 typedef struct addr_list_struct addr_list;
105
106 struct addr_list_struct {
107     addr_list *next;
108     Xauth auth;
109 };
110
111 static addr_list *addresses;
112
113 \f
114 /* Utility functions. */
115
116 /* Return the current host name. Matches what Xlib does. */
117 static char *
118 host_name (void)
119 {
120 #ifdef NEED_UTSNAME
121     static struct utsname name;
122
123     uname(&name);
124
125     return name.nodename;
126 #else
127     static char buf[100];
128
129     gethostname(buf, sizeof(buf));
130
131     return buf;
132 #endif
133 }
134
135 static int
136 read_boolean_pref (CFStringRef name, int default_)
137 {
138     int value;
139     Boolean ok;
140
141     value = CFPreferencesGetAppBooleanValue (name,
142                                              CFSTR ("com.apple.x11"), &ok);
143     return ok ? value : default_;
144 }
145
146 static inline int
147 binary_equal (const void *a, const void *b, int length)
148 {
149     return memcmp (a, b, length) == 0;
150 }
151
152 static inline void *
153 binary_dup (const void *a, int length)
154 {
155     void *b = malloc (length);
156     if (b != NULL)
157         memcpy (b, a, length);
158     return b;
159 }
160
161 static inline void
162 binary_free (void *data, int length)
163 {
164     if (data != NULL)
165         free (data);
166 }
167
168 \f
169 /* Functions for managing the authentication entries. */
170
171 /* Returns true if something matching AUTH is in our list of auth items */
172 static int
173 check_auth_item (Xauth *auth)
174 {
175     addr_list *a;
176
177     for (a = addresses; a != NULL; a = a->next)
178     {
179         if (a->auth.family == auth->family
180             && a->auth.address_length == auth->address_length
181             && binary_equal (a->auth.address, auth->address, auth->address_length)
182             && a->auth.number_length == auth->number_length
183             && binary_equal (a->auth.number, auth->number, auth->number_length)
184             && a->auth.name_length == auth->name_length
185             && binary_equal (a->auth.name, auth->name, auth->name_length))
186         {
187             return TRUE;
188         }
189     }
190
191     return FALSE;
192 }
193
194 /* Add one item to our list of auth items. */
195 static void
196 add_auth_item (Xauth *auth)
197 {
198     addr_list *a = malloc (sizeof (addr_list));
199
200     a->auth.family = auth->family;
201     a->auth.address_length = auth->address_length;
202     a->auth.address = binary_dup (auth->address, auth->address_length);
203     a->auth.number_length = auth->number_length;
204     a->auth.number = binary_dup (auth->number, auth->number_length);
205     a->auth.name_length = auth->name_length;
206     a->auth.name = binary_dup (auth->name, auth->name_length);
207     a->auth.data_length = auth->data_length;
208     a->auth.data = binary_dup (auth->data, auth->data_length);
209
210     a->next = addresses;
211     addresses = a;
212 }
213
214 /* Free all allocated auth items. */
215 static void
216 free_auth_items (void)
217 {
218     addr_list *a;
219
220     while ((a = addresses) != NULL)
221     {
222         addresses = a->next;
223
224         binary_free (a->auth.address, a->auth.address_length);
225         binary_free (a->auth.number, a->auth.number_length);
226         binary_free (a->auth.name, a->auth.name_length);
227         binary_free (a->auth.data, a->auth.data_length);
228         free (a);
229     }
230 }
231
232 /* Add the unix domain auth item. */
233 static void
234 define_local (Xauth *auth)
235 {
236     char *host = host_name ();
237
238 #ifdef DEBUG
239     fprintf (stderr, "x11: hostname is %s\n", host);
240 #endif
241
242     auth->family = FamilyLocal;
243     auth->address_length = strlen (host);
244     auth->address = host;
245
246     add_auth_item (auth);
247 }
248
249 /* Add the tcp auth item. */
250 static void
251 define_named (Xauth *auth, const char *name)
252 {
253     struct ifaddrs *addrs, *ptr;
254
255     if (getifaddrs (&addrs) != 0)
256         return;
257
258     for (ptr = addrs; ptr != NULL; ptr = ptr->ifa_next)
259     {
260         if (ptr->ifa_addr->sa_family != AF_INET)
261             continue;
262
263         auth->family = FamilyInternet;
264         auth->address_length = sizeof (struct sockaddr_in);
265         auth->address = (char *) &(((struct sockaddr_in *) ptr->ifa_addr)->sin_addr);
266
267 #ifdef DEBUG
268         fprintf (stderr, "x11: ipaddr is %d.%d.%d.%d\n",
269                  (unsigned char) auth->address[0],
270                  (unsigned char) auth->address[1],
271                  (unsigned char) auth->address[2],
272                  (unsigned char) auth->address[3]);
273 #endif
274
275         add_auth_item (auth);
276     }
277
278     freeifaddrs (addrs);
279 }
280
281 /* Parse the display number from NAME and add it to AUTH. */
282 static void
283 set_auth_number (Xauth *auth, const char *name)
284 {
285     char *colon;
286     char *dot, *number;
287
288     colon = strrchr(name, ':');
289     if (colon != NULL)
290     {
291         colon++;
292         dot = strchr(colon, '.');
293
294         if (dot != NULL)
295             auth->number_length = dot - colon;
296         else
297             auth->number_length = strlen (colon);
298
299         number = malloc (auth->number_length + 1);
300         if (number != NULL)
301         {
302             strncpy (number, colon, auth->number_length);
303             number[auth->number_length] = '\0';
304         }
305         else
306         {
307             auth->number_length = 0;
308         }
309
310         auth->number = number;
311     }
312 }
313
314 /* Put 128 bits of random data into DATA. If possible, it will be "high
315    quality" */
316 static int
317 generate_mit_magic_cookie (char data[16])
318 {
319     int fd, ret, i;
320     long *ldata = (long *) data;
321
322     fd = open ("/dev/random", O_RDONLY);
323     if (fd > 0)
324     {
325         ret = read (fd, data, 16);
326         if (ret == 16)
327             return TRUE;
328
329         close (fd);
330     }
331
332     /* fall back to the usual crappy rng */
333
334     srand48 (getpid () ^ time (NULL));
335
336     for (i = 0; i < 4; i++)
337         ldata[i] = lrand48 ();
338
339     return TRUE;
340 }
341
342 /* Create the keys we'll be using for the display named NAME. */
343 static int
344 make_auth_keys (const char *name)
345 {
346     Xauth auth;
347     char key[16];
348
349     if (auth_file == NULL)
350         return FALSE;
351
352     auth.name = "MIT-MAGIC-COOKIE-1";
353     auth.name_length = strlen (auth.name);
354
355     if (!generate_mit_magic_cookie (key))
356     {
357         auth_file = NULL;
358         return FALSE;
359     }
360
361     auth.data = key;
362     auth.data_length = 16;
363
364     set_auth_number (&auth, name);
365
366     define_named (&auth, host_name ());
367     define_local (&auth);
368
369     free (auth.number);
370
371     return TRUE;
372 }
373
374 /* If ADD-ENTRIES is true, merge our auth entries into the existing
375    Xauthority file. If ADD-ENTRIES is false, remove our entries. */
376 static int
377 write_auth_file (int add_entries)
378 {
379     char *home, newname[1024];
380     int fd, ret;
381     FILE *new_fh, *old_fh;
382     addr_list *addr;
383     Xauth *auth;
384
385     if (auth_file == NULL)
386         return FALSE;
387
388     home = getenv ("HOME");
389     if (home == NULL)
390     {
391         auth_file = NULL;
392         return FALSE;
393     }
394
395     snprintf (newname, sizeof (newname), "%s/.XauthorityXXXXXX", home);
396     mktemp (newname);
397
398     if (XauLockAuth (auth_file, 1, 2, 10) != LOCK_SUCCESS)
399     {
400         /* FIXME: do something here? */
401
402         auth_file = NULL;
403         return FALSE;
404     }
405
406     fd = open (newname, O_WRONLY | O_CREAT | O_TRUNC, 0600);
407     if (fd >= 0)
408     {
409         new_fh = fdopen (fd, "w");
410         if (new_fh != NULL)
411         {
412             if (add_entries)
413             {
414                 for (addr = addresses; addr != NULL; addr = addr->next)
415                 {
416                     XauWriteAuth (new_fh, &addr->auth);
417                 }
418             }
419
420             old_fh = fopen (auth_file, "r");
421             if (old_fh != NULL)
422             {
423                 while ((auth = XauReadAuth (old_fh)) != NULL)
424                 {
425                     if (!check_auth_item (auth))
426                         XauWriteAuth (new_fh, auth);
427                     XauDisposeAuth (auth);
428                 }
429                 fclose (old_fh);
430             }
431
432             fclose (new_fh);
433             unlink (auth_file);
434
435             ret = rename (newname, auth_file);
436
437             if (ret != 0)
438                 auth_file = NULL;
439
440             XauUnlockAuth (auth_file);
441             return ret == 0;
442         }
443
444         close (fd);
445     }
446
447     XauUnlockAuth (auth_file);
448     auth_file = NULL;
449     return FALSE;
450 }
451
452 \f
453 /* Subprocess management functions. */
454
455 static int
456 start_server (char **xargv)
457 {
458     int child;
459
460     child = fork ();
461
462     switch (child)
463     {
464     case -1:                            /* error */
465         perror ("fork");
466         return FALSE;
467
468     case 0:                             /* child */
469         execv (X_SERVER, xargv);
470         perror ("Couldn't exec " X_SERVER);
471         _exit (1);
472
473     default:                            /* parent */
474         server_pid = child;
475         return TRUE;
476     }
477 }
478
479 static int
480 wait_for_server (void)
481 {
482     int count = 100;
483
484     while (count-- > 0)
485     {
486         int status;
487
488         server_dpy = XOpenDisplay (server_name);
489         if (server_dpy != NULL)
490             return TRUE;
491
492         if (waitpid (server_pid, &status, WNOHANG) == server_pid)
493             return FALSE;
494
495         sleep (1);
496     }
497
498     return FALSE;
499 }
500
501 static int
502 start_client (void)
503 {
504     int child;
505
506     child = fork ();
507
508     switch (child)
509     {
510         char *tem, buf[1024];
511
512     case -1:                            /* error */
513         perror ("fork");
514         return FALSE;
515
516     case 0:                             /* child */
517         /* cd $HOME */
518         tem = getenv ("HOME");
519         if (tem != NULL)
520             chdir (tem);
521
522         /* Setup environment */
523
524         setenv ("DISPLAY", server_name, TRUE);
525         tem = getenv ("PATH");
526         if (tem != NULL && tem[0] != NULL)
527             snprintf (buf, sizeof (buf), "%s:/usr/X11R6/bin", tem);
528         else
529             snprintf (buf, sizeof (buf), "/bin:/usr/bin:/usr/X11R6/bin");
530         setenv ("PATH", buf, TRUE);
531
532 #if 1
533         setenv("GTK_USE_XFT","1",0);
534         system(WM_PATH " &");
535         execl("/usr/local/bin/synfigstudio","/usr/local/bin/synfigstudio",NULL);
536
537 #else
538         /* First look for .xinitrc in user's home directory. */
539
540         tem = getenv ("HOME");
541         if (tem != NULL)
542         {
543             snprintf (buf, sizeof (buf), "%s/.xinitrc", tem);
544             if (access (buf, R_OK) == 0)
545                 execlp (SHELL, SHELL, buf, NULL);
546         }
547
548         /* Then try the default xinitrc in the lib directory. */
549
550         if (access (DEFAULT_XINITRC, R_OK) == 0)
551             execlp (SHELL, SHELL, DEFAULT_XINITRC, NULL);
552
553         /* Then fallback to hardcoding an xterm and the window manager. */
554
555         system (XTERM_PATH " &");
556         execl (WM_PATH, WM_PATH, NULL);
557         
558 #endif
559         perror ("exec");
560         _exit (1);
561
562     default:                            /* parent */
563         client_pid = child;
564         return TRUE;
565     }
566 }
567
568 static void
569 sigchld_handler (int sig)
570 {
571     int pid, status;
572
573 again:
574     pid = waitpid (WAIT_ANY, &status, WNOHANG);
575
576     if (pid > 0)
577     {
578         if (pid == server_pid)
579         {
580             server_pid = -1;
581
582             if (client_pid >= 0)
583                 kill (client_pid, SIGTERM);
584         }
585         else if (pid == client_pid)
586         {
587             client_pid = -1;
588
589             if (server_pid >= 0 && xinit_kills_server)
590                 kill (server_pid, SIGTERM);
591         }
592         goto again;
593     }
594
595     if (server_pid == -1 && client_pid == -1)
596         longjmp (exit_continuation, 1);
597
598     signal (SIGCHLD, sigchld_handler);
599 }
600
601 \f
602 /* Server utilities. */
603
604 static Boolean
605 display_exists_p (int number)
606 {
607     char buf[64];
608     void *conn;
609     char *fullname = NULL;
610     int idisplay, iscreen;
611     char *conn_auth_name, *conn_auth_data;
612     int conn_auth_namelen, conn_auth_datalen;
613
614     extern void *_X11TransConnectDisplay ();
615     extern void _XDisconnectDisplay ();
616
617     /* Since connecting to the display waits for a few seconds if the
618        display doesn't exist, check for trivial non-existence - if the
619        socket in /tmp exists or not.. (note: if the socket exists, the
620        server may still not, so we need to try to connect in that case..) */
621
622     sprintf (buf, "/tmp/.X11-unix/X%d", number);
623     if (access (buf, F_OK) != 0)
624         return FALSE;
625
626     /* This is a private function that we shouldn't really be calling,
627        but it's the best way to see if the server exists (without
628        needing to hold the necessary authentication to use it) */
629
630     sprintf (buf, ":%d", number);
631     conn = _X11TransConnectDisplay (buf, &fullname, &idisplay, &iscreen,
632                                     &conn_auth_name, &conn_auth_namelen,
633                                     &conn_auth_data, &conn_auth_datalen);
634     if (conn == NULL)
635         return FALSE;
636
637     _XDisconnectDisplay (conn);
638     return TRUE;
639 }
640
641 \f
642 /* Monitoring when the system's ip addresses change. */
643
644 static Boolean pending_timer;
645
646 static void
647 timer_callback (CFRunLoopTimerRef timer, void *info)
648 {
649     pending_timer = FALSE;
650
651     /* Update authentication names. Need to write .Xauthority file first
652        without the existing entries, then again with the new entries.. */
653
654     write_auth_file (FALSE);
655
656     free_auth_items ();
657     make_auth_keys (server_name);
658
659     write_auth_file (TRUE);
660 }
661
662 /* This function is called when the system's ip addresses may have changed. */
663 static void
664 ipaddr_callback (SCDynamicStoreRef store, CFArrayRef changed_keys, void *info)
665 {
666     if (auth_file != NULL && !pending_timer)
667     {
668         CFRunLoopTimerRef timer;
669
670         timer = CFRunLoopTimerCreate (NULL, CFAbsoluteTimeGetCurrent () + 1.0,
671                                       0.0, 0, 0, timer_callback, NULL);
672         CFRunLoopAddTimer (CFRunLoopGetCurrent (), timer,
673                            kCFRunLoopDefaultMode);
674         CFRelease (timer);
675
676         pending_timer = TRUE;
677     }
678 }
679
680 /* This code adapted from "Living in a Dynamic TCP/IP Environment" technote. */
681 static Boolean
682 install_ipaddr_source (void)
683 {
684     CFRunLoopSourceRef source = NULL;
685
686     SCDynamicStoreContext context = {0};
687     SCDynamicStoreRef ref;
688
689     ref = SCDynamicStoreCreate (NULL,
690                                 CFSTR ("AddIPAddressListChangeCallbackSCF"),
691                                 ipaddr_callback, &context);
692
693     if (ref != NULL)
694     {
695         const void *keys[2];
696
697         /* This should tell us when any IPV4 address changes */
698         keys[0] = (SCDynamicStoreKeyCreateNetworkServiceEntity
699                    (NULL, kSCDynamicStoreDomainState,
700                     kSCCompAnyRegex, kSCEntNetIPv4));
701
702         /* This should tell us when the hostname(s) change */
703         keys[1] = SCDynamicStoreKeyCreateHostNames (NULL);
704
705         if (keys[0] != NULL && keys[1] != NULL)
706         {
707             CFArrayRef pattern_array;
708
709             pattern_array = CFArrayCreate (NULL, keys, 2,
710                                            &kCFTypeArrayCallBacks);
711
712             if (pattern_array != NULL)
713             {
714                 SCDynamicStoreSetNotificationKeys (ref, NULL, pattern_array);
715                 source = SCDynamicStoreCreateRunLoopSource (NULL, ref, 0);
716
717                 CFRelease (pattern_array);
718             }
719
720             if (keys[0] != NULL)
721                 CFRelease (keys[0]);
722             if (keys[1] != NULL)
723                 CFRelease (keys[1]);
724         }
725
726         CFRelease (ref); 
727    }
728
729     if (source != NULL)
730     {
731         CFRunLoopAddSource (CFRunLoopGetCurrent (),
732                             source, kCFRunLoopDefaultMode);
733         CFRelease (source);
734     }
735
736     return source != NULL;
737 }
738
739
740 \f
741 /* Entrypoint. */
742 int
743 main (int argc, char **argv)
744 {
745     char **xargv;
746     int i, j;
747     int fd;
748
749
750
751
752
753
754     xargv = alloca (sizeof (char *) * (argc + 32));
755
756     if (!read_boolean_pref (CFSTR ("no_auth"), FALSE))
757         auth_file = XauFileName ();
758
759     /* The standard X11 behaviour is for the server to quit when the first
760        client exits. But it can be useful for debugging (and to mimic our
761        behaviour in the beta releases) to not do that. */
762
763     xinit_kills_server = read_boolean_pref (CFSTR ("xinit_kills_server"), TRUE);
764
765     for (i = 1; i < argc; i++)
766     {
767         if (argv[i][0] == ':')
768             server_name = argv[i];
769     }
770
771     if (server_name == NULL)
772     {
773         static char name[8];
774
775         /* No display number specified, so search for the first unused.
776
777            There's a big old race condition here if two servers start at
778            the same time, but that's fairly unlikely. We could create
779            lockfiles or something, but that's seems more likely to cause
780            problems than the race condition itself.. */
781
782         for (i = 2; i < MAX_DISPLAYS; i++)
783         {
784             if (!display_exists_p (i))
785                 break;
786         }
787
788         if (i == MAX_DISPLAYS)
789         {
790             fprintf (stderr, "%s: couldn't allocate a display number", argv[0]);
791             exit (1);
792         }
793
794         sprintf (name, ":%d", i);
795         server_name = name;
796     }
797
798     if (auth_file != NULL)
799     {
800         /* Create new Xauth keys and add them to the .Xauthority file */
801
802         make_auth_keys (server_name);
803         write_auth_file (TRUE);
804     }
805
806     /* Construct our new argv */
807
808     i = j = 0;
809
810     xargv[i++] = argv[j++];
811
812     if (auth_file != NULL)
813     {
814         xargv[i++] = "-auth";
815         xargv[i++] = auth_file;
816     }
817
818     /* By default, don't listen on tcp sockets if Xauth is disabled. */
819
820     if (read_boolean_pref (CFSTR ("nolisten_tcp"), auth_file == NULL))
821     {
822         xargv[i++] = "-nolisten";
823         xargv[i++] = "tcp";
824     }
825
826     while (j < argc)
827     {
828         if (argv[j++][0] != ':')
829             xargv[i++] = argv[j-1];
830     }
831
832     xargv[i++] = (char *) server_name;
833     xargv[i++] = NULL;
834
835     /* Detach from any controlling terminal and connect stdin to /dev/null */
836
837 #ifdef TIOCNOTTY
838     fd = open ("/dev/tty", O_RDONLY);
839     if (fd != -1)
840     {
841         ioctl (fd, TIOCNOTTY, 0);
842         close (fd);
843     }
844 #endif
845
846     fd = open ("/dev/null", O_RDWR, 0);
847     if (fd >= 0)
848     {
849         dup2 (fd, 0);
850         if (fd > 0)
851             close (fd);
852     }
853
854     if (!start_server (xargv))
855         return 1;
856
857     if (!wait_for_server ())
858     {
859         kill (server_pid, SIGTERM);
860         return 1;
861     }
862
863     if (!start_client ())
864     {
865         kill (server_pid, SIGTERM);
866         return 1;
867     }
868
869     signal (SIGCHLD, sigchld_handler);
870
871         if (NSIsSymbolNameDefined("_ASKInitialize"))
872         {
873                 NSSymbol *symbol = NSLookupAndBindSymbol("_ASKInitialize");
874                 if (symbol)
875                 {
876                         void (*initializeASKFunc)(void) = NSAddressOfSymbol(symbol);
877                         if (initializeASKFunc)
878                         {
879                                 initializeASKFunc();
880                         }
881                         else
882                                 return 666;
883                 }
884                 else return 667;
885         }else
886         return 668;
887
888     if (setjmp (exit_continuation) == 0)
889     {
890         if (install_ipaddr_source ())
891             CFRunLoopRun ();
892         else
893             while (1) pause ();
894     }
895
896     signal (SIGCHLD, SIG_IGN);
897
898     if (auth_file != NULL)
899     {
900         /* Remove our Xauth keys */
901
902         write_auth_file (FALSE);
903     }
904
905     free_auth_items ();
906
907     return 0;
908 }