1 /*
2  * Copyright 1989 Network Computing Devices, Inc., Mountain View, California.
3  *
4  * Permission to use, copy, modify, and distribute this software and its
5  * documentation for any purpose and without fee is hereby granted, provided
6  * that the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation, and that the name of N.C.D. not be used in advertising or
9  * publicity pertaining to distribution of the software without specific,
10  * written prior permission.  N.C.D. makes no representations about the
11  * suitability of this software for any purpose.  It is provided "as is"
12  * without express or implied warranty.
13  *
14  */
15 
16 #ifdef HAVE_DIX_CONFIG_H
17 #include <dix-config.h>
18 #endif
19 
20 #ifdef WIN32
21 #include <X11/Xwinsock.h>
22 #define XSERV_t
23 #define TRANS_SERVER
24 #define TRANS_REOPEN
25 #include <X11/Xtrans/Xtrans.h>
26 #endif
27 
28 #include <X11/Xos.h>
29 
30 #if !defined(WIN32)
31 #include <sys/param.h>
32 #include <sys/socket.h>
33 #include <netinet/in.h>
34 #include <netdb.h>
35 #endif
36 
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <X11/X.h>
40 #include <X11/Xmd.h>
41 #include "misc.h"
42 #include "osdep.h"
43 #include "input.h"
44 #include "dixstruct.h"
45 #include "opaque.h"
46 
47 #define XSERV_t
48 #define TRANS_SERVER
49 #define TRANS_REOPEN
50 #include <X11/Xtrans/Xtrans.h>
51 
52 #ifdef XDMCP
53 #undef REQUEST
54 
55 #ifdef XDMCP_NO_IPV6
56 #undef IPv6
57 #endif
58 
59 #include <X11/Xdmcp.h>
60 
61 #define X_INCLUDE_NETDB_H
62 #include <X11/Xos_r.h>
63 
64 static const char *defaultDisplayClass = "MIT-unspecified";
65 
66 static int xdmcpSocket, sessionSocket;
67 static xdmcp_states state;
68 
69 #if defined(IPv6) && defined(AF_INET6)
70 static int xdmcpSocket6;
71 static struct sockaddr_storage req_sockaddr;
72 #else
73 static struct sockaddr_in req_sockaddr;
74 #endif
75 static int req_socklen;
76 static CARD32 SessionID;
77 static int timeOutRtx;
78 static CARD16 DisplayNumber;
79 static xdmcp_states XDM_INIT_STATE = XDM_OFF;
80 static OsTimerPtr xdmcp_timer;
81 
82 #ifdef HASXDMAUTH
83 static char *xdmAuthCookie;
84 #endif
85 
86 static XdmcpBuffer buffer;
87 
88 #if defined(IPv6) && defined(AF_INET6)
89 
90 static struct addrinfo *mgrAddr;
91 static struct addrinfo *mgrAddrFirst;
92 
93 #define SOCKADDR_TYPE		struct sockaddr_storage
94 #define SOCKADDR_FAMILY(s)	((struct sockaddr *)&(s))->sa_family
95 
96 #ifdef BSD44SOCKETS
97 #define SOCKLEN_FIELD(s)	((struct sockaddr *)&(s))->sa_len
98 #define SOCKLEN_TYPE 		unsigned char
99 #else
100 #define SOCKLEN_TYPE 		unsigned int
101 #endif
102 
103 #else
104 
105 #define SOCKADDR_TYPE		struct sockaddr_in
106 #define SOCKADDR_FAMILY(s)	(s).sin_family
107 
108 #ifdef BSD44SOCKETS
109 #define SOCKLEN_FIELD(s)	(s).sin_len
110 #define SOCKLEN_TYPE		unsigned char
111 #else
112 #define SOCKLEN_TYPE		size_t
113 #endif
114 
115 #endif
116 
117 static SOCKADDR_TYPE ManagerAddress;
118 static SOCKADDR_TYPE FromAddress;
119 
120 #ifdef SOCKLEN_FIELD
121 #define ManagerAddressLen	SOCKLEN_FIELD(ManagerAddress)
122 #define FromAddressLen		SOCKLEN_FIELD(FromAddress)
123 #else
124 static SOCKLEN_TYPE ManagerAddressLen, FromAddressLen;
125 #endif
126 
127 #if defined(IPv6) && defined(AF_INET6)
128 static struct multicastinfo {
129     struct multicastinfo *next;
130     struct addrinfo *ai;
131     int hops;
132 } *mcastlist;
133 #endif
134 
135 static void XdmcpAddHost(const struct sockaddr *from,
136                          int fromlen,
137                          ARRAY8Ptr AuthenticationName,
138                          ARRAY8Ptr hostname, ARRAY8Ptr status);
139 
140 static void XdmcpSelectHost(const struct sockaddr *host_sockaddr,
141                             int host_len, ARRAY8Ptr AuthenticationName);
142 
143 static void get_xdmcp_sock(void);
144 
145 static void send_query_msg(void);
146 
147 static void recv_willing_msg(struct sockaddr    *from,
148                              int                fromlen,
149                              unsigned           length);
150 
151 static void send_request_msg(void);
152 
153 static void recv_accept_msg(unsigned    length);
154 
155 static void recv_decline_msg(unsigned   length);
156 
157 static void send_manage_msg(void);
158 
159 static void recv_refuse_msg(unsigned    length);
160 
161 static void recv_failed_msg(unsigned    length);
162 
163 static void send_keepalive_msg(void);
164 
165 static void recv_alive_msg(unsigned     length );
166 
167 static void XdmcpFatal(const char       *type,
168                        ARRAY8Ptr        status);
169 
170 static void XdmcpWarning(const char     *str);
171 
172 static void get_manager_by_name(int     argc,
173                                 char    **argv,
174                                 int     i);
175 
176 static void get_fromaddr_by_name(int    argc,
177                                  char   **argv,
178                                  int    i);
179 
180 #if defined(IPv6) && defined(AF_INET6)
181 static int get_mcast_options(int        argc,
182                              char       **argv,
183                              int        i);
184 #endif
185 
186 static void receive_packet(int socketfd);
187 
188 static void send_packet(void);
189 
190 static void timeout(void);
191 
192 static void XdmcpSocketNotify(int fd, int ready, void *data);
193 
194 static CARD32 XdmcpTimerNotify(OsTimerPtr timer, CARD32 time, void *arg);
195 
196 /*
197  * Register the Manufacturer display ID
198  */
199 
200 static ARRAY8 ManufacturerDisplayID;
201 
202 static void
XdmcpRegisterManufacturerDisplayID(const char * name,int length)203 XdmcpRegisterManufacturerDisplayID(const char *name, int length)
204 {
205     int i;
206 
207     XdmcpDisposeARRAY8(&ManufacturerDisplayID);
208     if (!XdmcpAllocARRAY8(&ManufacturerDisplayID, length))
209         return;
210     for (i = 0; i < length; i++)
211         ManufacturerDisplayID.data[i] = (CARD8) name[i];
212 }
213 
214 static unsigned short xdm_udp_port = XDM_UDP_PORT;
215 static Bool OneSession = FALSE;
216 static const char *xdm_from = NULL;
217 
218 void
XdmcpUseMsg(void)219 XdmcpUseMsg(void)
220 {
221     ErrorF("-query host-name       contact named host for XDMCP\n");
222     ErrorF("-broadcast             broadcast for XDMCP\n");
223 #if defined(IPv6) && defined(AF_INET6)
224     ErrorF("-multicast [addr [hops]] IPv6 multicast for XDMCP\n");
225 #endif
226     ErrorF("-indirect host-name    contact named host for indirect XDMCP\n");
227     ErrorF("-port port-num         UDP port number to send messages to\n");
228     ErrorF
229         ("-from local-address    specify the local address to connect from\n");
230     ErrorF("-once                  Terminate server after one session\n");
231     ErrorF("-class display-class   specify display class to send in manage\n");
232 #ifdef HASXDMAUTH
233     ErrorF("-cookie xdm-auth-bits  specify the magic cookie for XDMCP\n");
234 #endif
235     ErrorF("-displayID display-id  manufacturer display ID for request\n");
236 }
237 
238 static void
XdmcpDefaultListen(void)239 XdmcpDefaultListen(void)
240 {
241     /* Even when configured --disable-listen-tcp, we should listen on tcp in
242        XDMCP modes */
243     _XSERVTransListen("tcp");
244 }
245 
246 int
XdmcpOptions(int argc,char ** argv,int i)247 XdmcpOptions(int argc, char **argv, int i)
248 {
249     if (strcmp(argv[i], "-query") == 0) {
250         get_manager_by_name(argc, argv, i++);
251         XDM_INIT_STATE = XDM_QUERY;
252         AccessUsingXdmcp();
253         XdmcpDefaultListen();
254         return i + 1;
255     }
256     if (strcmp(argv[i], "-broadcast") == 0) {
257         XDM_INIT_STATE = XDM_BROADCAST;
258         AccessUsingXdmcp();
259         XdmcpDefaultListen();
260         return i + 1;
261     }
262 #if defined(IPv6) && defined(AF_INET6)
263     if (strcmp(argv[i], "-multicast") == 0) {
264         i = get_mcast_options(argc, argv, ++i);
265         XDM_INIT_STATE = XDM_MULTICAST;
266         AccessUsingXdmcp();
267         XdmcpDefaultListen();
268         return i + 1;
269     }
270 #endif
271     if (strcmp(argv[i], "-indirect") == 0) {
272         get_manager_by_name(argc, argv, i++);
273         XDM_INIT_STATE = XDM_INDIRECT;
274         AccessUsingXdmcp();
275         XdmcpDefaultListen();
276         return i + 1;
277     }
278     if (strcmp(argv[i], "-port") == 0) {
279         if (++i == argc) {
280             FatalError("Xserver: missing port number in command line\n");
281         }
282         xdm_udp_port = (unsigned short) atoi(argv[i]);
283         return i + 1;
284     }
285     if (strcmp(argv[i], "-from") == 0) {
286         get_fromaddr_by_name(argc, argv, ++i);
287         return i + 1;
288     }
289     if (strcmp(argv[i], "-once") == 0) {
290         OneSession = TRUE;
291         return i + 1;
292     }
293     if (strcmp(argv[i], "-class") == 0) {
294         if (++i == argc) {
295             FatalError("Xserver: missing class name in command line\n");
296         }
297         defaultDisplayClass = argv[i];
298         return i + 1;
299     }
300 #ifdef HASXDMAUTH
301     if (strcmp(argv[i], "-cookie") == 0) {
302         if (++i == argc) {
303             FatalError("Xserver: missing cookie data in command line\n");
304         }
305         xdmAuthCookie = argv[i];
306         return i + 1;
307     }
308 #endif
309     if (strcmp(argv[i], "-displayID") == 0) {
310         if (++i == argc) {
311             FatalError("Xserver: missing displayID in command line\n");
312         }
313         XdmcpRegisterManufacturerDisplayID(argv[i], strlen(argv[i]));
314         return i + 1;
315     }
316     return i;
317 }
318 
319 /*
320  * This section is a collection of routines for
321  * registering server-specific data with the XDMCP
322  * state machine.
323  */
324 
325 /*
326  * Save all broadcast addresses away so BroadcastQuery
327  * packets get sent everywhere
328  */
329 
330 #define MAX_BROADCAST	10
331 
332 /* This stays sockaddr_in since IPv6 doesn't support broadcast */
333 static struct sockaddr_in BroadcastAddresses[MAX_BROADCAST];
334 static int NumBroadcastAddresses;
335 
336 void
XdmcpRegisterBroadcastAddress(const struct sockaddr_in * addr)337 XdmcpRegisterBroadcastAddress(const struct sockaddr_in *addr)
338 {
339     struct sockaddr_in *bcast;
340 
341     if (NumBroadcastAddresses >= MAX_BROADCAST)
342         return;
343     bcast = &BroadcastAddresses[NumBroadcastAddresses++];
344     memset(bcast, 0, sizeof(struct sockaddr_in));
345 #ifdef BSD44SOCKETS
346     bcast->sin_len = addr->sin_len;
347 #endif
348     bcast->sin_family = addr->sin_family;
349     bcast->sin_port = htons(xdm_udp_port);
350     bcast->sin_addr = addr->sin_addr;
351 }
352 
353 /*
354  * Each authentication type is registered here; Validator
355  * will be called to check all access attempts using
356  * the specified authentication type
357  */
358 
359 static ARRAYofARRAY8 AuthenticationNames, AuthenticationDatas;
360 typedef struct _AuthenticationFuncs {
361     ValidatorFunc Validator;
362     GeneratorFunc Generator;
363     AddAuthorFunc AddAuth;
364 } AuthenticationFuncsRec, *AuthenticationFuncsPtr;
365 
366 static AuthenticationFuncsPtr AuthenticationFuncsList;
367 
368 void
XdmcpRegisterAuthentication(const char * name,int namelen,const char * data,int datalen,ValidatorFunc Validator,GeneratorFunc Generator,AddAuthorFunc AddAuth)369 XdmcpRegisterAuthentication(const char *name,
370                             int namelen,
371                             const char *data,
372                             int datalen,
373                             ValidatorFunc Validator,
374                             GeneratorFunc Generator, AddAuthorFunc AddAuth)
375 {
376     int i;
377     ARRAY8 AuthenticationName, AuthenticationData;
378     static AuthenticationFuncsPtr newFuncs;
379 
380     if (!XdmcpAllocARRAY8(&AuthenticationName, namelen))
381         return;
382     if (!XdmcpAllocARRAY8(&AuthenticationData, datalen)) {
383         XdmcpDisposeARRAY8(&AuthenticationName);
384         return;
385     }
386     for (i = 0; i < namelen; i++)
387         AuthenticationName.data[i] = name[i];
388     for (i = 0; i < datalen; i++)
389         AuthenticationData.data[i] = data[i];
390     if (!(XdmcpReallocARRAYofARRAY8(&AuthenticationNames,
391                                     AuthenticationNames.length + 1) &&
392           XdmcpReallocARRAYofARRAY8(&AuthenticationDatas,
393                                     AuthenticationDatas.length + 1) &&
394           (newFuncs =
395            malloc((AuthenticationNames.length +
396                    1) * sizeof(AuthenticationFuncsRec))))) {
397         XdmcpDisposeARRAY8(&AuthenticationName);
398         XdmcpDisposeARRAY8(&AuthenticationData);
399         return;
400     }
401     for (i = 0; i < AuthenticationNames.length - 1; i++)
402         newFuncs[i] = AuthenticationFuncsList[i];
403     newFuncs[AuthenticationNames.length - 1].Validator = Validator;
404     newFuncs[AuthenticationNames.length - 1].Generator = Generator;
405     newFuncs[AuthenticationNames.length - 1].AddAuth = AddAuth;
406     free(AuthenticationFuncsList);
407     AuthenticationFuncsList = newFuncs;
408     AuthenticationNames.data[AuthenticationNames.length - 1] =
409         AuthenticationName;
410     AuthenticationDatas.data[AuthenticationDatas.length - 1] =
411         AuthenticationData;
412 }
413 
414 /*
415  * Select the authentication type to be used; this is
416  * set by the manager of the host to be connected to.
417  */
418 
419 static ARRAY8 noAuthenticationName = { (CARD16) 0, (CARD8Ptr) 0 };
420 static ARRAY8 noAuthenticationData = { (CARD16) 0, (CARD8Ptr) 0 };
421 
422 static ARRAY8Ptr AuthenticationName = &noAuthenticationName;
423 static ARRAY8Ptr AuthenticationData = &noAuthenticationData;
424 static AuthenticationFuncsPtr AuthenticationFuncs;
425 
426 static void
XdmcpSetAuthentication(const ARRAY8Ptr name)427 XdmcpSetAuthentication(const ARRAY8Ptr name)
428 {
429     int i;
430 
431     for (i = 0; i < AuthenticationNames.length; i++)
432         if (XdmcpARRAY8Equal(&AuthenticationNames.data[i], name)) {
433             AuthenticationName = &AuthenticationNames.data[i];
434             AuthenticationData = &AuthenticationDatas.data[i];
435             AuthenticationFuncs = &AuthenticationFuncsList[i];
436             break;
437         }
438 }
439 
440 /*
441  * Register the host address for the display
442  */
443 
444 static ARRAY16 ConnectionTypes;
445 static ARRAYofARRAY8 ConnectionAddresses;
446 static long xdmcpGeneration;
447 
448 void
XdmcpRegisterConnection(int type,const char * address,int addrlen)449 XdmcpRegisterConnection(int type, const char *address, int addrlen)
450 {
451     int i;
452     CARD8 *newAddress;
453 
454     if (xdmcpGeneration != serverGeneration) {
455         XdmcpDisposeARRAY16(&ConnectionTypes);
456         XdmcpDisposeARRAYofARRAY8(&ConnectionAddresses);
457         xdmcpGeneration = serverGeneration;
458     }
459     if (xdm_from != NULL) {     /* Only register the requested address */
460         const void *regAddr = address;
461         const void *fromAddr = NULL;
462         int regAddrlen = addrlen;
463 
464         if (addrlen == sizeof(struct in_addr)) {
465             if (SOCKADDR_FAMILY(FromAddress) == AF_INET) {
466                 fromAddr = &((struct sockaddr_in *) &FromAddress)->sin_addr;
467             }
468 #if defined(IPv6) && defined(AF_INET6)
469             else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET6) &&
470                      IN6_IS_ADDR_V4MAPPED(&
471                                           ((struct sockaddr_in6 *)
472                                            &FromAddress)->sin6_addr)) {
473                 fromAddr =
474                     &((struct sockaddr_in6 *) &FromAddress)->sin6_addr.
475                     s6_addr[12];
476             }
477 #endif
478         }
479 #if defined(IPv6) && defined(AF_INET6)
480         else if (addrlen == sizeof(struct in6_addr)) {
481             if (SOCKADDR_FAMILY(FromAddress) == AF_INET6) {
482                 fromAddr = &((struct sockaddr_in6 *) &FromAddress)->sin6_addr;
483             }
484             else if ((SOCKADDR_FAMILY(FromAddress) == AF_INET) &&
485                      IN6_IS_ADDR_V4MAPPED((const struct in6_addr *) address)) {
486                 fromAddr = &((struct sockaddr_in *) &FromAddress)->sin_addr;
487                 regAddr =
488                     &((struct sockaddr_in6 *) address)->sin6_addr.s6_addr[12];
489                 regAddrlen = sizeof(struct in_addr);
490             }
491         }
492 #endif
493         if (!fromAddr || memcmp(regAddr, fromAddr, regAddrlen) != 0) {
494             return;
495         }
496     }
497     if (ConnectionAddresses.length + 1 == 256)
498         return;
499     newAddress = malloc(addrlen * sizeof(CARD8));
500     if (!newAddress)
501         return;
502     if (!XdmcpReallocARRAY16(&ConnectionTypes, ConnectionTypes.length + 1)) {
503         free(newAddress);
504         return;
505     }
506     if (!XdmcpReallocARRAYofARRAY8(&ConnectionAddresses,
507                                    ConnectionAddresses.length + 1)) {
508         free(newAddress);
509         return;
510     }
511     ConnectionTypes.data[ConnectionTypes.length - 1] = (CARD16) type;
512     for (i = 0; i < addrlen; i++)
513         newAddress[i] = address[i];
514     ConnectionAddresses.data[ConnectionAddresses.length - 1].data = newAddress;
515     ConnectionAddresses.data[ConnectionAddresses.length - 1].length = addrlen;
516 }
517 
518 /*
519  * Register an Authorization Name.  XDMCP advertises this list
520  * to the manager.
521  */
522 
523 static ARRAYofARRAY8 AuthorizationNames;
524 
525 void
XdmcpRegisterAuthorizations(void)526 XdmcpRegisterAuthorizations(void)
527 {
528     XdmcpDisposeARRAYofARRAY8(&AuthorizationNames);
529     RegisterAuthorizations();
530 }
531 
532 void
XdmcpRegisterAuthorization(const char * name,int namelen)533 XdmcpRegisterAuthorization(const char *name, int namelen)
534 {
535     ARRAY8 authName;
536     int i;
537 
538     authName.data = malloc(namelen * sizeof(CARD8));
539     if (!authName.data)
540         return;
541     if (!XdmcpReallocARRAYofARRAY8
542         (&AuthorizationNames, AuthorizationNames.length + 1)) {
543         free(authName.data);
544         return;
545     }
546     for (i = 0; i < namelen; i++)
547         authName.data[i] = (CARD8) name[i];
548     authName.length = namelen;
549     AuthorizationNames.data[AuthorizationNames.length - 1] = authName;
550 }
551 
552 /*
553  * Register the DisplayClass string
554  */
555 
556 static ARRAY8 DisplayClass;
557 
558 static void
XdmcpRegisterDisplayClass(const char * name,int length)559 XdmcpRegisterDisplayClass(const char *name, int length)
560 {
561     int i;
562 
563     XdmcpDisposeARRAY8(&DisplayClass);
564     if (!XdmcpAllocARRAY8(&DisplayClass, length))
565         return;
566     for (i = 0; i < length; i++)
567         DisplayClass.data[i] = (CARD8) name[i];
568 }
569 
570 static void
xdmcp_reset(void)571 xdmcp_reset(void)
572 {
573     timeOutRtx = 0;
574     if (xdmcpSocket >= 0)
575         SetNotifyFd(xdmcpSocket, XdmcpSocketNotify, X_NOTIFY_READ, NULL);
576 #if defined(IPv6) && defined(AF_INET6)
577     if (xdmcpSocket6 >= 0)
578         SetNotifyFd(xdmcpSocket6, XdmcpSocketNotify, X_NOTIFY_READ, NULL);
579 #endif
580     xdmcp_timer = TimerSet(NULL, 0, 0, XdmcpTimerNotify, NULL);
581     send_packet();
582 }
583 
584 static void
xdmcp_start(void)585 xdmcp_start(void)
586 {
587     get_xdmcp_sock();
588     xdmcp_reset();
589 }
590 
591 /*
592  * initialize XDMCP; create the socket, compute the display
593  * number, set up the state machine
594  */
595 
596 void
XdmcpInit(void)597 XdmcpInit(void)
598 {
599     state = XDM_INIT_STATE;
600 #ifdef HASXDMAUTH
601     if (xdmAuthCookie)
602         XdmAuthenticationInit(xdmAuthCookie, strlen(xdmAuthCookie));
603 #endif
604     if (state != XDM_OFF) {
605         XdmcpRegisterAuthorizations();
606         XdmcpRegisterDisplayClass(defaultDisplayClass,
607                                   strlen(defaultDisplayClass));
608         AccessUsingXdmcp();
609         DisplayNumber = (CARD16) atoi(display);
610         xdmcp_start();
611     }
612 }
613 
614 void
XdmcpReset(void)615 XdmcpReset(void)
616 {
617     state = XDM_INIT_STATE;
618     if (state != XDM_OFF)
619         xdmcp_reset();
620 }
621 
622 /*
623  * Called whenever a new connection is created; notices the
624  * first connection and saves it to terminate the session
625  * when it is closed
626  */
627 
628 void
XdmcpOpenDisplay(int sock)629 XdmcpOpenDisplay(int sock)
630 {
631     if (state != XDM_AWAIT_MANAGE_RESPONSE)
632         return;
633     state = XDM_RUN_SESSION;
634     TimerSet(xdmcp_timer, 0, XDM_DEF_DORMANCY * 1000, XdmcpTimerNotify, NULL);
635     sessionSocket = sock;
636 }
637 
638 void
XdmcpCloseDisplay(int sock)639 XdmcpCloseDisplay(int sock)
640 {
641     if ((state != XDM_RUN_SESSION && state != XDM_AWAIT_ALIVE_RESPONSE)
642         || sessionSocket != sock)
643         return;
644     state = XDM_INIT_STATE;
645     if (OneSession)
646         dispatchException |= DE_TERMINATE;
647     else
648         dispatchException |= DE_RESET;
649     isItTimeToYield = TRUE;
650 }
651 
652 static void
XdmcpSocketNotify(int fd,int ready,void * data)653 XdmcpSocketNotify(int fd, int ready, void *data)
654 {
655     if (state == XDM_OFF)
656         return;
657     receive_packet(fd);
658 }
659 
660 static CARD32
XdmcpTimerNotify(OsTimerPtr timer,CARD32 time,void * arg)661 XdmcpTimerNotify(OsTimerPtr timer, CARD32 time, void *arg)
662 {
663     if (state == XDM_RUN_SESSION) {
664         state = XDM_KEEPALIVE;
665         send_packet();
666     }
667     else
668         timeout();
669     return 0;
670 }
671 
672 /*
673  * This routine should be called from the routine that drives the
674  * user's host menu when the user selects a host
675  */
676 
677 static void
XdmcpSelectHost(const struct sockaddr * host_sockaddr,int host_len,ARRAY8Ptr auth_name)678 XdmcpSelectHost(const struct sockaddr *host_sockaddr,
679                 int host_len, ARRAY8Ptr auth_name)
680 {
681     state = XDM_START_CONNECTION;
682     memmove(&req_sockaddr, host_sockaddr, host_len);
683     req_socklen = host_len;
684     XdmcpSetAuthentication(auth_name);
685     send_packet();
686 }
687 
688 /*
689  * !!! this routine should be replaced by a routine that adds
690  * the host to the user's host menu. the current version just
691  * selects the first host to respond with willing message.
692  */
693 
694  /*ARGSUSED*/ static void
XdmcpAddHost(const struct sockaddr * from,int fromlen,ARRAY8Ptr auth_name,ARRAY8Ptr hostname,ARRAY8Ptr status)695 XdmcpAddHost(const struct sockaddr *from,
696              int fromlen,
697              ARRAY8Ptr auth_name, ARRAY8Ptr hostname, ARRAY8Ptr status)
698 {
699     XdmcpSelectHost(from, fromlen, auth_name);
700 }
701 
702 /*
703  * A message is queued on the socket; read it and
704  * do the appropriate thing
705  */
706 
707 static ARRAY8 UnwillingMessage = { (CARD8) 14, (CARD8 *) "Host unwilling" };
708 
709 static void
receive_packet(int socketfd)710 receive_packet(int socketfd)
711 {
712 #if defined(IPv6) && defined(AF_INET6)
713     struct sockaddr_storage from;
714 #else
715     struct sockaddr_in from;
716 #endif
717     int fromlen = sizeof(from);
718     XdmcpHeader header;
719 
720     /* read message off socket */
721     if (!XdmcpFill(socketfd, &buffer, (XdmcpNetaddr) &from, &fromlen))
722         return;
723 
724     /* reset retransmission backoff */
725     timeOutRtx = 0;
726 
727     if (!XdmcpReadHeader(&buffer, &header))
728         return;
729 
730     if (header.version != XDM_PROTOCOL_VERSION)
731         return;
732 
733     switch (header.opcode) {
734     case WILLING:
735         recv_willing_msg((struct sockaddr *) &from, fromlen, header.length);
736         break;
737     case UNWILLING:
738         XdmcpFatal("Manager unwilling", &UnwillingMessage);
739         break;
740     case ACCEPT:
741         recv_accept_msg(header.length);
742         break;
743     case DECLINE:
744         recv_decline_msg(header.length);
745         break;
746     case REFUSE:
747         recv_refuse_msg(header.length);
748         break;
749     case FAILED:
750         recv_failed_msg(header.length);
751         break;
752     case ALIVE:
753         recv_alive_msg(header.length);
754         break;
755     }
756 }
757 
758 /*
759  * send the appropriate message given the current state
760  */
761 
762 static void
send_packet(void)763 send_packet(void)
764 {
765     int rtx;
766 
767     switch (state) {
768     case XDM_QUERY:
769     case XDM_BROADCAST:
770     case XDM_INDIRECT:
771 #if defined(IPv6)  && defined(AF_INET6)
772     case XDM_MULTICAST:
773 #endif
774         send_query_msg();
775         break;
776     case XDM_START_CONNECTION:
777         send_request_msg();
778         break;
779     case XDM_MANAGE:
780         send_manage_msg();
781         break;
782     case XDM_KEEPALIVE:
783         send_keepalive_msg();
784         break;
785     default:
786         break;
787     }
788     rtx = (XDM_MIN_RTX << timeOutRtx);
789     if (rtx > XDM_MAX_RTX)
790         rtx = XDM_MAX_RTX;
791     TimerSet(xdmcp_timer, 0, rtx * 1000, XdmcpTimerNotify, NULL);
792 }
793 
794 /*
795  * The session is declared dead for some reason; too many
796  * timeouts, or Keepalive failure.
797  */
798 
799 static void
XdmcpDeadSession(const char * reason)800 XdmcpDeadSession(const char *reason)
801 {
802     ErrorF("XDM: %s, declaring session dead\n", reason);
803     state = XDM_INIT_STATE;
804     isItTimeToYield = TRUE;
805     dispatchException |= (OneSession ? DE_TERMINATE : DE_RESET);
806     TimerCancel(xdmcp_timer);
807     timeOutRtx = 0;
808     send_packet();
809 }
810 
811 /*
812  * Timeout waiting for an XDMCP response.
813  */
814 
815 static void
timeout(void)816 timeout(void)
817 {
818     timeOutRtx++;
819     if (state == XDM_AWAIT_ALIVE_RESPONSE && timeOutRtx >= XDM_KA_RTX_LIMIT) {
820         XdmcpDeadSession("too many keepalive retransmissions");
821         return;
822     }
823     else if (timeOutRtx >= XDM_RTX_LIMIT) {
824         /* Quit if "-once" specified, otherwise reset and try again. */
825         if (OneSession) {
826             dispatchException |= DE_TERMINATE;
827             ErrorF("XDM: too many retransmissions\n");
828         }
829         else {
830             XdmcpDeadSession("too many retransmissions");
831         }
832         return;
833     }
834 
835 #if defined(IPv6) && defined(AF_INET6)
836     if (state == XDM_COLLECT_QUERY || state == XDM_COLLECT_INDIRECT_QUERY) {
837         /* Try next address */
838         for (mgrAddr = mgrAddr->ai_next;; mgrAddr = mgrAddr->ai_next) {
839             if (mgrAddr == NULL) {
840                 mgrAddr = mgrAddrFirst;
841             }
842             if (mgrAddr->ai_family == AF_INET || mgrAddr->ai_family == AF_INET6)
843                 break;
844         }
845 #ifndef SIN6_LEN
846         ManagerAddressLen = mgrAddr->ai_addrlen;
847 #endif
848         memcpy(&ManagerAddress, mgrAddr->ai_addr, mgrAddr->ai_addrlen);
849     }
850 #endif
851 
852     switch (state) {
853     case XDM_COLLECT_QUERY:
854         state = XDM_QUERY;
855         break;
856     case XDM_COLLECT_BROADCAST_QUERY:
857         state = XDM_BROADCAST;
858         break;
859 #if defined(IPv6) && defined(AF_INET6)
860     case XDM_COLLECT_MULTICAST_QUERY:
861         state = XDM_MULTICAST;
862         break;
863 #endif
864     case XDM_COLLECT_INDIRECT_QUERY:
865         state = XDM_INDIRECT;
866         break;
867     case XDM_AWAIT_REQUEST_RESPONSE:
868         state = XDM_START_CONNECTION;
869         break;
870     case XDM_AWAIT_MANAGE_RESPONSE:
871         state = XDM_MANAGE;
872         break;
873     case XDM_AWAIT_ALIVE_RESPONSE:
874         state = XDM_KEEPALIVE;
875         break;
876     default:
877         break;
878     }
879     send_packet();
880 }
881 
882 static int
XdmcpCheckAuthentication(ARRAY8Ptr Name,ARRAY8Ptr Data,int packet_type)883 XdmcpCheckAuthentication(ARRAY8Ptr Name, ARRAY8Ptr Data, int packet_type)
884 {
885     return (XdmcpARRAY8Equal(Name, AuthenticationName) &&
886             (AuthenticationName->length == 0 ||
887              (*AuthenticationFuncs->Validator) (AuthenticationData, Data,
888                                                 packet_type)));
889 }
890 
891 static int
XdmcpAddAuthorization(ARRAY8Ptr name,ARRAY8Ptr data)892 XdmcpAddAuthorization(ARRAY8Ptr name, ARRAY8Ptr data)
893 {
894     AddAuthorFunc AddAuth;
895 
896     if (AuthenticationFuncs && AuthenticationFuncs->AddAuth)
897         AddAuth = AuthenticationFuncs->AddAuth;
898     else
899         AddAuth = AddAuthorization;
900     return (*AddAuth) ((unsigned short) name->length,
901                        (char *) name->data,
902                        (unsigned short) data->length, (char *) data->data);
903 }
904 
905 /*
906  * from here to the end of this file are routines private
907  * to the state machine.
908  */
909 
910 static void
get_xdmcp_sock(void)911 get_xdmcp_sock(void)
912 {
913     int soopts = 1;
914     int socketfd = -1;
915 
916 #if defined(IPv6) && defined(AF_INET6)
917     if ((xdmcpSocket6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
918         XdmcpWarning("INET6 UDP socket creation failed");
919 #endif
920     if ((xdmcpSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
921         XdmcpWarning("UDP socket creation failed");
922 #ifdef SO_BROADCAST
923     else if (setsockopt(xdmcpSocket, SOL_SOCKET, SO_BROADCAST, (char *) &soopts,
924                         sizeof(soopts)) < 0)
925         XdmcpWarning("UDP set broadcast socket-option failed");
926 #endif                          /* SO_BROADCAST */
927 
928     if (xdm_from == NULL)
929         return;
930 
931     if (SOCKADDR_FAMILY(FromAddress) == AF_INET)
932         socketfd = xdmcpSocket;
933 #if defined(IPv6) && defined(AF_INET6)
934     else if (SOCKADDR_FAMILY(FromAddress) == AF_INET6)
935         socketfd = xdmcpSocket6;
936 #endif
937     if (socketfd >= 0) {
938         if (bind(socketfd, (struct sockaddr *) &FromAddress,
939                  FromAddressLen) < 0) {
940             FatalError("Xserver: failed to bind to -from address: %s\n",
941                        xdm_from);
942         }
943     }
944 }
945 
946 static void
send_query_msg(void)947 send_query_msg(void)
948 {
949     XdmcpHeader header;
950     Bool broadcast = FALSE;
951 
952 #if defined(IPv6) && defined(AF_INET6)
953     Bool multicast = FALSE;
954 #endif
955     int i;
956     int socketfd = xdmcpSocket;
957 
958     header.version = XDM_PROTOCOL_VERSION;
959     switch (state) {
960     case XDM_QUERY:
961         header.opcode = (CARD16) QUERY;
962         state = XDM_COLLECT_QUERY;
963         break;
964     case XDM_BROADCAST:
965         header.opcode = (CARD16) BROADCAST_QUERY;
966         state = XDM_COLLECT_BROADCAST_QUERY;
967         broadcast = TRUE;
968         break;
969 #if defined(IPv6) && defined(AF_INET6)
970     case XDM_MULTICAST:
971         header.opcode = (CARD16) BROADCAST_QUERY;
972         state = XDM_COLLECT_MULTICAST_QUERY;
973         multicast = TRUE;
974         break;
975 #endif
976     case XDM_INDIRECT:
977         header.opcode = (CARD16) INDIRECT_QUERY;
978         state = XDM_COLLECT_INDIRECT_QUERY;
979         break;
980     default:
981         break;
982     }
983     header.length = 1;
984     for (i = 0; i < AuthenticationNames.length; i++)
985         header.length += 2 + AuthenticationNames.data[i].length;
986 
987     XdmcpWriteHeader(&buffer, &header);
988     XdmcpWriteARRAYofARRAY8(&buffer, &AuthenticationNames);
989     if (broadcast) {
990         for (i = 0; i < NumBroadcastAddresses; i++)
991             XdmcpFlush(xdmcpSocket, &buffer,
992                        (XdmcpNetaddr) &BroadcastAddresses[i],
993                        sizeof(struct sockaddr_in));
994     }
995 #if defined(IPv6) && defined(AF_INET6)
996     else if (multicast) {
997         struct multicastinfo *mcl;
998         struct addrinfo *ai;
999 
1000         for (mcl = mcastlist; mcl != NULL; mcl = mcl->next) {
1001             for (ai = mcl->ai; ai != NULL; ai = ai->ai_next) {
1002                 if (ai->ai_family == AF_INET) {
1003                     unsigned char hopflag = (unsigned char) mcl->hops;
1004 
1005                     socketfd = xdmcpSocket;
1006                     setsockopt(socketfd, IPPROTO_IP, IP_MULTICAST_TTL,
1007                                &hopflag, sizeof(hopflag));
1008                 }
1009                 else if (ai->ai_family == AF_INET6) {
1010                     int hopflag6 = mcl->hops;
1011 
1012                     socketfd = xdmcpSocket6;
1013                     setsockopt(socketfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
1014                                &hopflag6, sizeof(hopflag6));
1015                 }
1016                 else {
1017                     continue;
1018                 }
1019                 XdmcpFlush(socketfd, &buffer,
1020                            (XdmcpNetaddr) ai->ai_addr, ai->ai_addrlen);
1021                 break;
1022             }
1023         }
1024     }
1025 #endif
1026     else {
1027 #if defined(IPv6) && defined(AF_INET6)
1028         if (SOCKADDR_FAMILY(ManagerAddress) == AF_INET6)
1029             socketfd = xdmcpSocket6;
1030 #endif
1031         XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &ManagerAddress,
1032                    ManagerAddressLen);
1033     }
1034 }
1035 
1036 static void
recv_willing_msg(struct sockaddr * from,int fromlen,unsigned length)1037 recv_willing_msg(struct sockaddr *from, int fromlen, unsigned length)
1038 {
1039     ARRAY8 authenticationName;
1040     ARRAY8 hostname;
1041     ARRAY8 status;
1042 
1043     authenticationName.data = 0;
1044     hostname.data = 0;
1045     status.data = 0;
1046     if (XdmcpReadARRAY8(&buffer, &authenticationName) &&
1047         XdmcpReadARRAY8(&buffer, &hostname) &&
1048         XdmcpReadARRAY8(&buffer, &status)) {
1049         if (length == 6 + authenticationName.length +
1050             hostname.length + status.length) {
1051             switch (state) {
1052             case XDM_COLLECT_QUERY:
1053                 XdmcpSelectHost(from, fromlen, &authenticationName);
1054                 break;
1055             case XDM_COLLECT_BROADCAST_QUERY:
1056 #if defined(IPv6) && defined(AF_INET6)
1057             case XDM_COLLECT_MULTICAST_QUERY:
1058 #endif
1059             case XDM_COLLECT_INDIRECT_QUERY:
1060                 XdmcpAddHost(from, fromlen, &authenticationName, &hostname,
1061                              &status);
1062                 break;
1063             default:
1064                 break;
1065             }
1066         }
1067     }
1068     XdmcpDisposeARRAY8(&authenticationName);
1069     XdmcpDisposeARRAY8(&hostname);
1070     XdmcpDisposeARRAY8(&status);
1071 }
1072 
1073 static void
send_request_msg(void)1074 send_request_msg(void)
1075 {
1076     XdmcpHeader header;
1077     int length;
1078     int i;
1079     CARD16 XdmcpConnectionType;
1080     ARRAY8 authenticationData;
1081     int socketfd = xdmcpSocket;
1082 
1083     switch (SOCKADDR_FAMILY(ManagerAddress)) {
1084     case AF_INET:
1085         XdmcpConnectionType = FamilyInternet;
1086         break;
1087 #if defined(IPv6) && defined(AF_INET6)
1088     case AF_INET6:
1089         XdmcpConnectionType = FamilyInternet6;
1090         break;
1091 #endif
1092     default:
1093         XdmcpConnectionType = 0xffff;
1094         break;
1095     }
1096 
1097     header.version = XDM_PROTOCOL_VERSION;
1098     header.opcode = (CARD16) REQUEST;
1099 
1100     length = 2;                 /* display number */
1101     length += 1 + 2 * ConnectionTypes.length;   /* connection types */
1102     length += 1;                /* connection addresses */
1103     for (i = 0; i < ConnectionAddresses.length; i++)
1104         length += 2 + ConnectionAddresses.data[i].length;
1105     authenticationData.length = 0;
1106     authenticationData.data = 0;
1107     if (AuthenticationFuncs) {
1108         (*AuthenticationFuncs->Generator) (AuthenticationData,
1109                                            &authenticationData, REQUEST);
1110     }
1111     length += 2 + AuthenticationName->length;   /* authentication name */
1112     length += 2 + authenticationData.length;    /* authentication data */
1113     length += 1;                /* authorization names */
1114     for (i = 0; i < AuthorizationNames.length; i++)
1115         length += 2 + AuthorizationNames.data[i].length;
1116     length += 2 + ManufacturerDisplayID.length; /* display ID */
1117     header.length = length;
1118 
1119     if (!XdmcpWriteHeader(&buffer, &header)) {
1120         XdmcpDisposeARRAY8(&authenticationData);
1121         return;
1122     }
1123     XdmcpWriteCARD16(&buffer, DisplayNumber);
1124     XdmcpWriteCARD8(&buffer, ConnectionTypes.length);
1125 
1126     /* The connection array is send reordered, so that connections of   */
1127     /* the same address type as the XDMCP manager connection are send   */
1128     /* first. This works around a bug in xdm. mario@klebsch.de          */
1129     for (i = 0; i < (int) ConnectionTypes.length; i++)
1130         if (ConnectionTypes.data[i] == XdmcpConnectionType)
1131             XdmcpWriteCARD16(&buffer, ConnectionTypes.data[i]);
1132     for (i = 0; i < (int) ConnectionTypes.length; i++)
1133         if (ConnectionTypes.data[i] != XdmcpConnectionType)
1134             XdmcpWriteCARD16(&buffer, ConnectionTypes.data[i]);
1135 
1136     XdmcpWriteCARD8(&buffer, ConnectionAddresses.length);
1137     for (i = 0; i < (int) ConnectionAddresses.length; i++)
1138         if ((i < ConnectionTypes.length) &&
1139             (ConnectionTypes.data[i] == XdmcpConnectionType))
1140             XdmcpWriteARRAY8(&buffer, &ConnectionAddresses.data[i]);
1141     for (i = 0; i < (int) ConnectionAddresses.length; i++)
1142         if ((i >= ConnectionTypes.length) ||
1143             (ConnectionTypes.data[i] != XdmcpConnectionType))
1144             XdmcpWriteARRAY8(&buffer, &ConnectionAddresses.data[i]);
1145 
1146     XdmcpWriteARRAY8(&buffer, AuthenticationName);
1147     XdmcpWriteARRAY8(&buffer, &authenticationData);
1148     XdmcpDisposeARRAY8(&authenticationData);
1149     XdmcpWriteARRAYofARRAY8(&buffer, &AuthorizationNames);
1150     XdmcpWriteARRAY8(&buffer, &ManufacturerDisplayID);
1151 #if defined(IPv6) && defined(AF_INET6)
1152     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
1153         socketfd = xdmcpSocket6;
1154 #endif
1155     if (XdmcpFlush(socketfd, &buffer,
1156                    (XdmcpNetaddr) &req_sockaddr, req_socklen))
1157         state = XDM_AWAIT_REQUEST_RESPONSE;
1158 }
1159 
1160 static void
recv_accept_msg(unsigned length)1161 recv_accept_msg(unsigned length)
1162 {
1163     CARD32 AcceptSessionID;
1164     ARRAY8 AcceptAuthenticationName, AcceptAuthenticationData;
1165     ARRAY8 AcceptAuthorizationName, AcceptAuthorizationData;
1166 
1167     if (state != XDM_AWAIT_REQUEST_RESPONSE)
1168         return;
1169     AcceptAuthenticationName.data = 0;
1170     AcceptAuthenticationData.data = 0;
1171     AcceptAuthorizationName.data = 0;
1172     AcceptAuthorizationData.data = 0;
1173     if (XdmcpReadCARD32(&buffer, &AcceptSessionID) &&
1174         XdmcpReadARRAY8(&buffer, &AcceptAuthenticationName) &&
1175         XdmcpReadARRAY8(&buffer, &AcceptAuthenticationData) &&
1176         XdmcpReadARRAY8(&buffer, &AcceptAuthorizationName) &&
1177         XdmcpReadARRAY8(&buffer, &AcceptAuthorizationData)) {
1178         if (length == 12 + AcceptAuthenticationName.length +
1179             AcceptAuthenticationData.length +
1180             AcceptAuthorizationName.length + AcceptAuthorizationData.length) {
1181             if (!XdmcpCheckAuthentication(&AcceptAuthenticationName,
1182                                           &AcceptAuthenticationData, ACCEPT)) {
1183                 XdmcpFatal("Authentication Failure", &AcceptAuthenticationName);
1184             }
1185             /* permit access control manipulations from this host */
1186             AugmentSelf(&req_sockaddr, req_socklen);
1187             /* if the authorization specified in the packet fails
1188              * to be acceptable, enable the local addresses
1189              */
1190             if (!XdmcpAddAuthorization(&AcceptAuthorizationName,
1191                                        &AcceptAuthorizationData)) {
1192                 AddLocalHosts();
1193             }
1194             SessionID = AcceptSessionID;
1195             state = XDM_MANAGE;
1196             send_packet();
1197         }
1198     }
1199     XdmcpDisposeARRAY8(&AcceptAuthenticationName);
1200     XdmcpDisposeARRAY8(&AcceptAuthenticationData);
1201     XdmcpDisposeARRAY8(&AcceptAuthorizationName);
1202     XdmcpDisposeARRAY8(&AcceptAuthorizationData);
1203 }
1204 
1205 static void
recv_decline_msg(unsigned length)1206 recv_decline_msg(unsigned length)
1207 {
1208     ARRAY8 status, DeclineAuthenticationName, DeclineAuthenticationData;
1209 
1210     status.data = 0;
1211     DeclineAuthenticationName.data = 0;
1212     DeclineAuthenticationData.data = 0;
1213     if (XdmcpReadARRAY8(&buffer, &status) &&
1214         XdmcpReadARRAY8(&buffer, &DeclineAuthenticationName) &&
1215         XdmcpReadARRAY8(&buffer, &DeclineAuthenticationData)) {
1216         if (length == 6 + status.length +
1217             DeclineAuthenticationName.length +
1218             DeclineAuthenticationData.length &&
1219             XdmcpCheckAuthentication(&DeclineAuthenticationName,
1220                                      &DeclineAuthenticationData, DECLINE)) {
1221             XdmcpFatal("Session declined", &status);
1222         }
1223     }
1224     XdmcpDisposeARRAY8(&status);
1225     XdmcpDisposeARRAY8(&DeclineAuthenticationName);
1226     XdmcpDisposeARRAY8(&DeclineAuthenticationData);
1227 }
1228 
1229 static void
send_manage_msg(void)1230 send_manage_msg(void)
1231 {
1232     XdmcpHeader header;
1233     int socketfd = xdmcpSocket;
1234 
1235     header.version = XDM_PROTOCOL_VERSION;
1236     header.opcode = (CARD16) MANAGE;
1237     header.length = 8 + DisplayClass.length;
1238 
1239     if (!XdmcpWriteHeader(&buffer, &header))
1240         return;
1241     XdmcpWriteCARD32(&buffer, SessionID);
1242     XdmcpWriteCARD16(&buffer, DisplayNumber);
1243     XdmcpWriteARRAY8(&buffer, &DisplayClass);
1244     state = XDM_AWAIT_MANAGE_RESPONSE;
1245 #if defined(IPv6) && defined(AF_INET6)
1246     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
1247         socketfd = xdmcpSocket6;
1248 #endif
1249     XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
1250 }
1251 
1252 static void
recv_refuse_msg(unsigned length)1253 recv_refuse_msg(unsigned length)
1254 {
1255     CARD32 RefusedSessionID;
1256 
1257     if (state != XDM_AWAIT_MANAGE_RESPONSE)
1258         return;
1259     if (length != 4)
1260         return;
1261     if (XdmcpReadCARD32(&buffer, &RefusedSessionID)) {
1262         if (RefusedSessionID == SessionID) {
1263             state = XDM_START_CONNECTION;
1264             send_packet();
1265         }
1266     }
1267 }
1268 
1269 static void
recv_failed_msg(unsigned length)1270 recv_failed_msg(unsigned length)
1271 {
1272     CARD32 FailedSessionID;
1273     ARRAY8 status;
1274 
1275     if (state != XDM_AWAIT_MANAGE_RESPONSE)
1276         return;
1277     status.data = 0;
1278     if (XdmcpReadCARD32(&buffer, &FailedSessionID) &&
1279         XdmcpReadARRAY8(&buffer, &status)) {
1280         if (length == 6 + status.length && SessionID == FailedSessionID) {
1281             XdmcpFatal("Session failed", &status);
1282         }
1283     }
1284     XdmcpDisposeARRAY8(&status);
1285 }
1286 
1287 static void
send_keepalive_msg(void)1288 send_keepalive_msg(void)
1289 {
1290     XdmcpHeader header;
1291     int socketfd = xdmcpSocket;
1292 
1293     header.version = XDM_PROTOCOL_VERSION;
1294     header.opcode = (CARD16) KEEPALIVE;
1295     header.length = 6;
1296 
1297     XdmcpWriteHeader(&buffer, &header);
1298     XdmcpWriteCARD16(&buffer, DisplayNumber);
1299     XdmcpWriteCARD32(&buffer, SessionID);
1300 
1301     state = XDM_AWAIT_ALIVE_RESPONSE;
1302 #if defined(IPv6) && defined(AF_INET6)
1303     if (SOCKADDR_FAMILY(req_sockaddr) == AF_INET6)
1304         socketfd = xdmcpSocket6;
1305 #endif
1306     XdmcpFlush(socketfd, &buffer, (XdmcpNetaddr) &req_sockaddr, req_socklen);
1307 }
1308 
1309 static void
recv_alive_msg(unsigned length)1310 recv_alive_msg(unsigned length)
1311 {
1312     CARD8 SessionRunning;
1313     CARD32 AliveSessionID;
1314 
1315     if (state != XDM_AWAIT_ALIVE_RESPONSE)
1316         return;
1317     if (length != 5)
1318         return;
1319     if (XdmcpReadCARD8(&buffer, &SessionRunning) &&
1320         XdmcpReadCARD32(&buffer, &AliveSessionID)) {
1321         if (SessionRunning && AliveSessionID == SessionID) {
1322             state = XDM_RUN_SESSION;
1323             TimerSet(xdmcp_timer, 0, XDM_DEF_DORMANCY * 1000, XdmcpTimerNotify, NULL);
1324         }
1325         else {
1326             XdmcpDeadSession("Alive response indicates session dead");
1327         }
1328     }
1329 }
1330 
1331 _X_NORETURN
1332 static void
XdmcpFatal(const char * type,ARRAY8Ptr status)1333 XdmcpFatal(const char *type, ARRAY8Ptr status)
1334 {
1335     FatalError("XDMCP fatal error: %s %*.*s\n", type,
1336                status->length, status->length, status->data);
1337 }
1338 
1339 static void
XdmcpWarning(const char * str)1340 XdmcpWarning(const char *str)
1341 {
1342     ErrorF("XDMCP warning: %s\n", str);
1343 }
1344 
1345 static void
get_addr_by_name(const char * argtype,const char * namestr,int port,int socktype,SOCKADDR_TYPE * addr,SOCKLEN_TYPE * addrlen,struct addrinfo ** aip,struct addrinfo ** aifirstp)1346 get_addr_by_name(const char *argtype,
1347                  const char *namestr,
1348                  int port,
1349                  int socktype, SOCKADDR_TYPE * addr, SOCKLEN_TYPE * addrlen
1350 #if defined(IPv6) && defined(AF_INET6)
1351                  , struct addrinfo **aip, struct addrinfo **aifirstp
1352 #endif
1353     )
1354 {
1355 #if defined(IPv6) && defined(AF_INET6)
1356     struct addrinfo *ai;
1357     struct addrinfo hints;
1358     char portstr[6];
1359     char *pport = portstr;
1360     int gaierr;
1361 
1362     memset(&hints, 0, sizeof(hints));
1363     hints.ai_socktype = socktype;
1364 
1365     if (port == 0) {
1366         pport = NULL;
1367     }
1368     else if (port > 0 && port < 65535) {
1369         snprintf(portstr, sizeof(portstr), "%d", port);
1370     }
1371     else {
1372         FatalError("Xserver: port out of range: %d\n", port);
1373     }
1374 
1375     if (*aifirstp != NULL) {
1376         freeaddrinfo(*aifirstp);
1377         *aifirstp = NULL;
1378     }
1379 
1380     if ((gaierr = getaddrinfo(namestr, pport, &hints, aifirstp)) == 0) {
1381         for (ai = *aifirstp; ai != NULL; ai = ai->ai_next) {
1382             if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6)
1383                 break;
1384         }
1385         if ((ai == NULL) || (ai->ai_addrlen > sizeof(SOCKADDR_TYPE))) {
1386             FatalError("Xserver: %s host %s not on supported network type\n",
1387                        argtype, namestr);
1388         }
1389         else {
1390             *aip = ai;
1391             *addrlen = ai->ai_addrlen;
1392             memcpy(addr, ai->ai_addr, ai->ai_addrlen);
1393         }
1394     }
1395     else {
1396         FatalError("Xserver: %s: %s %s\n", gai_strerror(gaierr), argtype,
1397                    namestr);
1398     }
1399 #else
1400     struct hostent *hep;
1401 
1402 #ifdef XTHREADS_NEEDS_BYNAMEPARAMS
1403     _Xgethostbynameparams hparams;
1404 #endif
1405 #if defined(WIN32) && defined(TCPCONN)
1406     _XSERVTransWSAStartup();
1407 #endif
1408     if (!(hep = _XGethostbyname(namestr, hparams))) {
1409         FatalError("Xserver: %s unknown host: %s\n", argtype, namestr);
1410     }
1411     if (hep->h_length == sizeof(struct in_addr)) {
1412         memmove(&addr->sin_addr, hep->h_addr, hep->h_length);
1413         *addrlen = sizeof(struct sockaddr_in);
1414         addr->sin_family = AF_INET;
1415         addr->sin_port = htons(port);
1416     }
1417     else {
1418         FatalError("Xserver: %s host on strange network %s\n", argtype,
1419                    namestr);
1420     }
1421 #endif
1422 }
1423 
1424 static void
get_manager_by_name(int argc,char ** argv,int i)1425 get_manager_by_name(int argc, char **argv, int i)
1426 {
1427 
1428     if ((i + 1) == argc) {
1429         FatalError("Xserver: missing %s host name in command line\n", argv[i]);
1430     }
1431 
1432     get_addr_by_name(argv[i], argv[i + 1], xdm_udp_port, SOCK_DGRAM,
1433                      &ManagerAddress, &ManagerAddressLen
1434 #if defined(IPv6) && defined(AF_INET6)
1435                      , &mgrAddr, &mgrAddrFirst
1436 #endif
1437         );
1438 }
1439 
1440 static void
get_fromaddr_by_name(int argc,char ** argv,int i)1441 get_fromaddr_by_name(int argc, char **argv, int i)
1442 {
1443 #if defined(IPv6) && defined(AF_INET6)
1444     struct addrinfo *ai = NULL;
1445     struct addrinfo *aifirst = NULL;
1446 #endif
1447     if (i == argc) {
1448         FatalError("Xserver: missing -from host name in command line\n");
1449     }
1450     get_addr_by_name("-from", argv[i], 0, 0, &FromAddress, &FromAddressLen
1451 #if defined(IPv6) && defined(AF_INET6)
1452                      , &ai, &aifirst
1453 #endif
1454         );
1455 #if defined(IPv6) && defined(AF_INET6)
1456     if (aifirst != NULL)
1457         freeaddrinfo(aifirst);
1458 #endif
1459     xdm_from = argv[i];
1460 }
1461 
1462 #if defined(IPv6) && defined(AF_INET6)
1463 static int
get_mcast_options(int argc,char ** argv,int i)1464 get_mcast_options(int argc, char **argv, int i)
1465 {
1466     const char *address = XDM_DEFAULT_MCAST_ADDR6;
1467     int hopcount = 1;
1468     struct addrinfo hints;
1469     char portstr[6];
1470     int gaierr;
1471     struct addrinfo *ai, *firstai;
1472 
1473     if ((i < argc) && (argv[i][0] != '-') && (argv[i][0] != '+')) {
1474         address = argv[i++];
1475         if ((i < argc) && (argv[i][0] != '-') && (argv[i][0] != '+')) {
1476             hopcount = strtol(argv[i++], NULL, 10);
1477             if ((hopcount < 1) || (hopcount > 255)) {
1478                 FatalError("Xserver: multicast hop count out of range: %d\n",
1479                            hopcount);
1480             }
1481         }
1482     }
1483 
1484     if (xdm_udp_port > 0 && xdm_udp_port < 65535) {
1485         snprintf(portstr, sizeof(portstr), "%d", xdm_udp_port);
1486     }
1487     else {
1488         FatalError("Xserver: port out of range: %d\n", xdm_udp_port);
1489     }
1490     memset(&hints, 0, sizeof(hints));
1491     hints.ai_socktype = SOCK_DGRAM;
1492 
1493     if ((gaierr = getaddrinfo(address, portstr, &hints, &firstai)) == 0) {
1494         for (ai = firstai; ai != NULL; ai = ai->ai_next) {
1495             if (((ai->ai_family == AF_INET) &&
1496                  IN_MULTICAST(((struct sockaddr_in *) ai->ai_addr)
1497                               ->sin_addr.s_addr))
1498                 || ((ai->ai_family == AF_INET6) &&
1499                     IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *) ai->ai_addr)
1500                                           ->sin6_addr)))
1501                 break;
1502         }
1503         if (ai == NULL) {
1504             FatalError("Xserver: address not supported multicast type %s\n",
1505                        address);
1506         }
1507         else {
1508             struct multicastinfo *mcastinfo, *mcl;
1509 
1510             mcastinfo = malloc(sizeof(struct multicastinfo));
1511             mcastinfo->next = NULL;
1512             mcastinfo->ai = firstai;
1513             mcastinfo->hops = hopcount;
1514 
1515             if (mcastlist == NULL) {
1516                 mcastlist = mcastinfo;
1517             }
1518             else {
1519                 for (mcl = mcastlist; mcl->next != NULL; mcl = mcl->next) {
1520                     /* Do nothing  - just find end of list */
1521                 }
1522                 mcl->next = mcastinfo;
1523             }
1524         }
1525     }
1526     else {
1527         FatalError("Xserver: %s: %s\n", gai_strerror(gaierr), address);
1528     }
1529     return i;
1530 }
1531 #endif
1532 
1533 #else
1534 static int xdmcp_non_empty;     /* avoid complaint by ranlib */
1535 #endif                          /* XDMCP */
1536