xdmcp.c

远程桌面连接工具

#else /* MINIX */
    char *udp_device;
    int r, s_errno;
    nwio_udpopt_t udpopt;
    nbio_ref_t ref;

    udp_device= getenv("UDP_DEVICE");
    if (udp_device == NULL)
    	udp_device= UDP_DEVICE;
    xdmcpSocket= open(udp_device, O_RDWR);
    if (xdmcpSocket != -1)
    {
    	udpopt.nwuo_flags= NWUO_COPY | NWUO_LP_SEL | NWUO_EN_LOC | 
    		NWUO_DI_BROAD | NWUO_RP_ANY | NWUO_RA_ANY | NWUO_RWDATALL |
    		NWUO_DI_IPOPT;
    	r= ioctl(xdmcpSocket, NWIOSUDPOPT, &udpopt);
    	if (r == -1)
    	{
    		s_errno= errno;
    		close(xdmcpSocket);
    		xdmcpSocket= -1;
    		errno= s_errno;
    	}
    	ioctl(xdmcpSocket, NWIOGUDPOPT, &udpopt);
    	ErrorF("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", 
    		udpopt.nwuo_flags,
    		udpopt.nwuo_locport,
    		udpopt.nwuo_remport,
    		udpopt.nwuo_locaddr,
    		udpopt.nwuo_remaddr);
    }
    if (xdmcpSocket != -1)
    {
	fcntl(xdmcpSocket, F_SETFD, fcntl(xdmcpSocket, F_GETFD) | 
    								FD_ASYNCHIO);
	nbio_register(xdmcpSocket);
	ref.ref_int= xdmcpSocket;
	nbio_setcallback(xdmcpSocket, ASIO_READ, read_cb, ref);
    }
    if (xdmcpSocket == -1)
#endif /* !MINIX */
	XdmcpWarning("UDP socket creation failed");
#ifdef SO_BROADCAST
    else if (setsockopt(xdmcpSocket, SOL_SOCKET, SO_BROADCAST, (char *)&soopts,
	sizeof(soopts)) < 0)
	    XdmcpWarning("UDP set broadcast socket-option failed");
#endif /* SO_BROADCAST */
#endif /* STREAMSCONN */
}

static void
send_query_msg()
{
    XdmcpHeader	header;
    Bool	broadcast = FALSE;
    int		i;

    header.version = XDM_PROTOCOL_VERSION;
    switch(state){
    case XDM_QUERY:
	header.opcode = (CARD16) QUERY; 
	state = XDM_COLLECT_QUERY;
	break;
    case XDM_BROADCAST:
	header.opcode = (CARD16) BROADCAST_QUERY;
	state = XDM_COLLECT_BROADCAST_QUERY;
	broadcast = TRUE;
	break;
    case XDM_INDIRECT:
	header.opcode = (CARD16) INDIRECT_QUERY;
	state = XDM_COLLECT_INDIRECT_QUERY;
	break;
    }
    header.length = 1;
    for (i = 0; i < AuthenticationNames.length; i++)
	header.length += 2 + AuthenticationNames.data[i].length;

    XdmcpWriteHeader (&buffer, &header);
    XdmcpWriteARRAYofARRAY8 (&buffer, &AuthenticationNames);
    if (broadcast)
    {
	int i;

	for (i = 0; i < NumBroadcastAddresses; i++)
	    XdmcpFlush (xdmcpSocket, &buffer, &BroadcastAddresses[i],
			sizeof (struct sockaddr_in));
    }
    else
    {
	XdmcpFlush (xdmcpSocket, &buffer, &ManagerAddress,
		    sizeof (ManagerAddress));
    }
}

static void
recv_willing_msg(from, fromlen, length)
    struct sockaddr_in	*from;
    int			fromlen;
    unsigned		length;
{
    ARRAY8	authenticationName;
    ARRAY8	hostname;
    ARRAY8	status;

    authenticationName.data = 0;
    hostname.data = 0;
    status.data = 0;
    if (XdmcpReadARRAY8 (&buffer, &authenticationName) &&
	XdmcpReadARRAY8 (&buffer, &hostname) &&
	XdmcpReadARRAY8 (&buffer, &status))
    {
    	if (length == 6 + authenticationName.length +
		      hostname.length + status.length)
    	{
	    switch (state)
	    {
	    case XDM_COLLECT_QUERY:
	    	XdmcpSelectHost(from, fromlen, &authenticationName);
	    	break;
	    case XDM_COLLECT_BROADCAST_QUERY:
	    case XDM_COLLECT_INDIRECT_QUERY:
	    	XdmcpAddHost(from, fromlen, &authenticationName, &hostname, &status);
	    	break;
    	    }
    	}
    }
    XdmcpDisposeARRAY8 (&authenticationName);
    XdmcpDisposeARRAY8 (&hostname);
    XdmcpDisposeARRAY8 (&status);
}

static void
send_request_msg()
{
    XdmcpHeader	    header;
    int		    length;
    int		    i;
    ARRAY8	    authenticationData;

    header.version = XDM_PROTOCOL_VERSION;
    header.opcode = (CARD16) REQUEST;

    length = 2;					    /* display number */
    length += 1 + 2 * ConnectionTypes.length;	    /* connection types */
    length += 1;				    /* connection addresses */
    for (i = 0; i < ConnectionAddresses.length; i++)
	length += 2 + ConnectionAddresses.data[i].length;
    authenticationData.length = 0;
    authenticationData.data = 0;
    if (AuthenticationFuncs)
    {
	(*AuthenticationFuncs->Generator) (AuthenticationData,
					   &authenticationData,
 					   REQUEST);
    }
    length += 2 + AuthenticationName->length;	    /* authentication name */
    length += 2 + authenticationData.length;	    /* authentication data */
    length += 1;				    /* authorization names */
    for (i = 0; i < AuthorizationNames.length; i++)
	length += 2 + AuthorizationNames.data[i].length;
    length += 2 + ManufacturerDisplayID.length;	    /* display ID */
    header.length = length;

    if (!XdmcpWriteHeader (&buffer, &header))
    {
	XdmcpDisposeARRAY8 (&authenticationData);
	return;
    }
    XdmcpWriteCARD16 (&buffer, DisplayNumber);
    XdmcpWriteARRAY16 (&buffer, &ConnectionTypes);
    XdmcpWriteARRAYofARRAY8 (&buffer, &ConnectionAddresses);

    XdmcpWriteARRAY8 (&buffer, AuthenticationName);
    XdmcpWriteARRAY8 (&buffer, &authenticationData);
    XdmcpDisposeARRAY8 (&authenticationData);
    XdmcpWriteARRAYofARRAY8 (&buffer, &AuthorizationNames);
    XdmcpWriteARRAY8 (&buffer, &ManufacturerDisplayID);
    if (XdmcpFlush (xdmcpSocket, &buffer, &req_sockaddr, req_socklen))
	state = XDM_AWAIT_REQUEST_RESPONSE;
}

static void
recv_accept_msg(length)
    unsigned		length;
{
    CARD32  AcceptSessionID;
    ARRAY8  AcceptAuthenticationName, AcceptAuthenticationData;
    ARRAY8  AcceptAuthorizationName, AcceptAuthorizationData;

    if (state != XDM_AWAIT_REQUEST_RESPONSE)
	return;
    AcceptAuthenticationName.data = 0;
    AcceptAuthenticationData.data = 0;
    AcceptAuthorizationName.data = 0;
    AcceptAuthorizationData.data = 0;
    if (XdmcpReadCARD32 (&buffer, &AcceptSessionID) &&
	XdmcpReadARRAY8 (&buffer, &AcceptAuthenticationName) &&
	XdmcpReadARRAY8 (&buffer, &AcceptAuthenticationData) &&
	XdmcpReadARRAY8 (&buffer, &AcceptAuthorizationName) &&
	XdmcpReadARRAY8 (&buffer, &AcceptAuthorizationData))
    {
    	if (length == 12 + AcceptAuthenticationName.length +
		      	   AcceptAuthenticationData.length +
		      	   AcceptAuthorizationName.length +
 		      	   AcceptAuthorizationData.length)
    	{
	    if (!XdmcpCheckAuthentication (&AcceptAuthenticationName,
				      &AcceptAuthenticationData, ACCEPT))
	    {
		XdmcpFatal ("Authentication Failure", &AcceptAuthenticationName);
	    }
	    /* permit access control manipulations from this host */
	    AugmentSelf (&req_sockaddr, req_socklen);
	    /* if the authorization specified in the packet fails
	     * to be acceptable, enable the local addresses
	     */
	    if (!XdmcpAddAuthorization (&AcceptAuthorizationName,
					&AcceptAuthorizationData))
	    {
		AddLocalHosts ();
	    }
	    SessionID = AcceptSessionID;
    	    state = XDM_MANAGE;
    	    send_packet();
    	}
    }
    XdmcpDisposeARRAY8 (&AcceptAuthenticationName);
    XdmcpDisposeARRAY8 (&AcceptAuthenticationData);
    XdmcpDisposeARRAY8 (&AcceptAuthorizationName);
    XdmcpDisposeARRAY8 (&AcceptAuthorizationData);
}

static void
recv_decline_msg(length)
    unsigned		length;
{
    ARRAY8  status, DeclineAuthenticationName, DeclineAuthenticationData;

    status.data = 0;
    DeclineAuthenticationName.data = 0;
    DeclineAuthenticationData.data = 0;
    if (XdmcpReadARRAY8 (&buffer, &status) &&
	XdmcpReadARRAY8 (&buffer, &DeclineAuthenticationName) &&
	XdmcpReadARRAY8 (&buffer, &DeclineAuthenticationData))
    {
    	if (length == 6 + status.length +
		      	  DeclineAuthenticationName.length +
 		      	  DeclineAuthenticationData.length &&
	    XdmcpCheckAuthentication (&DeclineAuthenticationName,
				      &DeclineAuthenticationData, DECLINE))
    	{
	    XdmcpFatal ("Session declined", &status);
    	}
    }
    XdmcpDisposeARRAY8 (&status);
    XdmcpDisposeARRAY8 (&DeclineAuthenticationName);
    XdmcpDisposeARRAY8 (&DeclineAuthenticationData);
}

static void
send_manage_msg()
{
    XdmcpHeader	header;

    header.version = XDM_PROTOCOL_VERSION;
    header.opcode = (CARD16) MANAGE;
    header.length = 8 + DisplayClass.length;

    if (!XdmcpWriteHeader (&buffer, &header))
	return;
    XdmcpWriteCARD32 (&buffer, SessionID);
    XdmcpWriteCARD16 (&buffer, DisplayNumber);
    XdmcpWriteARRAY8 (&buffer, &DisplayClass);
    state = XDM_AWAIT_MANAGE_RESPONSE;
    XdmcpFlush (xdmcpSocket, &buffer, &req_sockaddr, req_socklen);
}

static void
recv_refuse_msg(length)
    unsigned		length;
{
    CARD32  RefusedSessionID;

    if (state != XDM_AWAIT_MANAGE_RESPONSE)
	return;
    if (length != 4)
	return;
    if (XdmcpReadCARD32 (&buffer, &RefusedSessionID))
    {
	if (RefusedSessionID == SessionID)
	{
    	    state = XDM_START_CONNECTION;
    	    send_packet();
	}
    }
}

static void
recv_failed_msg(length)
    unsigned		length;
{
    CARD32  FailedSessionID;
    ARRAY8  status;

    if (state != XDM_AWAIT_MANAGE_RESPONSE)
	return;
    status.data = 0;
    if (XdmcpReadCARD32 (&buffer, &FailedSessionID) &&
	XdmcpReadARRAY8 (&buffer, &status))
    {
    	if (length == 6 + status.length &&
	    SessionID == FailedSessionID)
	{
	    XdmcpFatal ("Session failed", &status);
	}
    }
    XdmcpDisposeARRAY8 (&status);
}

static void
send_keepalive_msg()
{
    XdmcpHeader	header;

    header.version = XDM_PROTOCOL_VERSION;
    header.opcode = (CARD16) KEEPALIVE;
    header.length = 6;

    XdmcpWriteHeader (&buffer, &header);
    XdmcpWriteCARD16 (&buffer, DisplayNumber);
    XdmcpWriteCARD32 (&buffer, SessionID);

    state = XDM_AWAIT_ALIVE_RESPONSE;
    XdmcpFlush (xdmcpSocket, &buffer, &req_sockaddr, req_socklen);
}

static void
recv_alive_msg (length)
    unsigned		length;
{
    CARD8   SessionRunning;
    CARD32  AliveSessionID;
    int	    dormancy;

    if (state != XDM_AWAIT_ALIVE_RESPONSE)
	return;
    if (length != 5)
	return;
    if (XdmcpReadCARD8 (&buffer, &SessionRunning) &&
	XdmcpReadCARD32 (&buffer, &AliveSessionID))
    {
    	if (SessionRunning && AliveSessionID == SessionID)
    	{
	    /* backoff dormancy period */
	    state = XDM_RUN_SESSION;
	    if ((GetTimeInMillis() - lastDeviceEventTime.milliseconds) >
		keepaliveDormancy * 1000)
	    {
		keepaliveDormancy <<= 1;
		if (keepaliveDormancy > XDM_MAX_DORMANCY)
		    keepaliveDormancy = XDM_MAX_DORMANCY;
	    }
	    timeOutTime = GetTimeInMillis() + keepaliveDormancy * 1000;
    	}
	else
    	{
	    XdmcpDeadSession ("Alive respose indicates session dead");
    	}
    }
}

static 
XdmcpFatal (type, status)
    char	*type;
    ARRAY8Ptr	status;
{
    FatalError ("XDMCP fatal error: %s %*.*s\n", type,
	   status->length, status->length, status->data);
}

static 
XdmcpWarning(str)
    char *str;
{
    ErrorF("XDMCP warning: %s\n", str);
}

static
get_manager_by_name(argc, argv, i)
    int	    argc, i;
    char    **argv;
{
    struct hostent *hep;

    if (i == argc)
    {
	ErrorF("Xserver: missing host name in command line\n");
	exit(1);
    }
    if (!(hep = gethostbyname(argv[i])))
    {
	ErrorF("Xserver: unknown host: %s\n", argv[i]);
	exit(1);
    }
#ifndef _MINIX
    if (hep->h_length == sizeof (struct in_addr))
#else
    if (hep->h_length == sizeof (ipaddr_t))
#endif
    {
	memmove(&ManagerAddress.sin_addr, hep->h_addr, hep->h_length);
#ifdef BSD44SOCKETS
	ManagerAddress.sin_len = sizeof(ManagerAddress);
#endif
	ManagerAddress.sin_family = AF_INET;
	ManagerAddress.sin_port = htons (xdm_udp_port);
    }
    else
    {
	ErrorF ("Xserver: host on strange network %s\n", argv[i]);
	exit (1);
    }
}

#ifdef MINIX
static char read_buffer[XDM_MAX_MSGLEN+sizeof(udp_io_hdr_t)];
static int read_inprogress;
static int read_size;

int
XdmcpFill (fd, buffer, from, fromlen)
int             fd;
XdmcpBufferPtr  buffer;
XdmcpNetaddr    from;       /* return */
int             *fromlen;   /* return */
{
	int r;

	if (read_inprogress)
		return 0;

	if (read_size != 0)
	{
		r= read_size;
		read_size= 0;
		return MNX_XdmcpFill(fd, buffer, from, fromlen, read_buffer,
			r);
	}

	r= read(fd, read_buffer, sizeof(read_buffer));
	if (r > 0)
	{
		return MNX_XdmcpFill(fd, buffer, from, fromlen, read_buffer,
			r);
	}
	else if (r == -1 && errno == EINPROGRESS)
	{
		read_inprogress= 1;
		nbio_inprogress(fd, ASIO_READ, 1 /* read */, 0 /* write */,
			0 /* except */);
		return 0;
	}
	else
		FatalError("XdmcpFill: read failed: %s\n",
			r == 0 ? "EOF" : strerror(errno));
	return 0;
}

static void read_cb(ref, res, err)
nbio_ref_t ref;
int res;
int err;
{
	if (res <= 0)
	{
		FatalError("xdmcp'read_cb: read failed: %s\n",
			res == 0 ? "EOF" : strerror(err));
	}
	read_inprogress= 0;
	read_size= res;
}
#endif

#else
static int xdmcp_non_empty; /* avoid complaint by ranlib */
#endif /* XDMCP */