#define NEED_EVENTS
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <X11/Xlibint.h>
#include <X11/Xtrans/Xtrans.h>
#include <X11/Xauth.h>
#include <X11/Xdmcp.h>
#include <stdio.h>
#include <ctype.h>
#if !defined(WIN32)
#ifndef Lynx
#include <sys/socket.h>
#else
#include <socket.h>
#endif
#else
#include <X11/Xwindows.h>
#endif
#ifndef X_CONNECTION_RETRIES
#define X_CONNECTION_RETRIES 5
#endif
#ifdef LOCALCONN
#include <sys/utsname.h>
#endif
#include "Xintconn.h"
static void GetAuthorization(
XtransConnInfo trans_conn,
int family,
char *saddr,
int saddrlen,
int idisplay,
char **auth_namep,
int *auth_namelenp,
char **auth_datap,
int *auth_datalenp);
static char *copystring (char *src, int len)
{
char *dst = Xmalloc (len + 1);
if (dst) {
strncpy (dst, src, len);
dst[len] = '\0';
}
return dst;
}
XtransConnInfo
_X11TransConnectDisplay (
char *display_name,
char **fullnamep,
int *dpynump,
int *screenp,
char **auth_namep,
int *auth_namelenp,
char **auth_datap,
int *auth_datalenp)
{
int family;
int saddrlen;
Xtransaddr *saddr;
char *lastp, *lastc, *p;
char *pprotocol = NULL;
char *phostname = NULL;
char *pdpynum = NULL;
char *pscrnum = NULL;
Bool dnet = False;
int idisplay = 0;
int iscreen = 0;
int len, hostlen;
int retry;
char addrbuf[128];
char* address = addrbuf;
XtransConnInfo trans_conn = NULL;
int connect_stat;
#if defined(LOCALCONN) || defined(TCPCONN)
Bool reset_hostname = False;
#endif
#ifdef LOCALCONN
struct utsname sys;
# ifdef UNIXCONN
Bool try_unix_socket = False;
# endif
#endif
#ifdef TCPCONN
char *tcphostname = NULL;
#endif
p = display_name;
saddrlen = 0;
saddr = NULL;
for (lastp = p; *p && *p != ':' && *p != '/'; p++) ;
if (!*p) return NULL;
if (p != lastp && *p != ':') {
pprotocol = copystring (lastp, p - lastp);
if (!pprotocol) goto bad;
p++;
} else
p = display_name;
lastp = p;
lastc = NULL;
for (; *p; p++)
if (*p == ':')
lastc = p;
if (!lastc) return NULL;
if ((lastp != lastc) && (*(lastc - 1) == ':')
#if defined(IPv6) && defined(AF_INET6)
&& ( ((lastc - 1) == lastp) || (*(lastc - 2) != ':'))
#endif
) {
#ifndef DNETCONN
goto bad;
#else
dnet = True;
if (pprotocol)
Xfree (pprotocol);
pprotocol = copystring ("dnet", 4);
hostlen = lastc - 1 - lastp;
#endif
}
else
hostlen = lastc - lastp;
if (hostlen > 0) {
phostname = copystring (lastp, hostlen);
if (!phostname) goto bad;
}
p = lastc;
#ifdef LOCALCONN
if (!pprotocol && (!phostname || (phostname && uname(&sys) >= 0 &&
!strncmp(phostname, sys.nodename,
(strlen(sys.nodename) < strlen(phostname) ?
strlen(phostname) : strlen(sys.nodename))))))
{
#ifdef UNIXCONN
try_unix_socket = True;
#endif
#ifdef TCPCONN
if (phostname)
tcphostname = copystring(phostname, strlen(phostname));
else
tcphostname = copystring("localhost", 9);
#endif
if (!phostname)
reset_hostname = True;
Xfree (phostname);
phostname = copystring ("unix", 4);
}
#endif
for (lastp = ++p; *p && isascii(*p) && isdigit(*p); p++) ;
if ((p == lastp) ||
(*p != '\0' && *p != '.') ||
!(pdpynum = copystring (lastp, p - lastp)))
goto bad;
idisplay = atoi (pdpynum);
if (*p) {
for (lastp = ++p; *p && isascii(*p) && isdigit (*p); p++) ;
if (p != lastp) {
if (*p ||
!(pscrnum = copystring (lastp, p - lastp)))
goto bad;
iscreen = atoi (lastp);
}
}
#if defined(TCPCONN) || defined(UNIXCONN) || defined(LOCALCONN) || defined(MNX_TCPCONN) || defined(OS2PIPECONN)
if (!pprotocol) {
if (!phostname || phostname[0]=='/') {
#if defined(UNIXCONN) || defined(LOCALCONN) || defined(OS2PIPECONN)
pprotocol = copystring ("local", 5);
#if defined(TCPCONN)
tcphostname = copystring("localhost", 9);
#endif
}
else
{
#endif
pprotocol = copystring ("tcp", 3);
}
}
#endif
#if defined(UNIXCONN) || defined(LOCALCONN) || defined(OS2PIPECONN)
if (!phostname) {
#ifdef apollo
;
#else
if( pprotocol ) Xfree(pprotocol);
pprotocol = copystring ("local", 5);
#endif
}
else if (strcmp (phostname, "unix") == 0) {
if( pprotocol ) Xfree(pprotocol);
pprotocol = copystring ("local", 5);
}
#endif
#if defined(TCPCONN)
connect:
#endif
{
int olen = 3 + (pprotocol ? strlen(pprotocol) : 0) +
(phostname ? strlen(phostname) : 0) +
(pdpynum ? strlen(pdpynum) : 0);
if (olen > sizeof addrbuf) address = Xmalloc (olen);
}
if (!address) goto bad;
sprintf(address,"%s/%s:%d",
pprotocol ? pprotocol : "",
phostname ? phostname : "",
idisplay );
for(retry=X_CONNECTION_RETRIES; retry>=0; retry-- )
{
if ( (trans_conn = _X11TransOpenCOTSClient(address)) == NULL )
{
break;
}
if ((connect_stat = _X11TransConnect(trans_conn,address)) < 0 )
{
_X11TransClose(trans_conn);
trans_conn = NULL;
if (connect_stat == TRANS_TRY_CONNECT_AGAIN)
{
sleep(1);
continue;
}
else
break;
}
_X11TransGetPeerAddr(trans_conn, &family, &saddrlen, &saddr);
if( _X11TransConvertAddress(&family, &saddrlen, &saddr) < 0 )
{
_X11TransClose(trans_conn);
trans_conn = NULL;
sleep(1);
if (saddr)
{
free ((char *) saddr);
saddr = NULL;
}
continue;
}
break;
}
if (address != addrbuf) Xfree (address);
address = addrbuf;
if( trans_conn == NULL )
goto bad;
_X11TransSetOption(trans_conn,TRANS_CLOSEONEXEC,1);
#if defined(LOCALCONN) || defined(TCPCONN)
if (reset_hostname) {
Xfree (phostname);
phostname = NULL;
}
#endif
len = ((phostname ? strlen(phostname) : 0) + 1 + (dnet ? 1 : 0) +
strlen(pdpynum) + 1 + (pscrnum ? strlen(pscrnum) : 1) + 1);
*fullnamep = (char *) Xmalloc (len);
if (!*fullnamep) goto bad;
if (phostname && strlen(phostname) > 11 && !strncmp(phostname, "/tmp/launch", 11))
sprintf (*fullnamep, "%s%s%d",
(phostname ? phostname : ""),
(dnet ? "::" : ":"),
idisplay);
else
sprintf (*fullnamep, "%s%s%d.%d",
(phostname ? phostname : ""),
(dnet ? "::" : ":"),
idisplay, iscreen);
*dpynump = idisplay;
*screenp = iscreen;
if (pprotocol) Xfree (pprotocol);
if (phostname) Xfree (phostname);
if (pdpynum) Xfree (pdpynum);
if (pscrnum) Xfree (pscrnum);
#ifdef TCPCONN
if (tcphostname) Xfree (tcphostname);
#endif
GetAuthorization(trans_conn, family, (char *) saddr, saddrlen, idisplay,
auth_namep, auth_namelenp, auth_datap, auth_datalenp);
return trans_conn;
bad:
if (trans_conn) (void)_X11TransClose(trans_conn);
if (saddr) free ((char *) saddr);
if (pprotocol) Xfree (pprotocol);
if (phostname) Xfree (phostname);
if (address && address != addrbuf) { Xfree(address); address = addrbuf; }
#if defined(LOCALCONN) && defined(UNIXCONN)
if (try_unix_socket) {
pprotocol = copystring ("unix", 4);
phostname = NULL;
try_unix_socket = False;
goto connect;
}
#endif
#if defined(TCPCONN)
if (tcphostname) {
pprotocol = copystring("tcp", 3);
phostname = tcphostname;
tcphostname = NULL;
reset_hostname = True;
goto connect;
}
#endif
if (pdpynum) Xfree (pdpynum);
if (pscrnum) Xfree (pscrnum);
return NULL;
}
int _XConnectDisplay (
char *display_name,
char **fullnamep,
int *dpynump,
int *screenp,
char **auth_namep,
int *auth_namelenp,
char **auth_datap,
int *auth_datalenp)
{
XtransConnInfo trans_conn;
trans_conn = _X11TransConnectDisplay (
display_name, fullnamep, dpynump, screenp,
auth_namep, auth_namelenp, auth_datap, auth_datalenp);
if (trans_conn)
{
int fd = _X11TransGetConnectionNumber (trans_conn);
_X11TransFreeConnInfo (trans_conn);
return (fd);
}
else
return (-1);
}
int _XDisconnectDisplay (trans_conn)
XtransConnInfo trans_conn;
{
_X11TransDisconnect(trans_conn);
_X11TransClose(trans_conn);
return 0;
}
Bool
_XSendClientPrefix (dpy, client, auth_proto, auth_string, prefix)
Display *dpy;
xConnClientPrefix *client;
char *auth_proto, *auth_string;
xConnSetupPrefix *prefix;
{
int auth_length = client->nbytesAuthProto;
int auth_strlen = client->nbytesAuthString;
static char padbuf[3];
int pad;
struct iovec iovarray[5], *iov = iovarray;
int niov = 0;
int len = 0;
#define add_to_iov(b,l) \
{ iov->iov_base = (b); iov->iov_len = (l); iov++, niov++; len += (l); }
add_to_iov ((caddr_t) client, SIZEOF(xConnClientPrefix));
if (auth_length > 0) {
add_to_iov (auth_proto, auth_length);
pad = -auth_length & 3;
if (pad) add_to_iov (padbuf, pad);
}
if (auth_strlen > 0) {
add_to_iov (auth_string, auth_strlen);
pad = -auth_strlen & 3;
if (pad) add_to_iov (padbuf, pad);
}
#undef add_to_iov
len -= _X11TransWritev (dpy->trans_conn, iovarray, niov);
_X11TransSetOption(dpy->trans_conn, TRANS_NONBLOCKING, 1);
if (len != 0)
return -1;
#ifdef K5AUTH
if (auth_length == 14 &&
!strncmp(auth_proto, "MIT-KERBEROS-5", 14))
{
return k5_clientauth(dpy, prefix);
} else
#endif
return 0;
}
#ifdef STREAMSCONN
#ifdef SVR4
#include <tiuser.h>
#else
#undef HASXDMAUTH
#endif
#endif
#ifdef SECURE_RPC
#include <rpc/rpc.h>
#ifdef ultrix
#include <time.h>
#include <rpc/auth_des.h>
#endif
#endif
#ifdef HASXDMAUTH
#include <time.h>
#define Time_t time_t
#endif
static int xauth_namelen = 0;
static char *xauth_name = NULL;
static int xauth_datalen = 0;
static char *xauth_data = NULL;
static char *default_xauth_names[] = {
#ifdef K5AUTH
"MIT-KERBEROS-5",
#endif
#ifdef SECURE_RPC
"SUN-DES-1",
#endif
#ifdef HASXDMAUTH
"XDM-AUTHORIZATION-1",
#endif
"MIT-MAGIC-COOKIE-1"
};
static _Xconst int default_xauth_lengths[] = {
#ifdef K5AUTH
14,
#endif
#ifdef SECURE_RPC
9,
#endif
#ifdef HASXDMAUTH
19,
#endif
18
};
#define NUM_DEFAULT_AUTH (sizeof (default_xauth_names) / sizeof (default_xauth_names[0]))
static char **xauth_names = default_xauth_names;
static _Xconst int *xauth_lengths = default_xauth_lengths;
static int xauth_names_length = NUM_DEFAULT_AUTH;
void XSetAuthorization (name, namelen, data, datalen)
int namelen, datalen;
char *name, *data;
{
char *tmpname, *tmpdata;
_XLockMutex(_Xglobal_lock);
if (xauth_name) Xfree (xauth_name);
if (xauth_data) Xfree (xauth_data);
xauth_name = xauth_data = NULL;
xauth_namelen = xauth_datalen = 0;
_XUnlockMutex(_Xglobal_lock);
if (namelen < 0) namelen = 0;
if (datalen < 0) datalen = 0;
if (namelen > 0) {
tmpname = Xmalloc ((unsigned) namelen);
if (!tmpname) return;
memcpy (tmpname, name, namelen);
} else {
tmpname = NULL;
}
if (datalen > 0) {
tmpdata = Xmalloc ((unsigned) datalen);
if (!tmpdata) {
if (tmpname) (void) Xfree (tmpname);
return;
}
memcpy (tmpdata, data, datalen);
} else {
tmpdata = NULL;
}
_XLockMutex(_Xglobal_lock);
xauth_name = tmpname;
xauth_namelen = namelen;
if (tmpname)
{
xauth_names = &xauth_name;
xauth_lengths = &xauth_namelen;
xauth_names_length = 1;
}
else
{
xauth_names = default_xauth_names;
xauth_lengths = default_xauth_lengths;
xauth_names_length = NUM_DEFAULT_AUTH;
}
xauth_data = tmpdata;
xauth_datalen = datalen;
_XUnlockMutex(_Xglobal_lock);
return;
}
#ifdef SECURE_RPC
static int
auth_ezencode(
char *servername,
int window,
char *cred_out,
int *len)
{
AUTH *a;
XDR xdr;
#if defined(SVR4) && defined(sun)
a = authdes_seccreate(servername, window, NULL, NULL);
#else
a = (AUTH *)authdes_create(servername, window, NULL, NULL);
#endif
if (a == (AUTH *)NULL) {
perror("auth_create");
return 0;
}
xdrmem_create(&xdr, cred_out, *len, XDR_ENCODE);
if (AUTH_MARSHALL(a, &xdr) == FALSE) {
perror("auth_marshall");
AUTH_DESTROY(a);
return 0;
}
*len = xdr_getpos(&xdr);
AUTH_DESTROY(a);
return 1;
}
#endif
#ifdef K5AUTH
#include <com_err.h>
extern krb5_flags krb5_kdc_default_options;
static int k5_clientauth(dpy, sprefix)
Display *dpy;
xConnSetupPrefix *sprefix;
{
krb5_error_code retval;
xReq prefix;
char *buf;
CARD16 plen, tlen;
krb5_data kbuf;
krb5_ccache cc;
krb5_creds creds;
krb5_principal cprinc, sprinc;
krb5_ap_rep_enc_part *repl;
krb5_init_ets();
_XRead(dpy, (char *)&prefix, sz_xReq);
if (prefix.reqType != 2 && prefix.reqType != 3)
if (prefix.reqType == 0 || prefix.reqType == 1)
{
memcpy((char *)sprefix, (char *)&prefix, sz_xReq);
_XRead(dpy, (char *)sprefix + sz_xReq,
sz_xConnSetupPrefix - sz_xReq);
return 1;
}
else
{
fprintf(stderr,
"Xlib: Krb5 stage 0: got illegal connection setup success code %d\n",
prefix.reqType);
return -1;
}
if (prefix.data != 0)
{
fprintf(stderr, "Xlib: got out of sequence (%d) packet in Krb5 auth\n",
prefix.data);
return -1;
}
buf = (char *)malloc((prefix.length << 2) - sz_xReq);
if (buf == NULL)
{
fprintf(stderr, "Xlib: malloc bombed in Krb5 auth\n");
return -1;
}
tlen = (prefix.length << 2) - sz_xReq;
_XRead(dpy, buf, tlen);
if (prefix.reqType == 2 && tlen < 6)
{
fprintf(stderr, "Xlib: Krb5 stage 0 reply from server too short\n");
free(buf);
return -1;
}
if (prefix.reqType == 2)
{
plen = *(CARD16 *)buf;
kbuf.data = buf + 2;
kbuf.length = (plen > tlen) ? tlen : plen;
}
else
{
kbuf.data = buf;
kbuf.length = tlen;
}
if (XauKrb5Decode(kbuf, &sprinc))
{
free(buf);
fprintf(stderr, "Xlib: XauKrb5Decode bombed\n");
return -1;
}
if (prefix.reqType == 3)
{
char *sname, *hostname = NULL;
sname = (char *)malloc(krb5_princ_component(sprinc, 0)->length + 1);
if (sname == NULL)
{
free(buf);
krb5_free_principal(sprinc);
fprintf(stderr, "Xlib: malloc bombed in Krb5 auth\n");
return -1;
}
memcpy(sname, krb5_princ_component(sprinc, 0)->data,
krb5_princ_component(sprinc, 0)->length);
sname[krb5_princ_component(sprinc, 0)->length] = '\0';
krb5_free_principal(sprinc);
if (dpy->display_name[0] != ':')
{
char *t;
if ((hostname = (char *)malloc(strlen(dpy->display_name)))
== NULL)
{
free(buf);
free(sname);
fprintf(stderr, "Xlib: malloc bombed in Krb5 auth\n");
return -1;
}
strcpy(hostname, dpy->display_name);
t = strchr(hostname, ':');
if (t == NULL)
{
free(buf);
free(sname);
free(hostname);
fprintf(stderr,
"Xlib: shouldn't get here! malformed display name.");
return -1;
}
if ((t - hostname + 1 < strlen(hostname)) && t[1] == ':')
t++;
*t = '\0';
}
retval = krb5_sname_to_principal(hostname, sname,
KRB5_NT_SRV_HST, &sprinc);
free(sname);
if (hostname)
free(hostname);
if (retval)
{
free(buf);
fprintf(stderr, "Xlib: krb5_sname_to_principal failed: %s\n",
error_message(retval));
return -1;
}
}
if (retval = krb5_cc_default(&cc))
{
free(buf);
krb5_free_principal(sprinc);
fprintf(stderr, "Xlib: krb5_cc_default failed: %s\n",
error_message(retval));
return -1;
}
if (retval = krb5_cc_get_principal(cc, &cprinc))
{
free(buf);
krb5_free_principal(sprinc);
fprintf(stderr, "Xlib: cannot get Kerberos principal from \"%s\": %s\n",
krb5_cc_default_name(), error_message(retval));
return -1;
}
bzero((char *)&creds, sizeof(creds));
creds.server = sprinc;
creds.client = cprinc;
if (prefix.reqType == 2)
{
creds.second_ticket.length = tlen - plen - 2;
creds.second_ticket.data = buf + 2 + plen;
retval = krb5_get_credentials(KRB5_GC_USER_USER |
krb5_kdc_default_options,
cc, &creds);
}
else
retval = krb5_get_credentials(krb5_kdc_default_options,
cc, &creds);
if (retval)
{
free(buf);
krb5_free_cred_contents(&creds);
fprintf(stderr, "Xlib: cannot get Kerberos credentials: %s\n",
error_message(retval));
return -1;
}
if (prefix.reqType == 2)
retval = krb5_mk_req_extended(AP_OPTS_USE_SESSION_KEY |
AP_OPTS_MUTUAL_REQUIRED, NULL,
0, 0, NULL, cc,
&creds, NULL, &kbuf);
else
retval = krb5_mk_req_extended(AP_OPTS_MUTUAL_REQUIRED, NULL,
0, 0, NULL, cc, &creds, NULL,
&kbuf);
free(buf);
if (retval)
{
krb5_free_cred_contents(&creds);
fprintf(stderr, "Xlib: krb5_mk_req_extended failed: %s\n",
error_message(retval));
return -1;
}
prefix.reqType = 1;
prefix.data = 0;
prefix.length = (kbuf.length + sz_xReq + 3) >> 2;
_XSend(dpy, (char *)&prefix, sz_xReq);
_XSend(dpy, (char *)kbuf.data, kbuf.length);
free(kbuf.data);
_XRead(dpy, (char *)&prefix, sz_xReq);
if (prefix.reqType != 2)
if (prefix.reqType == 0 || prefix.reqType == 1)
{
memcpy((char *)sprefix, (char *)&prefix, sz_xReq);
_XRead(dpy, (char *)sprefix + sz_xReq,
sz_xConnSetupPrefix - sz_xReq);
return 1;
}
else
{
fprintf(stderr,
"Xlib: Krb5 stage 2: got illegal connection setup success code %d\n",
prefix.reqType);
return -1;
}
if (prefix.data != 2)
return -1;
kbuf.length = (prefix.length << 2) - sz_xReq;
kbuf.data = (char *)malloc(kbuf.length);
if (kbuf.data == NULL)
{
fprintf(stderr, "Xlib: malloc bombed in Krb5 auth\n");
return -1;
}
_XRead(dpy, (char *)kbuf.data, kbuf.length);
retval = krb5_rd_rep(&kbuf, &creds.keyblock, &repl);
if (retval)
{
free(kbuf.data);
fprintf(stderr, "Xlib: krb5_rd_rep failed: %s\n",
error_message(retval));
return -1;
}
free(kbuf.data);
prefix.reqType = 3;
prefix.data = 0;
prefix.length = sz_xReq >> 2;
_XSend(dpy, (char *)&prefix, sz_xReq);
return 0;
}
#endif
static void
GetAuthorization(
XtransConnInfo trans_conn,
int family,
char *saddr,
int saddrlen,
int idisplay,
char **auth_namep,
int *auth_namelenp,
char **auth_datap,
int *auth_datalenp)
{
#ifdef SECURE_RPC
char rpc_cred[MAX_AUTH_BYTES];
#endif
#ifdef HASXDMAUTH
unsigned char xdmcp_data[192/8];
#endif
char *auth_name;
int auth_namelen;
unsigned char *auth_data;
int auth_datalen;
Xauth *authptr = NULL;
if (xauth_name && xauth_data) {
auth_namelen = xauth_namelen;
auth_name = xauth_name;
auth_datalen = xauth_datalen;
auth_data = (unsigned char *) xauth_data;
} else {
char dpynumbuf[40];
(void) sprintf (dpynumbuf, "%d", idisplay);
authptr = XauGetBestAuthByAddr ((unsigned short) family,
(unsigned short) saddrlen,
saddr,
(unsigned short) strlen (dpynumbuf),
dpynumbuf,
xauth_names_length,
xauth_names,
xauth_lengths);
if (authptr) {
auth_namelen = authptr->name_length;
auth_name = (char *)authptr->name;
auth_datalen = authptr->data_length;
auth_data = (unsigned char *) authptr->data;
} else {
auth_namelen = 0;
auth_name = NULL;
auth_datalen = 0;
auth_data = NULL;
}
}
#ifdef HASXDMAUTH
if (auth_namelen == 19 && !strncmp (auth_name, "XDM-AUTHORIZATION-1", 19))
{
int i, j;
Time_t now;
int family, addrlen;
Xtransaddr *addr = NULL;
for (j = 0; j < 8; j++)
xdmcp_data[j] = auth_data[j];
_X11TransGetMyAddr(trans_conn, &family, &addrlen, &addr);
switch( family )
{
#ifdef AF_INET
case AF_INET:
{
for(i=4; i<8; i++)
xdmcp_data[j++] = ((char *)addr)[i];
for(i=2; i<4; i++)
xdmcp_data[j++] = ((char *)addr)[i];
break;
}
#endif
#if defined(IPv6) && defined(AF_INET6)
case AF_INET6:
{
unsigned char ipv4mappedprefix[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
if (memcmp(addr+8, ipv4mappedprefix, 12) == 0) {
for (i = 20 ; i < 24; i++)
xdmcp_data[j++] = ((char *)addr)[i];
for (i=2; i<4; i++)
xdmcp_data[j++] = ((char *)addr)[i];
} else {
for (i = 0; i < 6; i++) {
xdmcp_data[j++] = 0;
}
}
break;
}
#endif
#ifdef AF_UNIX
case AF_UNIX:
{
static unsigned long unix_addr = 0xFFFFFFFF;
unsigned long the_addr;
unsigned short the_port;
unsigned long the_utime;
struct timeval tp;
X_GETTIMEOFDAY(&tp);
_XLockMutex(_Xglobal_lock);
the_addr = unix_addr--;
_XUnlockMutex(_Xglobal_lock);
the_utime = (unsigned long) tp.tv_usec;
the_port = getpid ();
xdmcp_data[j++] = (the_utime >> 24) & 0xFF;
xdmcp_data[j++] = (the_utime >> 16) & 0xFF;
xdmcp_data[j++] = ((the_utime >> 8) & 0xF0)
| ((the_addr >> 8) & 0x0F);
xdmcp_data[j++] = (the_addr >> 0) & 0xFF;
xdmcp_data[j++] = (the_port >> 8) & 0xFF;
xdmcp_data[j++] = (the_port >> 0) & 0xFF;
break;
}
#endif
#ifdef AF_DECnet
case AF_DECnet:
break;
#endif
default:
break;
}
if (addr)
free ((char *) addr);
time (&now);
xdmcp_data[j++] = (now >> 24) & 0xFF;
xdmcp_data[j++] = (now >> 16) & 0xFF;
xdmcp_data[j++] = (now >> 8) & 0xFF;
xdmcp_data[j++] = (now >> 0) & 0xFF;
while (j < 192 / 8)
xdmcp_data[j++] = 0;
_XLockMutex(_Xglobal_lock);
XdmcpWrap (xdmcp_data, auth_data + 8,
xdmcp_data, j);
_XUnlockMutex(_Xglobal_lock);
auth_data = xdmcp_data;
auth_datalen = j;
}
#endif
#ifdef SECURE_RPC
if (auth_namelen == 9 && !strncmp(auth_name, "SUN-DES-1", 9)) {
char servernetname[MAXNETNAMELEN + 1];
if (auth_datalen > MAXNETNAMELEN) {
auth_datalen = 0;
auth_data = NULL;
} else {
memcpy(servernetname, auth_data, auth_datalen);
servernetname[auth_datalen] = '\0';
auth_datalen = sizeof (rpc_cred);
if (auth_ezencode(servernetname, 100, rpc_cred,
&auth_datalen))
auth_data = (unsigned char *) rpc_cred;
else {
auth_datalen = 0;
auth_data = NULL;
}
}
}
#endif
if (saddr) free ((char *) saddr);
if ((*auth_namelenp = auth_namelen))
{
if ((*auth_namep = Xmalloc(auth_namelen)))
memcpy(*auth_namep, auth_name, auth_namelen);
else
*auth_namelenp = 0;
}
else
*auth_namep = NULL;
if ((*auth_datalenp = auth_datalen))
{
if ((*auth_datap = Xmalloc(auth_datalen)))
memcpy(*auth_datap, auth_data, auth_datalen);
else
*auth_datalenp = 0;
}
else
*auth_datap = NULL;
if (authptr) XauDisposeAuth (authptr);
}