From 6080bcf5b8ef83e0c3b3f09d6a5c1298296b890e Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Tue, 5 Nov 2024 15:51:46 +0100 Subject: [PATCH 01/23] os: incorporate xtrans xtrans-1.6.0 Copy over from xtrans package, tag xtrans-1.6.0 Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 1365 +++++++++++++++++++++++++ os/Xtrans.h | 422 ++++++++ os/Xtransint.h | 430 ++++++++ os/Xtranslcl.c | 1462 +++++++++++++++++++++++++++ os/Xtranssock.c | 2585 +++++++++++++++++++++++++++++++++++++++++++++++ os/Xtransutil.c | 631 ++++++++++++ os/transport.c | 74 ++ 7 files changed, 6969 insertions(+) create mode 100644 os/Xtrans.c create mode 100644 os/Xtrans.h create mode 100644 os/Xtransint.h create mode 100644 os/Xtranslcl.c create mode 100644 os/Xtranssock.c create mode 100644 os/Xtransutil.c create mode 100644 os/transport.c diff --git a/os/Xtrans.c b/os/Xtrans.c new file mode 100644 index 000000000..617084165 --- /dev/null +++ b/os/Xtrans.c @@ -0,0 +1,1365 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#ifdef HAVE_SYSTEMD_DAEMON +#include +#endif + +/* + * The transport table contains a definition for every transport (protocol) + * family. All operations that can be made on the transport go through this + * table. + * + * Each transport is assigned a unique transport id. + * + * New transports can be added by adding an entry in this table. + * For compatibility, the transport ids should never be renumbered. + * Always add to the end of the list. + */ + +#define TRANS_TLI_INET_INDEX 1 +#define TRANS_TLI_TCP_INDEX 2 +#define TRANS_TLI_TLI_INDEX 3 +#define TRANS_SOCKET_UNIX_INDEX 4 +#define TRANS_SOCKET_LOCAL_INDEX 5 +#define TRANS_SOCKET_INET_INDEX 6 +#define TRANS_SOCKET_TCP_INDEX 7 +#define TRANS_DNET_INDEX 8 +#define TRANS_LOCAL_LOCAL_INDEX 9 +/* 10 used to be PTS, but that's gone. */ +#define TRANS_LOCAL_NAMED_INDEX 11 +/* 12 used to be ISC, but that's gone. */ +/* 13 used to be SCO, but that's gone. */ +#define TRANS_SOCKET_INET6_INDEX 14 +#define TRANS_LOCAL_PIPE_INDEX 15 + +#if defined(IPv6) && !defined(AF_INET6) +#error "Cannot build IPv6 support without AF_INET6" +#endif + +static +Xtransport_table Xtransports[] = { +#if defined(TCPCONN) + { &TRANS(SocketTCPFuncs), TRANS_SOCKET_TCP_INDEX }, +#if defined(IPv6) + { &TRANS(SocketINET6Funcs), TRANS_SOCKET_INET6_INDEX }, +#endif /* IPv6 */ + { &TRANS(SocketINETFuncs), TRANS_SOCKET_INET_INDEX }, +#endif /* TCPCONN */ +#if defined(UNIXCONN) +#if !defined(LOCALCONN) + { &TRANS(SocketLocalFuncs), TRANS_SOCKET_LOCAL_INDEX }, +#endif /* !LOCALCONN */ + { &TRANS(SocketUNIXFuncs), TRANS_SOCKET_UNIX_INDEX }, +#endif /* UNIXCONN */ +#if defined(LOCALCONN) + { &TRANS(LocalFuncs), TRANS_LOCAL_LOCAL_INDEX }, +#if defined(SVR4) || defined(__SVR4) + { &TRANS(NAMEDFuncs), TRANS_LOCAL_NAMED_INDEX }, +#endif +#ifdef __sun + { &TRANS(PIPEFuncs), TRANS_LOCAL_PIPE_INDEX }, +#endif /* __sun */ +#endif /* LOCALCONN */ +}; + +#define NUMTRANS (sizeof(Xtransports)/sizeof(Xtransport_table)) + + +#ifdef WIN32 +#define ioctl ioctlsocket +#endif + + + +/* + * These are a few utility function used by the public interface functions. + */ + +void +TRANS(FreeConnInfo) (XtransConnInfo ciptr) + +{ + prmsg (3,"FreeConnInfo(%p)\n", (void *) ciptr); + + if (ciptr->addr) + free (ciptr->addr); + + if (ciptr->peeraddr) + free (ciptr->peeraddr); + + if (ciptr->port) + free (ciptr->port); + + free (ciptr); +} + + +#define PROTOBUFSIZE 20 + +static Xtransport * +TRANS(SelectTransport) (const char *protocol) + +{ +#ifndef HAVE_STRCASECMP + char protobuf[PROTOBUFSIZE]; +#endif + + prmsg (3,"SelectTransport(%s)\n", protocol); + +#ifndef HAVE_STRCASECMP + /* + * Force Protocol to be lowercase as a way of doing + * a case insensitive match. + */ + + strncpy (protobuf, protocol, PROTOBUFSIZE - 1); + protobuf[PROTOBUFSIZE-1] = '\0'; + + for (unsigned int i = 0; i < PROTOBUFSIZE && protobuf[i] != '\0'; i++) + if (isupper ((unsigned char)protobuf[i])) + protobuf[i] = tolower ((unsigned char)protobuf[i]); +#endif + + /* Look at all of the configured protocols */ + + for (unsigned int i = 0; i < NUMTRANS; i++) + { +#ifndef HAVE_STRCASECMP + if (!strcmp (protobuf, Xtransports[i].transport->TransName)) +#else + if (!strcasecmp (protocol, Xtransports[i].transport->TransName)) +#endif + return Xtransports[i].transport; + } + + return NULL; +} + +static int +TRANS(ParseAddress) (const char *address, + char **protocol, char **host, char **port) + +{ + /* + * For the font library, the address is a string formatted + * as "protocol/host:port[/catalogue]". Note that the catologue + * is optional. At this time, the catologue info is ignored, but + * we have to parse it anyways. + * + * Other than fontlib, the address is a string formatted + * as "protocol/host:port". + * + * If the protocol part is missing, then assume TCP. + * If the protocol part and host part are missing, then assume local. + * If a "::" is found then assume DNET. + */ + + char *mybuf, *tmpptr = NULL; + const char *_protocol = NULL; + const char *_host, *_port; + char hostnamebuf[256]; + char *_host_buf; + int _host_len; + + prmsg (3,"ParseAddress(%s)\n", address); + + /* First, check for AF_UNIX socket paths */ + if (address[0] == '/') { + _protocol = "local"; + _host = ""; + _port = address; + } else +#ifdef HAVE_LAUNCHD + /* launchd sockets will look like 'local//tmp/launch-XgkNns/:0' */ + if(!strncmp(address,"local//",7)) { + _protocol="local"; + _host=""; + _port=address+6; + } else +#endif + if (!strncmp(address, "unix:", 5)) { + _protocol = "local"; + _host = ""; + _port = address + 5; + } + if (_protocol) + goto done_parsing; + + /* Copy the string so it can be changed */ + + tmpptr = mybuf = strdup (address); + + /* Parse the string to get each component */ + + /* Get the protocol part */ + + _protocol = mybuf; + + + if ((mybuf == NULL) || + ( ((mybuf = strchr (mybuf, '/')) == NULL) && + ((mybuf = strrchr (tmpptr, ':')) == NULL) ) ) + { + /* address is in a bad format */ + *protocol = NULL; + *host = NULL; + *port = NULL; + free (tmpptr); + return 0; + } + + if (*mybuf == ':') + { + /* + * If there is a hostname, then assume tcp, otherwise + * it must be local. + */ + if (mybuf == tmpptr) + { + /* There is neither a protocol or host specified */ + _protocol = "local"; + } + else + { + /* There is a hostname specified */ + _protocol = "tcp"; + mybuf = tmpptr; /* reset to the beginning of the host ptr */ + } + } + else + { + /* *mybuf == '/' */ + + *mybuf ++= '\0'; /* put a null at the end of the protocol */ + + if (strlen(_protocol) == 0) + { + /* + * If there is a hostname, then assume tcp, otherwise + * it must be local. + */ + if (*mybuf != ':') + _protocol = "tcp"; + else + _protocol = "local"; + } + } + + /* Get the host part */ + + _host = _host_buf = mybuf; + + if ((mybuf = strrchr (mybuf,':')) == NULL) + { + *protocol = NULL; + *host = NULL; + *port = NULL; + free (tmpptr); + return 0; + } + + *mybuf ++= '\0'; + + _host_len = strlen(_host); + if (_host_len == 0) + { + TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf)); + _host = hostnamebuf; + } +#ifdef IPv6 + /* hostname in IPv6 [numeric_addr]:0 form? */ + else if ( (_host_len > 3) && + ((strcmp(_protocol, "tcp") == 0) || (strcmp(_protocol, "inet6") == 0)) + && (_host_buf[0] == '[') && (_host_buf[_host_len - 1] == ']') ) { + struct sockaddr_in6 sin6; + + _host_buf[_host_len - 1] = '\0'; + + /* Verify address is valid IPv6 numeric form */ + if (inet_pton(AF_INET6, _host + 1, &sin6) == 1) { + /* It is. Use it as such. */ + _host++; + _protocol = "inet6"; + } else { + /* It's not, restore it just in case some other code can use it. */ + _host_buf[_host_len - 1] = ']'; + } + } +#endif + + + /* Get the port */ + + _port = mybuf; + +#if defined(FONT_t) || defined(FS_t) + /* + * Is there an optional catalogue list? + */ + + if ((mybuf = strchr (mybuf,'/')) != NULL) + *mybuf ++= '\0'; + + /* + * The rest, if any, is the (currently unused) catalogue list. + * + * _catalogue = mybuf; + */ +#endif + +done_parsing: + /* + * Now that we have all of the components, allocate new + * string space for them. + */ + + if ((*protocol = strdup (_protocol)) == NULL) + { + /* Malloc failed */ + *port = NULL; + *host = NULL; + *protocol = NULL; + free (tmpptr); + return 0; + } + + if ((*host = strdup (_host)) == NULL) + { + /* Malloc failed */ + *port = NULL; + *host = NULL; + free (*protocol); + *protocol = NULL; + free (tmpptr); + return 0; + } + + if ((*port = strdup (_port)) == NULL) + { + /* Malloc failed */ + *port = NULL; + free (*host); + *host = NULL; + free (*protocol); + *protocol = NULL; + free (tmpptr); + return 0; + } + + free (tmpptr); + + return 1; +} + + +/* + * TRANS(Open) does all of the real work opening a connection. The only + * funny part about this is the type parameter which is used to decide which + * type of open to perform. + */ + +static XtransConnInfo +TRANS(Open) (int type, const char *address) + +{ + char *protocol = NULL, *host = NULL, *port = NULL; + XtransConnInfo ciptr = NULL; + Xtransport *thistrans; + + prmsg (2,"Open(%d,%s)\n", type, address); + +#if defined(WIN32) && defined(TCPCONN) + if (TRANS(WSAStartup)()) + { + prmsg (1,"Open: WSAStartup failed\n"); + return NULL; + } +#endif + + /* Parse the Address */ + + if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0) + { + prmsg (1,"Open: Unable to Parse address %s\n", address); + return NULL; + } + + /* Determine the transport type */ + + if ((thistrans = TRANS(SelectTransport) (protocol)) == NULL) + { + prmsg (1,"Open: Unable to find transport for %s\n", + protocol); + + free (protocol); + free (host); + free (port); + return NULL; + } + + /* Open the transport */ + + switch (type) + { + case XTRANS_OPEN_COTS_CLIENT: +#ifdef TRANS_CLIENT + ciptr = thistrans->OpenCOTSClient(thistrans, protocol, host, port); +#endif /* TRANS_CLIENT */ + break; + case XTRANS_OPEN_COTS_SERVER: +#ifdef TRANS_SERVER + ciptr = thistrans->OpenCOTSServer(thistrans, protocol, host, port); +#endif /* TRANS_SERVER */ + break; + default: + prmsg (1,"Open: Unknown Open type %d\n", type); + } + + if (ciptr == NULL) + { + if (!(thistrans->flags & TRANS_DISABLED)) + { + prmsg (1,"Open: transport open failed for %s/%s:%s\n", + protocol, host, port); + } + free (protocol); + free (host); + free (port); + return NULL; + } + + ciptr->transptr = thistrans; + ciptr->port = port; /* We need this for TRANS(Reopen) */ + + free (protocol); + free (host); + + return ciptr; +} + + +#ifdef TRANS_REOPEN + +/* + * We might want to create an XtransConnInfo object based on a previously + * opened connection. For example, the font server may clone itself and + * pass file descriptors to the parent. + */ + +static XtransConnInfo +TRANS(Reopen) (int type, int trans_id, int fd, const char *port) + +{ + XtransConnInfo ciptr = NULL; + Xtransport *thistrans = NULL; + char *save_port; + + prmsg (2,"Reopen(%d,%d,%s)\n", trans_id, fd, port); + + /* Determine the transport type */ + + for (unsigned int i = 0; i < NUMTRANS; i++) + { + if (Xtransports[i].transport_id == trans_id) + { + thistrans = Xtransports[i].transport; + break; + } + } + + if (thistrans == NULL) + { + prmsg (1,"Reopen: Unable to find transport id %d\n", + trans_id); + + return NULL; + } + + if ((save_port = strdup (port)) == NULL) + { + prmsg (1,"Reopen: Unable to malloc port string\n"); + + return NULL; + } + + /* Get a new XtransConnInfo object */ + + switch (type) + { + case XTRANS_OPEN_COTS_SERVER: + ciptr = thistrans->ReopenCOTSServer(thistrans, fd, port); + break; + default: + prmsg (1,"Reopen: Bad Open type %d\n", type); + } + + if (ciptr == NULL) + { + prmsg (1,"Reopen: transport open failed\n"); + free (save_port); + return NULL; + } + + ciptr->transptr = thistrans; + ciptr->port = save_port; + + return ciptr; +} + +#endif /* TRANS_REOPEN */ + + + +/* + * These are the public interfaces to this Transport interface. + * These are the only functions that should have knowledge of the transport + * table. + */ + +#ifdef TRANS_CLIENT + +XtransConnInfo +TRANS(OpenCOTSClient) (const char *address) + +{ + prmsg (2,"OpenCOTSClient(%s)\n", address); + return TRANS(Open) (XTRANS_OPEN_COTS_CLIENT, address); +} + +#endif /* TRANS_CLIENT */ + + +#ifdef TRANS_SERVER + +XtransConnInfo +TRANS(OpenCOTSServer) (const char *address) + +{ + prmsg (2,"OpenCOTSServer(%s)\n", address); + return TRANS(Open) (XTRANS_OPEN_COTS_SERVER, address); +} + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_REOPEN + +XtransConnInfo +TRANS(ReopenCOTSServer) (int trans_id, int fd, const char *port) + +{ + prmsg (2,"ReopenCOTSServer(%d, %d, %s)\n", trans_id, fd, port); + return TRANS(Reopen) (XTRANS_OPEN_COTS_SERVER, trans_id, fd, port); +} + +int +TRANS(GetReopenInfo) (XtransConnInfo ciptr, + int *trans_id, int *fd, char **port) + +{ + for (unsigned int i = 0; i < NUMTRANS; i++) + { + if (Xtransports[i].transport == ciptr->transptr) + { + *trans_id = Xtransports[i].transport_id; + *fd = ciptr->fd; + + if ((*port = strdup (ciptr->port)) == NULL) + return 0; + else + return 1; + } + } + + return 0; +} + +#endif /* TRANS_REOPEN */ + + +int +TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) + +{ + int fd = ciptr->fd; + int ret = 0; + + prmsg (2,"SetOption(%d,%d,%d)\n", fd, option, arg); + + /* + * For now, all transport type use the same stuff for setting options. + * As long as this is true, we can put the common code here. Once a more + * complicated transport such as shared memory or an OSI implementation + * that uses the session and application libraries is implemented, this + * code may have to move to a transport dependent function. + * + * ret = ciptr->transptr->SetOption (ciptr, option, arg); + */ + + switch (option) + { + case TRANS_NONBLOCKING: + switch (arg) + { + case 0: + /* Set to blocking mode */ + break; + case 1: /* Set to non-blocking mode */ + +#if defined(O_NONBLOCK) + ret = fcntl (fd, F_GETFL, 0); + if (ret != -1) + ret = fcntl (fd, F_SETFL, ret | O_NONBLOCK); +#else +#ifdef FIOSNBIO + { + int arg; + arg = 1; + ret = ioctl (fd, FIOSNBIO, &arg); + } +#else +#if defined(WIN32) + { +#ifdef WIN32 + u_long arg; +#else + int arg; +#endif + arg = 1; +/* IBM TCP/IP understands this option too well: it causes TRANS(Read) to fail + * eventually with EWOULDBLOCK */ + ret = ioctl (fd, FIONBIO, &arg); + } +#else + ret = fcntl (fd, F_GETFL, 0); +#ifdef FNDELAY + ret = fcntl (fd, F_SETFL, ret | FNDELAY); +#else + ret = fcntl (fd, F_SETFL, ret | O_NDELAY); +#endif +#endif /* AIXV3 || uniosu */ +#endif /* FIOSNBIO */ +#endif /* O_NONBLOCK */ + break; + default: + /* Unknown option */ + break; + } + break; + case TRANS_CLOSEONEXEC: +#ifdef F_SETFD +#ifdef FD_CLOEXEC + ret = fcntl (fd, F_SETFD, FD_CLOEXEC); +#else + ret = fcntl (fd, F_SETFD, 1); +#endif /* FD_CLOEXEC */ +#endif /* F_SETFD */ + break; + } + + return ret; +} + +#ifdef TRANS_SERVER + +int +TRANS(CreateListener) (XtransConnInfo ciptr, const char *port, unsigned int flags) + +{ + return ciptr->transptr->CreateListener (ciptr, port, flags); +} + +int +TRANS(Received) (const char * protocol) + +{ + Xtransport *trans; + int i = 0, ret = 0; + + prmsg (5, "Received(%s)\n", protocol); + + if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + { + prmsg (1,"Received: unable to find transport: %s\n", + protocol); + + return -1; + } + if (trans->flags & TRANS_ALIAS) { + if (trans->nolisten) + while (trans->nolisten[i]) { + ret |= TRANS(Received)(trans->nolisten[i]); + i++; + } + } + + trans->flags |= TRANS_RECEIVED; + return ret; +} + +int +TRANS(NoListen) (const char * protocol) + +{ + Xtransport *trans; + int i = 0, ret = 0; + + if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + { + prmsg (1,"TransNoListen: unable to find transport: %s\n", + protocol); + + return -1; + } + if (trans->flags & TRANS_ALIAS) { + if (trans->nolisten) + while (trans->nolisten[i]) { + ret |= TRANS(NoListen)(trans->nolisten[i]); + i++; + } + } + + trans->flags |= TRANS_NOLISTEN; + return ret; +} + +int +TRANS(Listen) (const char * protocol) +{ + Xtransport *trans; + int i = 0, ret = 0; + + if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + { + prmsg (1,"TransListen: unable to find transport: %s\n", + protocol); + + return -1; + } + if (trans->flags & TRANS_ALIAS) { + if (trans->nolisten) + while (trans->nolisten[i]) { + ret |= TRANS(Listen)(trans->nolisten[i]); + i++; + } + } + + trans->flags &= ~TRANS_NOLISTEN; + return ret; +} + +int +TRANS(IsListening) (const char * protocol) +{ + Xtransport *trans; + + if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + { + prmsg (1,"TransIsListening: unable to find transport: %s\n", + protocol); + + return 0; + } + + return !(trans->flags & TRANS_NOLISTEN); +} + +int +TRANS(ResetListener) (XtransConnInfo ciptr) + +{ + if (ciptr->transptr->ResetListener) + return ciptr->transptr->ResetListener (ciptr); + else + return TRANS_RESET_NOOP; +} + + +XtransConnInfo +TRANS(Accept) (XtransConnInfo ciptr, int *status) + +{ + XtransConnInfo newciptr; + + prmsg (2,"Accept(%d)\n", ciptr->fd); + + newciptr = ciptr->transptr->Accept (ciptr, status); + + if (newciptr) + newciptr->transptr = ciptr->transptr; + + return newciptr; +} + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_CLIENT + +int +TRANS(Connect) (XtransConnInfo ciptr, const char *address) + +{ + char *protocol; + char *host; + char *port; + int ret; + + prmsg (2,"Connect(%d,%s)\n", ciptr->fd, address); + + if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0) + { + prmsg (1,"Connect: Unable to Parse address %s\n", + address); + return -1; + } + +#ifdef HAVE_LAUNCHD + if (!host) host=strdup(""); +#endif + + if (!port || !*port) + { + prmsg (1,"Connect: Missing port specification in %s\n", + address); + if (protocol) free (protocol); + if (host) free (host); + return -1; + } + + ret = ciptr->transptr->Connect (ciptr, host, port); + + if (protocol) free (protocol); + if (host) free (host); + if (port) free (port); + + return ret; +} + +#endif /* TRANS_CLIENT */ + + +int +TRANS(BytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) + +{ + return ciptr->transptr->BytesReadable (ciptr, pend); +} + +int +TRANS(Read) (XtransConnInfo ciptr, char *buf, int size) + +{ + return ciptr->transptr->Read (ciptr, buf, size); +} + +int +TRANS(Write) (XtransConnInfo ciptr, const char *buf, int size) + +{ + return ciptr->transptr->Write (ciptr, buf, size); +} + +int +TRANS(Readv) (XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + return ciptr->transptr->Readv (ciptr, buf, size); +} + +int +TRANS(Writev) (XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + return ciptr->transptr->Writev (ciptr, buf, size); +} + +#if XTRANS_SEND_FDS +int +TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close) +{ + return ciptr->transptr->SendFd(ciptr, fd, do_close); +} + +int +TRANS(RecvFd) (XtransConnInfo ciptr) +{ + return ciptr->transptr->RecvFd(ciptr); +} +#endif + +int +TRANS(Disconnect) (XtransConnInfo ciptr) + +{ + return ciptr->transptr->Disconnect (ciptr); +} + +int +TRANS(Close) (XtransConnInfo ciptr) + +{ + int ret; + + prmsg (2,"Close(%d)\n", ciptr->fd); + + ret = ciptr->transptr->Close (ciptr); + + TRANS(FreeConnInfo) (ciptr); + + return ret; +} + +int +TRANS(CloseForCloning) (XtransConnInfo ciptr) + +{ + int ret; + + prmsg (2,"CloseForCloning(%d)\n", ciptr->fd); + + ret = ciptr->transptr->CloseForCloning (ciptr); + + TRANS(FreeConnInfo) (ciptr); + + return ret; +} + +int +TRANS(IsLocal) (XtransConnInfo ciptr) + +{ + return (ciptr->family == AF_UNIX); +} + +int +TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp, + Xtransaddr **addrp) + +{ + prmsg (2,"GetPeerAddr(%d)\n", ciptr->fd); + + *familyp = ciptr->family; + *addrlenp = ciptr->peeraddrlen; + + if ((*addrp = malloc (ciptr->peeraddrlen)) == NULL) + { + prmsg (1,"GetPeerAddr: malloc failed\n"); + return -1; + } + memcpy(*addrp, ciptr->peeraddr, ciptr->peeraddrlen); + + return 0; +} + + +int +TRANS(GetConnectionNumber) (XtransConnInfo ciptr) + +{ + return ciptr->fd; +} + + +/* + * These functions are really utility functions, but they require knowledge + * of the internal data structures, so they have to be part of the Transport + * Independent API. + */ + +#ifdef TRANS_SERVER + +static int +complete_network_count (void) + +{ + int count = 0; + int found_local = 0; + + /* + * For a complete network, we only need one LOCALCONN transport to work + */ + + for (unsigned int i = 0; i < NUMTRANS; i++) + { + if (Xtransports[i].transport->flags & TRANS_ALIAS + || Xtransports[i].transport->flags & TRANS_NOLISTEN) + continue; + + if (Xtransports[i].transport->flags & TRANS_LOCAL) + found_local = 1; + else + count++; + } + + return (count + found_local); +} + + +static int +receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs, + int* count_ret) + +{ +#ifdef HAVE_SYSTEMD_DAEMON + XtransConnInfo ciptr; + int i, systemd_listen_fds; + + systemd_listen_fds = sd_listen_fds(1); + if (systemd_listen_fds < 0) + { + prmsg (1, "receive_listening_fds: sd_listen_fds error: %s\n", + strerror(-systemd_listen_fds)); + return -1; + } + + for (i = 0; i < systemd_listen_fds && *count_ret < (int)NUMTRANS; i++) + { + struct sockaddr_storage a; + int ti; + const char* tn; + socklen_t al; + + al = sizeof(a); + if (getsockname(i + SD_LISTEN_FDS_START, (struct sockaddr*)&a, &al) < 0) { + prmsg (1, "receive_listening_fds: getsockname error: %s\n", + strerror(errno)); + return -1; + } + + switch (a.ss_family) + { + case AF_UNIX: + ti = TRANS_SOCKET_UNIX_INDEX; + if (*((struct sockaddr_un*)&a)->sun_path == '\0' && + al > sizeof(sa_family_t)) + tn = "local"; + else + tn = "unix"; + break; + case AF_INET: + ti = TRANS_SOCKET_INET_INDEX; + tn = "inet"; + break; +#ifdef IPv6 + case AF_INET6: + ti = TRANS_SOCKET_INET6_INDEX; + tn = "inet6"; + break; +#endif /* IPv6 */ + default: + prmsg (1, "receive_listening_fds:" + "Got unknown socket address family\n"); + return -1; + } + + ciptr = TRANS(ReopenCOTSServer)(ti, i + SD_LISTEN_FDS_START, port); + if (!ciptr) + { + prmsg (1, "receive_listening_fds:" + "Got NULL while trying to reopen socket received from systemd.\n"); + return -1; + } + + prmsg (5, "receive_listening_fds: received listener for %s, %d\n", + tn, ciptr->fd); + temp_ciptrs[(*count_ret)++] = ciptr; + TRANS(Received)(tn); + } +#endif /* HAVE_SYSTEMD_DAEMON */ + return 0; +} + +#ifdef XQUARTZ_EXPORTS_LAUNCHD_FD +extern int xquartz_launchd_fd; +#endif + +int +TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, + int *count_ret, XtransConnInfo **ciptrs_ret) + +{ + char buffer[256]; /* ??? What size ?? */ + XtransConnInfo ciptr, temp_ciptrs[NUMTRANS] = { NULL }; + int status, j; + +#ifdef IPv6 + int ipv6_succ = 0; +#endif + prmsg (2,"MakeAllCOTSServerListeners(%s,%p)\n", + port ? port : "NULL", (void *) ciptrs_ret); + + *count_ret = 0; + +#ifdef XQUARTZ_EXPORTS_LAUNCHD_FD + fprintf(stderr, "Launchd socket fd: %d\n", xquartz_launchd_fd); + if(xquartz_launchd_fd != -1) { + if((ciptr = TRANS(ReopenCOTSServer(TRANS_SOCKET_LOCAL_INDEX, + xquartz_launchd_fd, getenv("DISPLAY"))))==NULL) + fprintf(stderr,"Got NULL while trying to Reopen launchd port\n"); + else + temp_ciptrs[(*count_ret)++] = ciptr; + } +#endif + + if (receive_listening_fds(port, temp_ciptrs, count_ret) < 0) + return -1; + + for (unsigned int i = 0; i < NUMTRANS; i++) + { + Xtransport *trans = Xtransports[i].transport; + unsigned int flags = 0; + + if (trans->flags&TRANS_ALIAS || trans->flags&TRANS_NOLISTEN || + trans->flags&TRANS_RECEIVED) + continue; + + snprintf(buffer, sizeof(buffer), "%s/:%s", + trans->TransName, port ? port : ""); + + prmsg (5,"MakeAllCOTSServerListeners: opening %s\n", + buffer); + + if ((ciptr = TRANS(OpenCOTSServer(buffer))) == NULL) + { + if (trans->flags & TRANS_DISABLED) + continue; + + prmsg (1, + "MakeAllCOTSServerListeners: failed to open listener for %s\n", + trans->TransName); + continue; + } +#ifdef IPv6 + if ((Xtransports[i].transport_id == TRANS_SOCKET_INET_INDEX + && ipv6_succ)) + flags |= ADDR_IN_USE_ALLOWED; +#endif + + if ((status = TRANS(CreateListener (ciptr, port, flags))) < 0) + { + if (*partial != 0) + continue; + + if (status == TRANS_ADDR_IN_USE) + { + /* + * We failed to bind to the specified address because the + * address is in use. It must be that a server is already + * running at this address, and this function should fail. + */ + + prmsg (1, + "MakeAllCOTSServerListeners: server already running\n"); + + for (j = 0; j < *count_ret; j++) + if (temp_ciptrs[j] != NULL) + TRANS(Close) (temp_ciptrs[j]); + + *count_ret = 0; + *ciptrs_ret = NULL; + *partial = 0; + return -1; + } + else + { + prmsg (1, + "MakeAllCOTSServerListeners: failed to create listener for %s\n", + trans->TransName); + + continue; + } + } + +#ifdef IPv6 + if (Xtransports[i].transport_id == TRANS_SOCKET_INET6_INDEX) + ipv6_succ = 1; +#endif + + prmsg (5, + "MakeAllCOTSServerListeners: opened listener for %s, %d\n", + trans->TransName, ciptr->fd); + + temp_ciptrs[*count_ret] = ciptr; + (*count_ret)++; + } + + *partial = (*count_ret < complete_network_count()); + + prmsg (5, + "MakeAllCOTSServerListeners: partial=%d, actual=%d, complete=%d \n", + *partial, *count_ret, complete_network_count()); + + if (*count_ret > 0) + { + if ((*ciptrs_ret = malloc ( + *count_ret * sizeof (XtransConnInfo))) == NULL) + { + return -1; + } + + for (int i = 0; i < *count_ret; i++) + { + (*ciptrs_ret)[i] = temp_ciptrs[i]; + } + } + else + *ciptrs_ret = NULL; + + return 0; +} + +#endif /* TRANS_SERVER */ + + + +/* + * These routines are not part of the X Transport Interface, but they + * may be used by it. + */ + + +#ifdef WIN32 + +/* + * emulate readv + */ + +static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) + +{ + int i, len, total; + char *base; + + ESET(0); + for (i = 0, total = 0; i < iovcnt; i++, iov++) { + len = iov->iov_len; + base = iov->iov_base; + while (len > 0) { + register int nbytes; + nbytes = TRANS(Read) (ciptr, base, len); + if (nbytes < 0 && total == 0) return -1; + if (nbytes <= 0) return total; + ESET(0); + len -= nbytes; + total += nbytes; + base += nbytes; + } + } + return total; +} + + +/* + * emulate writev + */ + +static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) + +{ + int i, len, total; + char *base; + + ESET(0); + for (i = 0, total = 0; i < iovcnt; i++, iov++) { + len = iov->iov_len; + base = iov->iov_base; + while (len > 0) { + register int nbytes; + nbytes = TRANS(Write) (ciptr, base, len); + if (nbytes < 0 && total == 0) return -1; + if (nbytes <= 0) return total; + ESET(0); + len -= nbytes; + total += nbytes; + base += nbytes; + } + } + return total; +} + +#endif /* WIN32 */ + + +#if defined(_POSIX_SOURCE) || defined(SVR4) || defined(__SVR4) +#ifndef NEED_UTSNAME +#define NEED_UTSNAME +#endif +#include +#endif + +/* + * TRANS(GetHostname) - similar to gethostname but allows special processing. + */ + +int TRANS(GetHostname) (char *buf, int maxlen) + +{ + int len; + +#ifdef NEED_UTSNAME + struct utsname name; + + uname (&name); + len = strlen (name.nodename); + if (len >= maxlen) len = maxlen - 1; + memcpy (buf, name.nodename, len); + buf[len] = '\0'; +#else + buf[0] = '\0'; + (void) gethostname (buf, maxlen); + buf [maxlen - 1] = '\0'; + len = strlen(buf); +#endif /* NEED_UTSNAME */ + return len; +} diff --git a/os/Xtrans.h b/os/Xtrans.h new file mode 100644 index 000000000..8cf0dafc0 --- /dev/null +++ b/os/Xtrans.h @@ -0,0 +1,422 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XTRANS_H_ +#define _XTRANS_H_ + +#include +#include +#include + +#ifndef WIN32 +#include +#endif + +#ifdef __clang__ +/* Not all clients make use of all provided statics */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-function" +#endif + +/* + * Set the functions names according to where this code is being compiled. + */ + +#ifdef X11_t +#define TRANS(func) _X11Trans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_X11Trans"; +#endif +#endif /* X11_t */ + +#ifdef XSERV_t +#define TRANS(func) _XSERVTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_XSERVTrans"; +#endif +#define X11_t +#endif /* XSERV_t */ + +#ifdef XIM_t +#define TRANS(func) _XimXTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_XimTrans"; +#endif +#endif /* XIM_t */ + +#ifdef FS_t +#define TRANS(func) _FSTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_FSTrans"; +#endif +#endif /* FS_t */ + +#ifdef FONT_t +#define TRANS(func) _FontTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_FontTrans"; +#endif +#endif /* FONT_t */ + +#ifdef ICE_t +#define TRANS(func) _IceTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_IceTrans"; +#endif +#endif /* ICE_t */ + +#if !defined(TRANS) +#define TRANS(func) _XTrans##func +#ifdef XTRANSDEBUG +static const char *__xtransname = "_XTrans"; +#endif +#endif /* !TRANS */ + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +/* + * Create a single address structure that can be used wherever + * an address structure is needed. struct sockaddr is not big enough + * to hold a sockadd_un, so we create this definition to have a single + * structure that is big enough for all the structures we might need. + * + * This structure needs to be independent of the socket/TLI interface used. + */ + +/* Temporary workaround for consumers whose configure scripts were + generated with pre-1.6 versions of xtrans.m4 */ +#if defined(IPv6) && !defined(HAVE_STRUCT_SOCKADDR_STORAGE) +#define HAVE_STRUCT_SOCKADDR_STORAGE +#endif + +#ifdef HAVE_STRUCT_SOCKADDR_STORAGE +typedef struct sockaddr_storage Xtransaddr; +#else +#define XTRANS_MAX_ADDR_LEN 128 /* large enough to hold sun_path */ + +typedef struct { + unsigned char addr[XTRANS_MAX_ADDR_LEN]; +} Xtransaddr; +#endif + +#ifdef LONG64 +typedef int BytesReadable_t; +#else +typedef long BytesReadable_t; +#endif + + +#if defined(WIN32) + +/* + * TRANS(Readv) and TRANS(Writev) use struct iovec, normally found + * in Berkeley systems in . See the readv(2) and writev(2) + * manual pages for details. + */ + +struct iovec { + caddr_t iov_base; + int iov_len; +}; + +#else +#include +#endif + +typedef struct _XtransConnInfo *XtransConnInfo; + + +/* + * Transport Option definitions + */ + +#define TRANS_NONBLOCKING 1 +#define TRANS_CLOSEONEXEC 2 + + +/* + * Return values of Connect (0 is success) + */ + +#define TRANS_CONNECT_FAILED -1 +#define TRANS_TRY_CONNECT_AGAIN -2 +#define TRANS_IN_PROGRESS -3 + + +/* + * Return values of CreateListener (0 is success) + */ + +#define TRANS_CREATE_LISTENER_FAILED -1 +#define TRANS_ADDR_IN_USE -2 + + +/* + * Return values of Accept (0 is success) + */ + +#define TRANS_ACCEPT_BAD_MALLOC -1 +#define TRANS_ACCEPT_FAILED -2 +#define TRANS_ACCEPT_MISC_ERROR -3 + + +/* + * ResetListener return values + */ + +#define TRANS_RESET_NOOP 1 +#define TRANS_RESET_NEW_FD 2 +#define TRANS_RESET_FAILURE 3 + + +/* + * Function prototypes for the exposed interface + */ + +void TRANS(FreeConnInfo) ( + XtransConnInfo /* ciptr */ +); + +#ifdef TRANS_CLIENT + +XtransConnInfo TRANS(OpenCOTSClient)( + const char * /* address */ +); + +#endif /* TRANS_CLIENT */ + +#ifdef TRANS_SERVER + +XtransConnInfo TRANS(OpenCOTSServer)( + const char * /* address */ +); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_REOPEN + +XtransConnInfo TRANS(ReopenCOTSServer)( + int, /* trans_id */ + int, /* fd */ + const char * /* port */ +); + +int TRANS(GetReopenInfo)( + XtransConnInfo, /* ciptr */ + int *, /* trans_id */ + int *, /* fd */ + char ** /* port */ +); + +#endif /* TRANS_REOPEN */ + + +int TRANS(SetOption)( + XtransConnInfo, /* ciptr */ + int, /* option */ + int /* arg */ +); + +#ifdef TRANS_SERVER + +int TRANS(CreateListener)( + XtransConnInfo, /* ciptr */ + const char *, /* port */ + unsigned int /* flags */ +); + +int TRANS(Received) ( + const char* /* protocol*/ +); + +int TRANS(NoListen) ( + const char* /* protocol*/ +); + +int TRANS(Listen) ( + const char* /* protocol*/ +); + +int TRANS(IsListening) ( + const char* /* protocol*/ +); + +int TRANS(ResetListener)( + XtransConnInfo /* ciptr */ +); + +XtransConnInfo TRANS(Accept)( + XtransConnInfo, /* ciptr */ + int * /* status */ +); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_CLIENT + +int TRANS(Connect)( + XtransConnInfo, /* ciptr */ + const char * /* address */ +); + +#endif /* TRANS_CLIENT */ + +int TRANS(BytesReadable)( + XtransConnInfo, /* ciptr */ + BytesReadable_t * /* pend */ +); + +int TRANS(Read)( + XtransConnInfo, /* ciptr */ + char *, /* buf */ + int /* size */ +); + +int TRANS(Write)( + XtransConnInfo, /* ciptr */ + const char *, /* buf */ + int /* size */ +); + +int TRANS(Readv)( + XtransConnInfo, /* ciptr */ + struct iovec *, /* buf */ + int /* size */ +); + +int TRANS(Writev)( + XtransConnInfo, /* ciptr */ + struct iovec *, /* buf */ + int /* size */ +); + +int TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close); + +int TRANS(RecvFd) (XtransConnInfo ciptr); + +int TRANS(Disconnect)( + XtransConnInfo /* ciptr */ +); + +int TRANS(Close)( + XtransConnInfo /* ciptr */ +); + +int TRANS(CloseForCloning)( + XtransConnInfo /* ciptr */ +); + +int TRANS(IsLocal)( + XtransConnInfo /* ciptr */ +); + +int TRANS(GetPeerAddr)( + XtransConnInfo, /* ciptr */ + int *, /* familyp */ + int *, /* addrlenp */ + Xtransaddr ** /* addrp */ +); + +int TRANS(GetConnectionNumber)( + XtransConnInfo /* ciptr */ +); + +#ifdef TRANS_SERVER + +int TRANS(MakeAllCOTSServerListeners)( + const char *, /* port */ + int *, /* partial */ + int *, /* count_ret */ + XtransConnInfo ** /* ciptrs_ret */ +); + +#endif /* TRANS_SERVER */ + + +/* + * Function Prototypes for Utility Functions. + */ + +#ifdef X11_t + +int TRANS(ConvertAddress)( + int *, /* familyp */ + int *, /* addrlenp */ + Xtransaddr ** /* addrp */ +); + +#endif /* X11_t */ + +#ifdef ICE_t + +char * +TRANS(GetMyNetworkId)( + XtransConnInfo /* ciptr */ +); + +char * +TRANS(GetPeerNetworkId)( + XtransConnInfo /* ciptr */ +); + +#endif /* ICE_t */ + +int +TRANS(GetHostname) ( + char * /* buf */, + int /* maxlen */ +); + +#if defined(WIN32) && defined(TCPCONN) +int TRANS(WSAStartup)(); +#endif + +#endif /* _XTRANS_H_ */ diff --git a/os/Xtransint.h b/os/Xtransint.h new file mode 100644 index 000000000..82c8755c8 --- /dev/null +++ b/os/Xtransint.h @@ -0,0 +1,430 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XTRANSINT_H_ +#define _XTRANSINT_H_ + +/* + * XTRANSDEBUG will enable the PRMSG() macros used in the X Transport + * Interface code. Each use of the PRMSG macro has a level associated with + * it. XTRANSDEBUG is defined to be a level. If the invocation level is =< + * the value of XTRANSDEBUG, then the message will be printed out to stderr. + * Recommended levels are: + * + * XTRANSDEBUG=1 Error messages + * XTRANSDEBUG=2 API Function Tracing + * XTRANSDEBUG=3 All Function Tracing + * XTRANSDEBUG=4 printing of intermediate values + * XTRANSDEBUG=5 really detailed stuff +#define XTRANSDEBUG 2 + * + * Defining XTRANSDEBUGTIMESTAMP will cause printing timestamps with each + * message. + */ + +#if !defined(XTRANSDEBUG) && defined(XTRANS_TRANSPORT_C) +# define XTRANSDEBUG 1 +#endif + +#ifdef WIN32 +# define _WILLWINSOCK_ +#endif + +#include "Xtrans.h" + +#ifndef _X_UNUSED /* Defined in Xfuncproto.h in xproto >= 7.0.22 */ +# define _X_UNUSED /* */ +#endif + +#ifdef XTRANSDEBUG +# include +#endif /* XTRANSDEBUG */ + +#include + +#ifndef WIN32 +# include +# include +# include + +/* + * Moved the setting of NEED_UTSNAME to this header file from Xtrans.c, + * to avoid a race condition. JKJ (6/5/97) + */ + +# if defined(_POSIX_SOURCE) || defined(SVR4) || defined(__SVR4) +# ifndef NEED_UTSNAME +# define NEED_UTSNAME +# endif +# include +# endif + +# define ESET(val) errno = val +# define EGET() errno + +#else /* WIN32 */ + +# include /* for USHRT_MAX */ + +# define ESET(val) WSASetLastError(val) +# define EGET() WSAGetLastError() + +#endif /* WIN32 */ + +#include + +#ifdef X11_t +#define X_TCP_PORT 6000 +#endif + +#if XTRANS_SEND_FDS + +struct _XtransConnFd { + struct _XtransConnFd *next; + int fd; + int do_close; +}; + +#endif + +struct _XtransConnInfo { + struct _Xtransport *transptr; + int index; + char *priv; + int flags; + int fd; + char *port; + int family; + char *addr; + int addrlen; + char *peeraddr; + int peeraddrlen; + struct _XtransConnFd *recv_fds; + struct _XtransConnFd *send_fds; +}; + +#define XTRANS_OPEN_COTS_CLIENT 1 +#define XTRANS_OPEN_COTS_SERVER 2 + +typedef struct _Xtransport { + const char *TransName; + int flags; + +#ifdef TRANS_CLIENT + + XtransConnInfo (*OpenCOTSClient)( + struct _Xtransport *, /* transport */ + const char *, /* protocol */ + const char *, /* host */ + const char * /* port */ + ); + +#endif /* TRANS_CLIENT */ + +#ifdef TRANS_SERVER + const char ** nolisten; + XtransConnInfo (*OpenCOTSServer)( + struct _Xtransport *, /* transport */ + const char *, /* protocol */ + const char *, /* host */ + const char * /* port */ + ); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_REOPEN + + XtransConnInfo (*ReopenCOTSServer)( + struct _Xtransport *, /* transport */ + int, /* fd */ + const char * /* port */ + ); + +#endif /* TRANS_REOPEN */ + + + int (*SetOption)( + XtransConnInfo, /* connection */ + int, /* option */ + int /* arg */ + ); + +#ifdef TRANS_SERVER +/* Flags */ +# define ADDR_IN_USE_ALLOWED 1 + + int (*CreateListener)( + XtransConnInfo, /* connection */ + const char *, /* port */ + unsigned int /* flags */ + ); + + int (*ResetListener)( + XtransConnInfo /* connection */ + ); + + XtransConnInfo (*Accept)( + XtransConnInfo, /* connection */ + int * /* status */ + ); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_CLIENT + + int (*Connect)( + XtransConnInfo, /* connection */ + const char *, /* host */ + const char * /* port */ + ); + +#endif /* TRANS_CLIENT */ + + int (*BytesReadable)( + XtransConnInfo, /* connection */ + BytesReadable_t * /* pend */ + ); + + int (*Read)( + XtransConnInfo, /* connection */ + char *, /* buf */ + int /* size */ + ); + + int (*Write)( + XtransConnInfo, /* connection */ + const char *, /* buf */ + int /* size */ + ); + + int (*Readv)( + XtransConnInfo, /* connection */ + struct iovec *, /* buf */ + int /* size */ + ); + + int (*Writev)( + XtransConnInfo, /* connection */ + struct iovec *, /* buf */ + int /* size */ + ); + +#if XTRANS_SEND_FDS + int (*SendFd)( + XtransConnInfo, /* connection */ + int, /* fd */ + int /* do_close */ + ); + + int (*RecvFd)( + XtransConnInfo /* connection */ + ); +#endif + + int (*Disconnect)( + XtransConnInfo /* connection */ + ); + + int (*Close)( + XtransConnInfo /* connection */ + ); + + int (*CloseForCloning)( + XtransConnInfo /* connection */ + ); + +} Xtransport; + + +typedef struct _Xtransport_table { + Xtransport *transport; + int transport_id; +} Xtransport_table; + + +/* + * Flags for the flags member of Xtransport. + */ + +#define TRANS_ALIAS (1<<0) /* record is an alias, don't create server */ +#define TRANS_LOCAL (1<<1) /* local transport */ +#define TRANS_DISABLED (1<<2) /* Don't open this one */ +#define TRANS_NOLISTEN (1<<3) /* Don't listen on this one */ +#define TRANS_NOUNLINK (1<<4) /* Don't unlink transport endpoints */ +#define TRANS_ABSTRACT (1<<5) /* This previously meant that abstract sockets should be used available. For security + * reasons, this is now a no-op on the client side, but it is still supported for servers. + */ +#define TRANS_NOXAUTH (1<<6) /* Don't verify authentication (because it's secure some other way at the OS layer) */ +#define TRANS_RECEIVED (1<<7) /* The fd for this has already been opened by someone else. */ + +/* Flags to preserve when setting others */ +#define TRANS_KEEPFLAGS (TRANS_NOUNLINK|TRANS_ABSTRACT) + +#ifdef XTRANS_TRANSPORT_C /* only provide static function prototypes when + building the transport.c file that has them in */ + +#ifdef __clang__ +/* Not all clients make use of all provided statics */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunused-function" +#endif + +/* + * readv() and writev() don't exist or don't work correctly on some + * systems, so they may be emulated. + */ + +#ifdef WIN32 + +#define READV(ciptr, iov, iovcnt) TRANS(ReadV)(ciptr, iov, iovcnt) + +static int TRANS(ReadV)( + XtransConnInfo, /* ciptr */ + struct iovec *, /* iov */ + int /* iovcnt */ +); + +#else + +#define READV(ciptr, iov, iovcnt) readv(ciptr->fd, iov, iovcnt) + +#endif /* WIN32 */ + + +#ifdef WIN32 + +#define WRITEV(ciptr, iov, iovcnt) TRANS(WriteV)(ciptr, iov, iovcnt) + +static int TRANS(WriteV)( + XtransConnInfo, /* ciptr */ + struct iovec *, /* iov */ + int /* iovcnt */ +); + +#else + +#define WRITEV(ciptr, iov, iovcnt) writev(ciptr->fd, iov, iovcnt) + +#endif /* WIN32 */ + +#ifdef TRANS_SERVER +static int trans_mkdir ( + const char *, /* path */ + int /* mode */ +); +#endif + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +/* + * Some XTRANSDEBUG stuff + */ + +#ifdef XTRANSDEBUG +#include + +/* + * The X server and the font server both provide ErrorF() & VErrorF(). For + * other software that uses xtrans, we provide our own simple + * versions. + */ +# if (defined(XSERV_t) || defined(TRANS_HAS_ERRORF)) && defined(TRANS_SERVER) +# include "os.h" +# else +static inline void _X_ATTRIBUTE_PRINTF(1, 0) +VErrorF(const char *f, va_list args) +{ + vfprintf(stderr, f, args); + fflush(stderr); +} + +static inline void _X_ATTRIBUTE_PRINTF(1, 2) +ErrorF(const char *f, ...) +{ + va_list args; + + va_start(args, f); + VErrorF(f, args); + va_end(args); +} +# endif /* xserver */ +#endif /* XTRANSDEBUG */ + +static inline void _X_ATTRIBUTE_PRINTF(2, 3) +prmsg(int lvl, const char *f, ...) +{ +#ifdef XTRANSDEBUG + va_list args; + + va_start(args, f); + if (lvl <= XTRANSDEBUG) { + int saveerrno = errno; + + ErrorF("%s", __xtransname); + VErrorF(f, args); + +# ifdef XTRANSDEBUGTIMESTAMP + { + struct timeval tp; + gettimeofday(&tp, 0); + ErrorF("timestamp (ms): %d\n", + tp.tv_sec * 1000 + tp.tv_usec / 1000); + } +# endif + errno = saveerrno; + } + va_end(args); +#endif /* XTRANSDEBUG */ +} + +#endif /* XTRANS_TRANSPORT_C */ + +#endif /* _XTRANSINT_H_ */ diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c new file mode 100644 index 000000000..ba33bce38 --- /dev/null +++ b/os/Xtranslcl.c @@ -0,0 +1,1462 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * + * The connection code/ideas in lib/X and server/os for SVR4/Intel + * environments was contributed by the following companies/groups: + * + * MetroLink Inc + * NCR + * Pittsburgh Powercomputing Corporation (PPc)/Quarterdeck Office Systems + * SGCS + * Unix System Laboratories (USL) / Novell + * XFree86 + * + * The goal is to have common connection code among all SVR4/Intel vendors. + * + * ALL THE ABOVE COMPANIES DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, + * IN NO EVENT SHALL THESE COMPANIES * BE LIABLE FOR ANY SPECIAL, INDIRECT + * OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE + * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE + * OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include +#if defined(SVR4) || defined(__SVR4) +#include +#endif +# include +#include +#include + +/* + * The local transports should be treated the same as a UNIX domain socket + * wrt authentication, etc. Because of this, we will use struct sockaddr_un + * for the address format. This will simplify the code in other places like + * The X Server. + */ + +#include +#ifndef X_NO_SYS_UN +#include +#endif + + +/* Types of local connections supported: + * - PTS + * - named pipes + */ +#if defined(SVR4) || defined(__SVR4) +# define LOCAL_TRANS_NAMED +#endif + +static int TRANS(LocalClose)(XtransConnInfo ciptr); + +/* + * These functions actually implement the local connection mechanisms. + */ + +/* Type Not Supported */ + +static int +TRANS(OpenFail)(XtransConnInfo ciptr _X_UNUSED, const char *port _X_UNUSED) + +{ + return -1; +} + +#ifdef TRANS_REOPEN + +static int +TRANS(ReopenFail)(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED, + const char *port _X_UNUSED) + +{ + return 0; +} + +#endif /* TRANS_REOPEN */ + +#if XTRANS_SEND_FDS +static int +TRANS(LocalRecvFdInvalid)(XtransConnInfo ciptr) +{ + errno = EINVAL; + return -1; +} + +static int +TRANS(LocalSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close) +{ + errno = EINVAL; + return -1; +} +#endif + + +static int +TRANS(FillAddrInfo)(XtransConnInfo ciptr, + const char *sun_path, const char *peer_sun_path) + +{ + struct sockaddr_un *sunaddr; + struct sockaddr_un *p_sunaddr; + + ciptr->family = AF_UNIX; + ciptr->addrlen = sizeof (struct sockaddr_un); + + if ((sunaddr = malloc (ciptr->addrlen)) == NULL) + { + prmsg(1,"FillAddrInfo: failed to allocate memory for addr\n"); + return 0; + } + + sunaddr->sun_family = AF_UNIX; + + if (strlen(sun_path) > sizeof(sunaddr->sun_path) - 1) { + prmsg(1, "FillAddrInfo: path too long\n"); + free((char *) sunaddr); + return 0; + } + strcpy (sunaddr->sun_path, sun_path); +#if defined(BSD44SOCKETS) + sunaddr->sun_len = strlen (sunaddr->sun_path); +#endif + + ciptr->addr = (char *) sunaddr; + + ciptr->peeraddrlen = sizeof (struct sockaddr_un); + + if ((p_sunaddr = malloc (ciptr->peeraddrlen)) == NULL) + { + prmsg(1, + "FillAddrInfo: failed to allocate memory for peer addr\n"); + free (sunaddr); + ciptr->addr = NULL; + + return 0; + } + + p_sunaddr->sun_family = AF_UNIX; + + if (strlen(peer_sun_path) > sizeof(p_sunaddr->sun_path) - 1) { + prmsg(1, "FillAddrInfo: peer path too long\n"); + free((char *) p_sunaddr); + return 0; + } + strcpy (p_sunaddr->sun_path, peer_sun_path); +#if defined(BSD44SOCKETS) + p_sunaddr->sun_len = strlen (p_sunaddr->sun_path); +#endif + + ciptr->peeraddr = (char *) p_sunaddr; + + return 1; +} + + + + +#ifndef X11_t +#define X_STREAMS_DIR "/dev/X" +#else +#define X_STREAMS_DIR "/tmp/.X11-pipe" +#endif + +#define DEV_PTMX "/dev/ptmx" + +#if defined(X11_t) + +#define NAMEDNODENAME "/tmp/.X11-pipe/X" +#endif +#if defined(XIM_t) +#define NAMEDNODENAME "/tmp/.XIM-pipe/XIM" +#endif +#if defined(FS_t) || defined (FONT_t) +#define NAMEDNODENAME "/tmp/.font-pipe/fs" +#endif +#if defined(ICE_t) +#define NAMEDNODENAME "/tmp/.ICE-pipe/" +#endif + + + + + +#ifdef LOCAL_TRANS_NAMED + +/* NAMED */ + +#ifdef TRANS_CLIENT + +static int +TRANS(NAMEDOpenClient)(XtransConnInfo ciptr, const char *port) + +{ +#ifdef NAMEDNODENAME + int fd; + char server_path[64]; + struct stat filestat; +#endif + + prmsg(2,"NAMEDOpenClient(%s)\n", port); + +#if !defined(NAMEDNODENAME) + prmsg(1,"NAMEDOpenClient: Protocol is not supported by a NAMED connection\n"); + return -1; +#else + if ( port && *port ) { + if( *port == '/' ) { /* A full pathname */ + (void) snprintf(server_path, sizeof(server_path), "%s", port); + } else { + (void) snprintf(server_path, sizeof(server_path), "%s%s", NAMEDNODENAME, port); + } + } else { + (void) snprintf(server_path, sizeof(server_path), "%s%ld", NAMEDNODENAME, (long)getpid()); + } + + if ((fd = open(server_path, O_RDWR)) < 0) { + prmsg(1,"NAMEDOpenClient: Cannot open %s for NAMED connection\n", server_path); + return -1; + } + + if (fstat(fd, &filestat) < 0 ) { + prmsg(1,"NAMEDOpenClient: Cannot stat %s for NAMED connection\n", server_path); + (void) close(fd); + return -1; + } + + if ((filestat.st_mode & S_IFMT) != S_IFIFO) { + prmsg(1,"NAMEDOpenClient: Device %s is not a FIFO\n", server_path); + /* Is this really a failure? */ + (void) close(fd); + return -1; + } + + + if (isastream(fd) <= 0) { + prmsg(1,"NAMEDOpenClient: %s is not a streams device\n", server_path); + (void) close(fd); + return -1; + } + + /* + * Everything looks good: fill in the XtransConnInfo structure. + */ + + if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) + { + prmsg(1,"NAMEDOpenClient: failed to fill in addr info\n"); + close(fd); + return -1; + } + + return(fd); + +#endif /* !NAMEDNODENAME */ +} + +#endif /* TRANS_CLIENT */ + + +#ifdef TRANS_SERVER + + +#ifdef NAMEDNODENAME +static int +TRANS(NAMEDOpenPipe)(const char *server_path) +{ + int fd, pipefd[2]; + struct stat sbuf; + int mode; + + prmsg(2,"NAMEDOpenPipe(%s)\n", server_path); + +#ifdef HAS_STICKY_DIR_BIT + mode = 01777; +#else + mode = 0777; +#endif + if (trans_mkdir(X_STREAMS_DIR, mode) == -1) { + prmsg (1, "NAMEDOpenPipe: mkdir(%s) failed, errno = %d\n", + X_STREAMS_DIR, errno); + return(-1); + } + + if(stat(server_path, &sbuf) != 0) { + if (errno == ENOENT) { + if ((fd = creat(server_path, (mode_t)0666)) == -1) { + prmsg(1, "NAMEDOpenPipe: Can't open %s\n", server_path); + return(-1); + } + if (fchmod(fd, (mode_t)0666) < 0) { + prmsg(1, "NAMEDOpenPipe: Can't chmod %s\n", server_path); + close(fd); + return(-1); + } + close(fd); + } else { + prmsg(1, "NAMEDOpenPipe: stat on %s failed\n", server_path); + return(-1); + } + } + + if( pipe(pipefd) != 0) { + prmsg(1, "NAMEDOpenPipe: pipe() failed, errno=%d\n",errno); + return(-1); + } + + if( ioctl(pipefd[0], I_PUSH, "connld") != 0) { + prmsg(1, "NAMEDOpenPipe: ioctl(I_PUSH,\"connld\") failed, errno=%d\n",errno); + close(pipefd[0]); + close(pipefd[1]); + return(-1); + } + + if( fattach(pipefd[0], server_path) != 0) { + prmsg(1, "NAMEDOpenPipe: fattach(%s) failed, errno=%d\n", server_path,errno); + close(pipefd[0]); + close(pipefd[1]); + return(-1); + } + + return(pipefd[1]); +} +#endif + +static int +TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) +{ +#ifdef NAMEDNODENAME + int fd; + char server_path[64]; +#endif + + prmsg(2,"NAMEDOpenServer(%s)\n", port); + +#if !defined(NAMEDNODENAME) + prmsg(1,"NAMEDOpenServer: Protocol is not supported by a NAMED connection\n"); + return -1; +#else + if ( port && *port ) { + if( *port == '/' ) { /* A full pathname */ + (void) snprintf(server_path, sizeof(server_path), "%s", port); + } else { + (void) snprintf(server_path, sizeof(server_path), "%s%s", + NAMEDNODENAME, port); + } + } else { + (void) snprintf(server_path, sizeof(server_path), "%s%ld", + NAMEDNODENAME, (long)getpid()); + } + + fd = TRANS(NAMEDOpenPipe)(server_path); + if (fd < 0) { + return -1; + } + + /* + * Everything looks good: fill in the XtransConnInfo structure. + */ + + if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) + { + prmsg(1,"NAMEDOpenServer: failed to fill in addr info\n"); + TRANS(LocalClose)(ciptr); + return -1; + } + + return fd; + +#endif /* !NAMEDNODENAME */ +} + +static int +TRANS(NAMEDResetListener) (XtransConnInfo ciptr) + +{ + struct sockaddr_un *sockname=(struct sockaddr_un *) ciptr->addr; + struct stat statb; + + prmsg(2,"NAMEDResetListener(%p, %d)\n", (void *) ciptr, ciptr->fd); + + if (ciptr->fd != -1) { + /* + * see if the pipe has disappeared + */ + + if (stat (sockname->sun_path, &statb) == -1 || + (statb.st_mode & S_IFMT) != S_IFIFO) { + prmsg(3, "Pipe %s trashed, recreating\n", sockname->sun_path); + TRANS(LocalClose)(ciptr); + ciptr->fd = TRANS(NAMEDOpenPipe)(sockname->sun_path); + if (ciptr->fd >= 0) + return TRANS_RESET_NEW_FD; + else + return TRANS_CREATE_LISTENER_FAILED; + } + } + return TRANS_RESET_NOOP; +} + +static int +TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) + +{ + struct strrecvfd str; + + prmsg(2,"NAMEDAccept(%p->%d)\n", (void *) ciptr, ciptr->fd); + + if( ioctl(ciptr->fd, I_RECVFD, &str ) < 0 ) { + prmsg(1, "NAMEDAccept: ioctl(I_RECVFD) failed, errno=%d\n", errno); + *status = TRANS_ACCEPT_MISC_ERROR; + return(-1); + } + + /* + * Everything looks good: fill in the XtransConnInfo structure. + */ + newciptr->family=ciptr->family; + newciptr->addrlen=ciptr->addrlen; + if( (newciptr->addr = malloc(newciptr->addrlen)) == NULL ) { + prmsg(1, + "NAMEDAccept: failed to allocate memory for pipe addr\n"); + close(str.fd); + *status = TRANS_ACCEPT_BAD_MALLOC; + return -1; + } + + memcpy(newciptr->addr,ciptr->addr,newciptr->addrlen); + + newciptr->peeraddrlen=newciptr->addrlen; + if( (newciptr->peeraddr = malloc(newciptr->peeraddrlen)) == NULL ) { + prmsg(1, + "NAMEDAccept: failed to allocate memory for peer addr\n"); + free(newciptr->addr); + close(str.fd); + *status = TRANS_ACCEPT_BAD_MALLOC; + return -1; + } + + memcpy(newciptr->peeraddr,newciptr->addr,newciptr->peeraddrlen); + + *status = 0; + + return str.fd; +} + +#endif /* TRANS_SERVER */ + +#endif /* LOCAL_TRANS_NAMED */ + + + + + + + + + + +#ifdef TRANS_REOPEN + +#ifdef LOCAL_TRANS_NAMED + +static int +TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *port) + +{ +#ifdef NAMEDNODENAME + char server_path[64]; +#endif + + prmsg(2,"NAMEDReopenServer(%s)\n", port); + +#if !defined(NAMEDNODENAME) + prmsg(1,"NAMEDReopenServer: Protocol is not supported by a NAMED connection\n"); + return 0; +#else + if ( port && *port ) { + if( *port == '/' ) { /* A full pathname */ + snprintf(server_path, sizeof(server_path),"%s", port); + } else { + snprintf(server_path, sizeof(server_path), "%s%s", + NAMEDNODENAME, port); + } + } else { + snprintf(server_path, sizeof(server_path), "%s%ld", + NAMEDNODENAME, (long)getpid()); + } + + if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) + { + prmsg(1,"NAMEDReopenServer: failed to fill in addr info\n"); + return 0; + } + + return 1; + +#endif /* !NAMEDNODENAME */ +} + +#endif /* LOCAL_TRANS_NAMED */ + + + +#endif /* TRANS_REOPEN */ + + + +/* + * This table contains all of the entry points for the different local + * connection mechanisms. + */ + +typedef struct _LOCALtrans2dev { + const char *transname; + +#ifdef TRANS_CLIENT + + int (*devcotsopenclient)( + XtransConnInfo, const char * /*port*/ +); + +#endif /* TRANS_CLIENT */ + +#ifdef TRANS_SERVER + + int (*devcotsopenserver)( + XtransConnInfo, const char * /*port*/ +); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_CLIENT + + int (*devcltsopenclient)( + XtransConnInfo, const char * /*port*/ +); + +#endif /* TRANS_CLIENT */ + +#ifdef TRANS_SERVER + + int (*devcltsopenserver)( + XtransConnInfo, const char * /*port*/ +); + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_REOPEN + + int (*devcotsreopenserver)( + XtransConnInfo, + int, /* fd */ + const char * /* port */ +); + + int (*devcltsreopenserver)( + XtransConnInfo, + int, /* fd */ + const char * /* port */ +); + +#endif /* TRANS_REOPEN */ + +#ifdef TRANS_SERVER + + int (*devreset)( + XtransConnInfo /* ciptr */ +); + + int (*devaccept)( + XtransConnInfo, XtransConnInfo, int * +); + +#endif /* TRANS_SERVER */ + +} LOCALtrans2dev; + +static LOCALtrans2dev LOCALtrans2devtab[] = { +{"", +#ifdef TRANS_CLIENT + TRANS(NAMEDOpenClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(NAMEDOpenServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(OpenFail), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(OpenFail), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(NAMEDReopenServer), + TRANS(ReopenFail), +#endif +#ifdef TRANS_SERVER + TRANS(NAMEDResetListener), + TRANS(NAMEDAccept) +#endif /* TRANS_SERVER */ +}, + +{"local", +#ifdef TRANS_CLIENT + TRANS(NAMEDOpenClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(NAMEDOpenServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(OpenFail), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(OpenFail), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(NAMEDReopenServer), + TRANS(ReopenFail), +#endif +#ifdef TRANS_SERVER + TRANS(NAMEDResetListener), + TRANS(NAMEDAccept) +#endif /* TRANS_SERVER */ +}, + +#ifdef LOCAL_TRANS_NAMED +{"named", +#ifdef TRANS_CLIENT + TRANS(NAMEDOpenClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(NAMEDOpenServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(OpenFail), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(OpenFail), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(NAMEDReopenServer), + TRANS(ReopenFail), +#endif +#ifdef TRANS_SERVER + TRANS(NAMEDResetListener), + TRANS(NAMEDAccept) +#endif /* TRANS_SERVER */ +}, + +{"pipe", +#ifdef TRANS_CLIENT + TRANS(NAMEDOpenClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(NAMEDOpenServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(OpenFail), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + TRANS(OpenFail), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(NAMEDReopenServer), + TRANS(ReopenFail), +#endif +#ifdef TRANS_SERVER + TRANS(NAMEDResetListener), + TRANS(NAMEDAccept) +#endif /* TRANS_SERVER */ +}, +#endif /* LOCAL_TRANS_NAMED */ + + +}; + +#define NUMTRANSPORTS (sizeof(LOCALtrans2devtab)/sizeof(LOCALtrans2dev)) + +static const char *XLOCAL=NULL; +static char *workingXLOCAL=NULL; +static char *freeXLOCAL=NULL; + +#define DEF_XLOCAL "UNIX:NAMED" + +static void +TRANS(LocalInitTransports)(const char *protocol) + +{ + prmsg(3,"LocalInitTransports(%s)\n", protocol); + + if( strcmp(protocol,"local") && strcmp(protocol,"LOCAL") ) + { + workingXLOCAL = freeXLOCAL = strdup (protocol); + } + else { + XLOCAL = getenv("XLOCAL"); + if(XLOCAL==NULL) + XLOCAL=DEF_XLOCAL; + workingXLOCAL = freeXLOCAL = strdup (XLOCAL); + } +} + +static void +TRANS(LocalEndTransports)(void) + +{ + prmsg(3,"LocalEndTransports()\n"); + free(freeXLOCAL); + freeXLOCAL = NULL; +} + +#define TYPEBUFSIZE 32 + +#ifdef TRANS_CLIENT + +static LOCALtrans2dev * +TRANS(LocalGetNextTransport)(void) + +{ + char *typetocheck; + prmsg(3,"LocalGetNextTransport()\n"); + + while(1) + { + if( workingXLOCAL == NULL || *workingXLOCAL == '\0' ) + return NULL; + + typetocheck=workingXLOCAL; + workingXLOCAL=strchr(workingXLOCAL,':'); + if(workingXLOCAL && *workingXLOCAL) + *workingXLOCAL++='\0'; + + for (unsigned int i = 0; i < NUMTRANSPORTS; i++) + { +#ifndef HAVE_STRCASECMP + int j; + char typebuf[TYPEBUFSIZE]; + /* + * This is equivalent to a case insensitive strcmp(), + * but should be more portable. + */ + strncpy(typebuf,typetocheck,TYPEBUFSIZE); + for(j=0;j +#endif + +/* + * Make sure 'host' is really local. + */ + +static int +HostReallyLocal (const char *host) + +{ + /* + * The 'host' passed to this function may have been generated + * by either uname() or gethostname(). We try both if possible. + */ + +#ifdef NEED_UTSNAME + struct utsname name; +#endif + char buf[256]; + +#ifdef NEED_UTSNAME + if (uname (&name) >= 0 && strcmp (host, name.nodename) == 0) + return (1); +#endif + + buf[0] = '\0'; + (void) gethostname (buf, 256); + buf[255] = '\0'; + + if (strcmp (host, buf) == 0) + return (1); + + return (0); +} + + +static XtransConnInfo +TRANS(LocalOpenClient)(int type, const char *protocol, + const char *host, const char *port) + +{ + LOCALtrans2dev *transptr; + XtransConnInfo ciptr; + int index; + + prmsg(3,"LocalOpenClient()\n"); + + /* + * Make sure 'host' is really local. If not, we return failure. + * The reason we make this check is because a process may advertise + * a "local" address for which it can accept connections, but if a + * process on a remote machine tries to connect to this address, + * we know for sure it will fail. + */ + + if (strcmp (host, "unix") != 0 && !HostReallyLocal (host)) + { + prmsg (1, + "LocalOpenClient: Cannot connect to non-local host %s\n", + host); + return NULL; + } + + +#if defined(X11_t) + /* + * X has a well known port, that is transport dependent. It is easier + * to handle it here, than try and come up with a transport independent + * representation that can be passed in and resolved the usual way. + * + * The port that is passed here is really a string containing the idisplay + * from ConnectDisplay(). Since that is what we want for the local transports, + * we don't have to do anything special. + */ +#endif /* X11_t */ + + if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) + { + prmsg(1,"LocalOpenClient: calloc(1,%lu) failed\n", + sizeof(struct _XtransConnInfo)); + return NULL; + } + + ciptr->fd = -1; + + TRANS(LocalInitTransports)(protocol); + + index = 0; + for(transptr=TRANS(LocalGetNextTransport)(); + transptr!=NULL;transptr=TRANS(LocalGetNextTransport)(), index++) + { + switch( type ) + { + case XTRANS_OPEN_COTS_CLIENT: + ciptr->fd=transptr->devcotsopenclient(ciptr,port); + break; + case XTRANS_OPEN_COTS_SERVER: + prmsg(1, + "LocalOpenClient: Should not be opening a server with this function\n"); + break; + default: + prmsg(1, + "LocalOpenClient: Unknown Open type %d\n", + type); + } + if( ciptr->fd >= 0 ) + break; + } + + TRANS(LocalEndTransports)(); + + if( ciptr->fd < 0 ) + { + free(ciptr); + return NULL; + } + + ciptr->priv=(char *)transptr; + ciptr->index = index; + + return ciptr; +} + +#endif /* TRANS_CLIENT */ + + +#ifdef TRANS_SERVER + +static XtransConnInfo +TRANS(LocalOpenServer)(int type, const char *protocol, + const char *host _X_UNUSED, const char *port) + +{ + XtransConnInfo ciptr; + + prmsg(2,"LocalOpenServer(%d,%s,%s)\n", type, protocol, port); + +#if defined(X11_t) + /* + * For X11, the port will be in the format xserverN where N is the + * display number. All of the local connections just need to know + * the display number because they don't do any name resolution on + * the port. This just truncates port to the display portion. + */ +#endif /* X11_t */ + + if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) + { + prmsg(1,"LocalOpenServer: calloc(1,%lu) failed\n", + sizeof(struct _XtransConnInfo)); + return NULL; + } + + for (unsigned int i = 1; i < NUMTRANSPORTS; i++) + { + if( strcmp(protocol,LOCALtrans2devtab[i].transname) != 0 ) + continue; + switch( type ) + { + case XTRANS_OPEN_COTS_CLIENT: + prmsg(1, + "LocalOpenServer: Should not be opening a client with this function\n"); + break; + case XTRANS_OPEN_COTS_SERVER: + ciptr->fd=LOCALtrans2devtab[i].devcotsopenserver(ciptr,port); + break; + default: + prmsg(1,"LocalOpenServer: Unknown Open type %d\n", + type ); + } + if( ciptr->fd >= 0 ) { + ciptr->priv=(char *)&LOCALtrans2devtab[i]; + ciptr->index=i; + ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS); + return ciptr; + } + } + + free(ciptr); + return NULL; +} + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_REOPEN + +static XtransConnInfo +TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) + +{ + XtransConnInfo ciptr; + int stat = 0; + + prmsg(2,"LocalReopenServer(%d,%d,%d)\n", type, index, fd); + + if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) + { + prmsg(1,"LocalReopenServer: calloc(1,%lu) failed\n", + sizeof(struct _XtransConnInfo)); + return NULL; + } + + ciptr->fd = fd; + + switch( type ) + { + case XTRANS_OPEN_COTS_SERVER: + stat = LOCALtrans2devtab[index].devcotsreopenserver(ciptr,fd,port); + break; + default: + prmsg(1,"LocalReopenServer: Unknown Open type %d\n", + type ); + } + + if( stat > 0 ) { + ciptr->priv=(char *)&LOCALtrans2devtab[index]; + ciptr->index=index; + ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS); + return ciptr; + } + + free(ciptr); + return NULL; +} + +#endif /* TRANS_REOPEN */ + + + +/* + * This is the Local implementation of the X Transport service layer + */ + +#ifdef TRANS_CLIENT + +static XtransConnInfo +TRANS(LocalOpenCOTSClient)(Xtransport *thistrans _X_UNUSED, const char *protocol, + const char *host, const char *port) + +{ + prmsg(2,"LocalOpenCOTSClient(%s,%s,%s)\n",protocol,host,port); + + return TRANS(LocalOpenClient)(XTRANS_OPEN_COTS_CLIENT, protocol, host, port); +} + +#endif /* TRANS_CLIENT */ + + +#ifdef TRANS_SERVER + +static XtransConnInfo +TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, + const char *host, const char *port) + +{ + char *typetocheck = NULL; + int found = 0; + + prmsg(2,"LocalOpenCOTSServer(%s,%s,%s)\n",protocol,host,port); + + /* Check if this local type is in the XLOCAL list */ + TRANS(LocalInitTransports)("local"); + typetocheck = workingXLOCAL; + while (typetocheck && !found) { +#ifndef HAVE_STRCASECMP + int j; + char typebuf[TYPEBUFSIZE]; +#endif + + workingXLOCAL = strchr(workingXLOCAL, ':'); + if (workingXLOCAL && *workingXLOCAL) + *workingXLOCAL++ = '\0'; +#ifndef HAVE_STRCASECMP + strncpy(typebuf, typetocheck, TYPEBUFSIZE); + for (j = 0; j < TYPEBUFSIZE; j++) + if (isupper(typebuf[j])) + typebuf[j] = tolower(typebuf[j]); + if (!strcmp(thistrans->TransName, typebuf)) +#else + if (!strcasecmp(thistrans->TransName, typetocheck)) +#endif + found = 1; + typetocheck = workingXLOCAL; + } + TRANS(LocalEndTransports)(); + + if (!found) { + prmsg(3,"LocalOpenCOTSServer: disabling %s\n",thistrans->TransName); + thistrans->flags |= TRANS_DISABLED; + return NULL; + } + + return TRANS(LocalOpenServer)(XTRANS_OPEN_COTS_SERVER, protocol, host, port); +} + +#endif /* TRANS_SERVER */ + +#ifdef TRANS_REOPEN + +static XtransConnInfo +TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port) + +{ + unsigned int index; + + prmsg(2,"LocalReopenCOTSServer(%d,%s)\n", fd, port); + + for(index=1;indexTransName, + LOCALtrans2devtab[index].transname) == 0 ) + break; + } + + if (index >= NUMTRANSPORTS) + { + return (NULL); + } + + return TRANS(LocalReopenServer)(XTRANS_OPEN_COTS_SERVER, + index, fd, port); +} + +#endif /* TRANS_REOPEN */ + + + +static int +TRANS(LocalSetOption)(XtransConnInfo ciptr, int option, int arg) + +{ + prmsg(2,"LocalSetOption(%d,%d,%d)\n",ciptr->fd,option,arg); + + return -1; +} + + +#ifdef TRANS_SERVER + +static int +TRANS(LocalCreateListener)(XtransConnInfo ciptr, const char *port, + unsigned int flags _X_UNUSED) + +{ + prmsg(2,"LocalCreateListener(%p->%d,%s)\n", (void *) ciptr, ciptr->fd, port); + + return 0; +} + +static int +TRANS(LocalResetListener)(XtransConnInfo ciptr) + +{ + LOCALtrans2dev *transptr; + + prmsg(2,"LocalResetListener(%p)\n", (void *) ciptr); + + transptr=(LOCALtrans2dev *)ciptr->priv; + if (transptr->devreset != NULL) { + return transptr->devreset(ciptr); + } + return TRANS_RESET_NOOP; +} + + +static XtransConnInfo +TRANS(LocalAccept)(XtransConnInfo ciptr, int *status) + +{ + XtransConnInfo newciptr; + LOCALtrans2dev *transptr; + + prmsg(2,"LocalAccept(%p->%d)\n", (void *) ciptr, ciptr->fd); + + transptr=(LOCALtrans2dev *)ciptr->priv; + + if( (newciptr = calloc(1,sizeof(struct _XtransConnInfo)))==NULL ) + { + prmsg(1,"LocalAccept: calloc(1,%lu) failed\n", + sizeof(struct _XtransConnInfo)); + *status = TRANS_ACCEPT_BAD_MALLOC; + return NULL; + } + + newciptr->fd=transptr->devaccept(ciptr,newciptr,status); + + if( newciptr->fd < 0 ) + { + free(newciptr); + return NULL; + } + + newciptr->priv=(char *)transptr; + newciptr->index = ciptr->index; + + *status = 0; + + return newciptr; +} + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_CLIENT + +static int +TRANS(LocalConnect)(XtransConnInfo ciptr, + const char *host _X_UNUSED, const char *port) + +{ + prmsg(2,"LocalConnect(%p->%d,%s)\n", (void *) ciptr, ciptr->fd, port); + + return 0; +} + +#endif /* TRANS_CLIENT */ + + +static int +TRANS(LocalBytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend ) + +{ + prmsg(2,"LocalBytesReadable(%p->%d,%p)\n", + (void *) ciptr, ciptr->fd, (void *) pend); + + return ioctl(ciptr->fd, FIONREAD, (char *)pend); +} + +static int +TRANS(LocalRead)(XtransConnInfo ciptr, char *buf, int size) + +{ + prmsg(2,"LocalRead(%d,%p,%d)\n", ciptr->fd, (void *) buf, size ); + + return read(ciptr->fd,buf,size); +} + +static int +TRANS(LocalWrite)(XtransConnInfo ciptr, const char *buf, int size) + +{ + prmsg(2,"LocalWrite(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size ); + + return write(ciptr->fd,buf,size); +} + +static int +TRANS(LocalReadv)(XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + prmsg(2,"LocalReadv(%d,%p,%d)\n", ciptr->fd, (void *) buf, size ); + + return READV(ciptr,buf,size); +} + +static int +TRANS(LocalWritev)(XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + prmsg(2,"LocalWritev(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size ); + + return WRITEV(ciptr,buf,size); +} + +static int +TRANS(LocalDisconnect)(XtransConnInfo ciptr) + +{ + prmsg(2,"LocalDisconnect(%p->%d)\n", (void *) ciptr, ciptr->fd); + + return 0; +} + +static int +TRANS(LocalClose)(XtransConnInfo ciptr) + +{ + struct sockaddr_un *sockname=(struct sockaddr_un *) ciptr->addr; + int ret; + + prmsg(2,"LocalClose(%p->%d)\n", (void *) ciptr, ciptr->fd ); + + ret=close(ciptr->fd); + + if(ciptr->flags + && sockname + && sockname->sun_family == AF_UNIX + && sockname->sun_path[0] ) + { + if (!(ciptr->flags & TRANS_NOUNLINK)) + unlink(sockname->sun_path); + } + + return ret; +} + +static int +TRANS(LocalCloseForCloning)(XtransConnInfo ciptr) + +{ + int ret; + + prmsg(2,"LocalCloseForCloning(%p->%d)\n", (void *) ciptr, ciptr->fd ); + + /* Don't unlink path */ + + ret=close(ciptr->fd); + + return ret; +} + + +/* + * MakeAllCOTSServerListeners() will go through the entire Xtransports[] + * array defined in Xtrans.c and try to OpenCOTSServer() for each entry. + * We will add duplicate entries to that table so that the OpenCOTSServer() + * function will get called once for each type of local transport. + * + * The TransName is in lowercase, so it will never match during a normal + * call to SelectTransport() in Xtrans.c. + */ + +#ifdef TRANS_SERVER +static const char * local_aliases[] = { + "named", + "pipe", /* compatibility with Solaris Xlib */ + NULL }; +#endif + +static Xtransport TRANS(LocalFuncs) = { + /* Local Interface */ + "local", + TRANS_ALIAS | TRANS_LOCAL, +#ifdef TRANS_CLIENT + TRANS(LocalOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + local_aliases, + TRANS(LocalOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(LocalReopenCOTSServer), +#endif + TRANS(LocalSetOption), +#ifdef TRANS_SERVER + TRANS(LocalCreateListener), + TRANS(LocalResetListener), + TRANS(LocalAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(LocalConnect), +#endif /* TRANS_CLIENT */ + TRANS(LocalBytesReadable), + TRANS(LocalRead), + TRANS(LocalWrite), + TRANS(LocalReadv), + TRANS(LocalWritev), +#if XTRANS_SEND_FDS + TRANS(LocalSendFdInvalid), + TRANS(LocalRecvFdInvalid), +#endif + TRANS(LocalDisconnect), + TRANS(LocalClose), + TRANS(LocalCloseForCloning), +}; + + +#ifdef LOCAL_TRANS_NAMED + +static Xtransport TRANS(NAMEDFuncs) = { + /* Local Interface */ + "named", + TRANS_LOCAL, +#ifdef TRANS_CLIENT + TRANS(LocalOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + NULL, + TRANS(LocalOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(LocalReopenCOTSServer), +#endif + TRANS(LocalSetOption), +#ifdef TRANS_SERVER + TRANS(LocalCreateListener), + TRANS(LocalResetListener), + TRANS(LocalAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(LocalConnect), +#endif /* TRANS_CLIENT */ + TRANS(LocalBytesReadable), + TRANS(LocalRead), + TRANS(LocalWrite), + TRANS(LocalReadv), + TRANS(LocalWritev), +#if XTRANS_SEND_FDS + TRANS(LocalSendFdInvalid), + TRANS(LocalRecvFdInvalid), +#endif + TRANS(LocalDisconnect), + TRANS(LocalClose), + TRANS(LocalCloseForCloning), +}; + +static Xtransport TRANS(PIPEFuncs) = { + /* Local Interface */ + "pipe", + TRANS_ALIAS | TRANS_LOCAL, +#ifdef TRANS_CLIENT + TRANS(LocalOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + NULL, + TRANS(LocalOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(LocalReopenCOTSServer), +#endif + TRANS(LocalSetOption), +#ifdef TRANS_SERVER + TRANS(LocalCreateListener), + TRANS(LocalResetListener), + TRANS(LocalAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(LocalConnect), +#endif /* TRANS_CLIENT */ + TRANS(LocalBytesReadable), + TRANS(LocalRead), + TRANS(LocalWrite), + TRANS(LocalReadv), + TRANS(LocalWritev), +#if XTRANS_SEND_FDS + TRANS(LocalSendFdInvalid), + TRANS(LocalRecvFdInvalid), +#endif + TRANS(LocalDisconnect), + TRANS(LocalClose), + TRANS(LocalCloseForCloning), +}; +#endif /* LOCAL_TRANS_NAMED */ + + diff --git a/os/Xtranssock.c b/os/Xtranssock.c new file mode 100644 index 000000000..4c7f80bec --- /dev/null +++ b/os/Xtranssock.c @@ -0,0 +1,2585 @@ +/* + * Copyright (c) 2002, 2025, Oracle and/or its affiliates. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the copyright holders shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from the copyright holders. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#ifdef XTHREADS +#include +#endif + +#ifndef WIN32 + +#if defined(TCPCONN) || defined(UNIXCONN) +#include +#include +#include +#endif + +#if defined(TCPCONN) || defined(UNIXCONN) +#define X_INCLUDE_NETDB_H +#define XOS_USE_NO_LOCKING +#include +#endif + +#ifdef UNIXCONN +#ifndef X_NO_SYS_UN +#include +#endif +#include +#endif + + +#ifndef NO_TCP_H +#if defined(linux) || defined(__GLIBC__) +#include +#endif /* osf */ +#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) +#include +#include +#endif /* __NetBSD__ || __OpenBSD__ || __FreeBSD__ || __DragonFly__ */ +#include +#endif /* !NO_TCP_H */ + +#include +#if defined(SVR4) || defined(__SVR4) +#include +#endif + +#include + +#else /* !WIN32 */ + +#include +#include +#include +#undef close +#define close closesocket +#define ECONNREFUSED WSAECONNREFUSED +#define EADDRINUSE WSAEADDRINUSE +#define EPROTOTYPE WSAEPROTOTYPE +#undef EWOULDBLOCK +#define EWOULDBLOCK WSAEWOULDBLOCK +#define EINPROGRESS WSAEINPROGRESS +#undef EINTR +#define EINTR WSAEINTR +#define X_INCLUDE_NETDB_H +#define XOS_USE_MTSAFE_NETDBAPI +#include +#endif /* WIN32 */ + +#if defined(SO_DONTLINGER) && defined(SO_LINGER) +#undef SO_DONTLINGER +#endif + +/* others don't need this */ +#define SocketInitOnce() /**/ + +#ifdef __linux__ +#define HAVE_ABSTRACT_SOCKETS +#endif + +#define MIN_BACKLOG 128 +#ifdef SOMAXCONN +#if SOMAXCONN > MIN_BACKLOG +#define BACKLOG SOMAXCONN +#endif +#endif +#ifndef BACKLOG +#define BACKLOG MIN_BACKLOG +#endif + +#if defined(IPv6) && !defined(AF_INET6) +#error "Cannot build IPv6 support without AF_INET6" +#endif + +/* Temporary workaround for consumers whose configure scripts were + generated with pre-1.6 versions of xtrans.m4 */ +#if defined(IPv6) && !defined(HAVE_GETADDRINFO) +#define HAVE_GETADDRINFO +#endif + +/* + * This is the Socket implementation of the X Transport service layer + * + * This file contains the implementation for both the UNIX and INET domains, + * and can be built for either one, or both. + * + */ + +typedef struct _Sockettrans2dev { + const char *transname; + int family; + int devcotsname; + int devcltsname; + int protocol; +} Sockettrans2dev; + +/* As documented in the X(7) man page: + * tcp TCP over IPv4 or IPv6 + * inet TCP over IPv4 only + * inet6 TCP over IPv6 only + * unix UNIX Domain Sockets (same host only) + * local Platform preferred local connection method + */ +static Sockettrans2dev Sockettrans2devtab[] = { +#ifdef TCPCONN + {"inet",AF_INET,SOCK_STREAM,SOCK_DGRAM,0}, +#ifndef IPv6 + {"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0}, +#else /* IPv6 */ + {"tcp",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0}, + {"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0}, /* fallback */ + {"inet6",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0}, +#endif +#endif /* TCPCONN */ +#ifdef UNIXCONN + {"unix",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0}, +#if !defined(LOCALCONN) + {"local",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0}, +#endif /* !LOCALCONN */ +#endif /* UNIXCONN */ +}; + +#define NUMSOCKETFAMILIES (sizeof(Sockettrans2devtab)/sizeof(Sockettrans2dev)) + +#ifdef TCPCONN +static int TRANS(SocketINETClose) (XtransConnInfo ciptr); +#endif + +#if (defined(TCPCONN) && \ + (defined(TRANS_SERVER) || defined(X11_t) || !defined(HAVE_GETADDRINFO))) \ + || defined(TRANS_REOPEN) +static int +is_numeric (const char *str) +{ + int i; + + for (i = 0; i < (int) strlen (str); i++) + if (!isdigit (str[i])) + return (0); + + return (1); +} +#endif + +#ifdef UNIXCONN + + +#if defined(X11_t) +#define UNIX_PATH "/tmp/.X11-unix/X" +#define UNIX_DIR "/tmp/.X11-unix" +#endif /* X11_t */ +#if defined(XIM_t) +#define UNIX_PATH "/tmp/.XIM-unix/XIM" +#define UNIX_DIR "/tmp/.XIM-unix" +#endif /* XIM_t */ +#if defined(FS_t) || defined(FONT_t) +#define UNIX_PATH "/tmp/.font-unix/fs" +#define UNIX_DIR "/tmp/.font-unix" +#endif /* FS_t || FONT_t */ +#if defined(ICE_t) +#define UNIX_PATH "/tmp/.ICE-unix/" +#define UNIX_DIR "/tmp/.ICE-unix" +#endif /* ICE_t */ + + +#endif /* UNIXCONN */ + +#define PORTBUFSIZE 32 + +#ifndef MAXHOSTNAMELEN +#define MAXHOSTNAMELEN 255 +#endif + +#if defined(HAVE_SOCKLEN_T) || defined(IPv6) +# define SOCKLEN_T socklen_t +#elif defined(SVR4) || defined(__SVR4) +# define SOCKLEN_T size_t +#else +# define SOCKLEN_T int +#endif + +/* + * These are some utility function used by the real interface function below. + */ + +static int +TRANS(SocketSelectFamily) (int first, const char *family) + +{ + int i; + + prmsg (3,"SocketSelectFamily(%s)\n", family); + + for (i = first + 1; i < (int)NUMSOCKETFAMILIES; i++) + { + if (!strcmp (family, Sockettrans2devtab[i].transname)) + return i; + } + + return (first == -1 ? -2 : -1); +} + + +/* + * This function gets the local address of the socket and stores it in the + * XtransConnInfo structure for the connection. + */ + +static int +TRANS(SocketINETGetAddr) (XtransConnInfo ciptr) + +{ +#ifdef HAVE_STRUCT_SOCKADDR_STORAGE + struct sockaddr_storage sockname; +#else + struct sockaddr_in sockname; +#endif + void *socknamePtr = &sockname; + SOCKLEN_T namelen = sizeof(sockname); + + prmsg (3,"SocketINETGetAddr(%p)\n", (void *) ciptr); + + bzero(socknamePtr, namelen); + + if (getsockname (ciptr->fd,(struct sockaddr *) socknamePtr, + (void *)&namelen) < 0) + { +#ifdef WIN32 + errno = WSAGetLastError(); +#endif + prmsg (1,"SocketINETGetAddr: getsockname() failed: %d\n", + EGET()); + return -1; + } + + /* + * Everything looks good: fill in the XtransConnInfo structure. + */ + + if ((ciptr->addr = malloc (namelen)) == NULL) + { + prmsg (1, + "SocketINETGetAddr: Can't allocate space for the addr\n"); + return -1; + } + + ciptr->family = ((struct sockaddr *)socknamePtr)->sa_family; + ciptr->addrlen = namelen; + memcpy (ciptr->addr, socknamePtr, ciptr->addrlen); + + return 0; +} + + +/* + * This function gets the remote address of the socket and stores it in the + * XtransConnInfo structure for the connection. + */ + +static int +TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr) + +{ +#ifdef HAVE_STRUCT_SOCKADDR_STORAGE + struct sockaddr_storage sockname; +#else + struct sockaddr_in sockname; +#endif + void *socknamePtr = &sockname; + SOCKLEN_T namelen = sizeof(sockname); + + bzero(socknamePtr, namelen); + + prmsg (3,"SocketINETGetPeerAddr(%p)\n", (void *) ciptr); + + if (getpeername (ciptr->fd, (struct sockaddr *) socknamePtr, + (void *)&namelen) < 0) + { +#ifdef WIN32 + errno = WSAGetLastError(); +#endif + prmsg (1,"SocketINETGetPeerAddr: getpeername() failed: %d\n", + EGET()); + return -1; + } + + /* + * Everything looks good: fill in the XtransConnInfo structure. + */ + + if ((ciptr->peeraddr = malloc (namelen)) == NULL) + { + prmsg (1, + "SocketINETGetPeerAddr: Can't allocate space for the addr\n"); + return -1; + } + + ciptr->peeraddrlen = namelen; + memcpy (ciptr->peeraddr, socknamePtr, ciptr->peeraddrlen); + + return 0; +} + + +static XtransConnInfo +TRANS(SocketOpen) (int i, int type) + +{ + XtransConnInfo ciptr; + + prmsg (3,"SocketOpen(%d,%d)\n", i, type); + + if ((ciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL) + { + prmsg (1, "SocketOpen: malloc failed\n"); + return NULL; + } + + ciptr->fd = socket(Sockettrans2devtab[i].family, type, + Sockettrans2devtab[i].protocol); + +#ifndef WIN32 +#if (defined(X11_t) && !defined(USE_POLL)) || defined(FS_t) || defined(FONT_t) + if (ciptr->fd >= sysconf(_SC_OPEN_MAX)) + { + prmsg (2, "SocketOpen: socket() returned out of range fd %d\n", + ciptr->fd); + close (ciptr->fd); + ciptr->fd = -1; + } +#endif +#endif + + if (ciptr->fd < 0) { +#ifdef WIN32 + errno = WSAGetLastError(); +#endif + prmsg (2, "SocketOpen: socket() failed for %s\n", + Sockettrans2devtab[i].transname); + + free (ciptr); + return NULL; + } + +#ifdef TCP_NODELAY + if (Sockettrans2devtab[i].family == AF_INET +#ifdef IPv6 + || Sockettrans2devtab[i].family == AF_INET6 +#endif + ) + { + /* + * turn off TCP coalescence for INET sockets + */ + + int tmp = 1; + setsockopt (ciptr->fd, IPPROTO_TCP, TCP_NODELAY, + (char *) &tmp, sizeof (int)); + } +#endif + + /* + * Some systems provide a really small default buffer size for + * UNIX sockets. Bump it up a bit such that large transfers don't + * proceed at glacial speed. + */ +#ifdef SO_SNDBUF + if (Sockettrans2devtab[i].family == AF_UNIX) + { + SOCKLEN_T len = sizeof (int); + int val; + + if (getsockopt (ciptr->fd, SOL_SOCKET, SO_SNDBUF, + (char *) &val, &len) == 0 && val < 64 * 1024) + { + val = 64 * 1024; + setsockopt (ciptr->fd, SOL_SOCKET, SO_SNDBUF, + (char *) &val, sizeof (int)); + } + } +#endif + + return ciptr; +} + + +#ifdef TRANS_REOPEN + +static XtransConnInfo +TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) + +{ + XtransConnInfo ciptr; + int portlen; + struct sockaddr *addr; + size_t addrlen; + + prmsg (3,"SocketReopen(%d,%d,%s)\n", type, fd, port); + + if (port == NULL) { + prmsg (1, "SocketReopen: port was null!\n"); + return NULL; + } + + portlen = strlen(port) + 1; // include space for trailing null +#ifdef SOCK_MAXADDRLEN + if (portlen < 0 || portlen > (SOCK_MAXADDRLEN + 2)) { + prmsg (1, "SocketReopen: invalid portlen %d\n", portlen); + return NULL; + } + if (portlen < 14) portlen = 14; +#else + if (portlen < 0 || portlen > 14) { + prmsg (1, "SocketReopen: invalid portlen %d\n", portlen); + return NULL; + } +#endif /*SOCK_MAXADDRLEN*/ + + if ((ciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL) + { + prmsg (1, "SocketReopen: malloc(ciptr) failed\n"); + return NULL; + } + + ciptr->fd = fd; + + addrlen = portlen + offsetof(struct sockaddr, sa_data); + if ((addr = calloc (1, addrlen)) == NULL) { + prmsg (1, "SocketReopen: malloc(addr) failed\n"); + free (ciptr); + return NULL; + } + ciptr->addr = (char *) addr; + ciptr->addrlen = addrlen; + + if ((ciptr->peeraddr = calloc (1, addrlen)) == NULL) { + prmsg (1, "SocketReopen: malloc(portaddr) failed\n"); + free (addr); + free (ciptr); + return NULL; + } + ciptr->peeraddrlen = addrlen; + + /* Initialize ciptr structure as if it were a normally-opened unix socket */ + ciptr->flags = TRANS_LOCAL | TRANS_NOUNLINK; +#ifdef BSD44SOCKETS + addr->sa_len = addrlen; +#endif + addr->sa_family = AF_UNIX; +#if defined(HAVE_STRLCPY) || defined(HAS_STRLCPY) + strlcpy(addr->sa_data, port, portlen); +#else + strncpy(addr->sa_data, port, portlen); +#endif + ciptr->family = AF_UNIX; + memcpy(ciptr->peeraddr, ciptr->addr, addrlen); + ciptr->port = rindex(addr->sa_data, ':'); + if (ciptr->port == NULL) { + if (is_numeric(addr->sa_data)) { + ciptr->port = addr->sa_data; + } + } else if (ciptr->port[0] == ':') { + ciptr->port++; + } + /* port should now point to portnum or NULL */ + return ciptr; +} + +#endif /* TRANS_REOPEN */ + + +/* + * These functions are the interface supplied in the Xtransport structure + */ + +#ifdef TRANS_CLIENT + +static XtransConnInfo +TRANS(SocketOpenCOTSClientBase) (const char *transname, const char *protocol, + const char *host, const char *port, int previndex) +{ + XtransConnInfo ciptr = NULL; + int i = previndex; + + prmsg (2, "SocketOpenCOTSClient(%s,%s,%s)\n", + protocol, host, port); + + SocketInitOnce(); + + while ((i = TRANS(SocketSelectFamily) (i, transname)) >= 0) { + if ((ciptr = TRANS(SocketOpen) ( + i, Sockettrans2devtab[i].devcotsname)) != NULL) { + /* Save the index for later use */ + + ciptr->index = i; + break; + } + } + if (i < 0) { + if (i == -1) + prmsg (1,"SocketOpenCOTSClient: Unable to open socket for %s\n", + transname); + else + prmsg (1,"SocketOpenCOTSClient: Unable to determine socket type for %s\n", + transname); + return NULL; + } + + return ciptr; +} + +static XtransConnInfo +TRANS(SocketOpenCOTSClient) (Xtransport *thistrans, const char *protocol, + const char *host, const char *port) +{ + return TRANS(SocketOpenCOTSClientBase)( + thistrans->TransName, protocol, host, port, -1); +} + + +#endif /* TRANS_CLIENT */ + + +#ifdef TRANS_SERVER + +static XtransConnInfo +TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, + const char *host, const char *port) + +{ + XtransConnInfo ciptr = NULL; + int i = -1; + + prmsg (2,"SocketOpenCOTSServer(%s,%s,%s)\n", protocol, host, port); + + SocketInitOnce(); + + while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) { + if ((ciptr = TRANS(SocketOpen) ( + i, Sockettrans2devtab[i].devcotsname)) != NULL) + break; + } + if (i < 0) { + if (i == -1) { + if (errno == EAFNOSUPPORT) { + thistrans->flags |= TRANS_NOLISTEN; + prmsg (1,"SocketOpenCOTSServer: Socket for %s unsupported on this system.\n", + thistrans->TransName); + } else { + prmsg (1,"SocketOpenCOTSServer: Unable to open socket for %s\n", + thistrans->TransName); + } + } else { + prmsg (1,"SocketOpenCOTSServer: Unable to determine socket type for %s\n", + thistrans->TransName); + } + return NULL; + } + + /* + * Using this prevents the bind() check for an existing server listening + * on the same port, but it is required for other reasons. + */ +#ifdef SO_REUSEADDR + + /* + * SO_REUSEADDR only applied to AF_INET && AF_INET6 + */ + + if (Sockettrans2devtab[i].family == AF_INET +#ifdef IPv6 + || Sockettrans2devtab[i].family == AF_INET6 +#endif + ) + { + int one = 1; + setsockopt (ciptr->fd, SOL_SOCKET, SO_REUSEADDR, + (char *) &one, sizeof (int)); + } +#endif +#ifdef IPV6_V6ONLY + if (Sockettrans2devtab[i].family == AF_INET6) + { + int one = 1; + setsockopt(ciptr->fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(int)); + } +#endif + /* Save the index for later use */ + + ciptr->index = i; + + return ciptr; +} + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_REOPEN + +static XtransConnInfo +TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) + +{ + XtransConnInfo ciptr; + int i = -1; + + prmsg (2, + "SocketReopenCOTSServer(%d, %s)\n", fd, port); + + SocketInitOnce(); + + while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) { + if ((ciptr = TRANS(SocketReopen) ( + i, Sockettrans2devtab[i].devcotsname, fd, port)) != NULL) + break; + } + if (i < 0) { + if (i == -1) + prmsg (1,"SocketReopenCOTSServer: Unable to open socket for %s\n", + thistrans->TransName); + else + prmsg (1,"SocketReopenCOTSServer: Unable to determine socket type for %s\n", + thistrans->TransName); + return NULL; + } + + /* Save the index for later use */ + + ciptr->index = i; + + return ciptr; +} + +#endif /* TRANS_REOPEN */ + + +static int +TRANS(SocketSetOption) (XtransConnInfo ciptr, int option, int arg) + +{ + prmsg (2,"SocketSetOption(%d,%d,%d)\n", ciptr->fd, option, arg); + + return -1; +} + +#ifdef UNIXCONN +static int +set_sun_path(const char *port, const char *upath, char *path, int abstract) +{ + struct sockaddr_un s; + ssize_t maxlen = sizeof(s.sun_path) - 1; + const char *at = ""; + + if (!port || !*port || !path) + return -1; + +#ifdef HAVE_ABSTRACT_SOCKETS + if (port[0] == '@') + upath = ""; + else if (abstract) + at = "@"; +#endif + + if (*port == '/') /* a full pathname */ + upath = ""; + + if ((ssize_t)(strlen(at) + strlen(upath) + strlen(port)) > maxlen) + return -1; + snprintf(path, sizeof(s.sun_path), "%s%s%s", at, upath, port); + return 0; +} +#endif + +#ifdef TRANS_SERVER + +static int +TRANS(SocketCreateListener) (XtransConnInfo ciptr, + struct sockaddr *sockname, + int socknamelen, unsigned int flags) + +{ + SOCKLEN_T namelen = socknamelen; + int fd = ciptr->fd; + int retry; + + prmsg (3, "SocketCreateListener(%p,%d)\n", (void *) ciptr, fd); + + if (Sockettrans2devtab[ciptr->index].family == AF_INET +#ifdef IPv6 + || Sockettrans2devtab[ciptr->index].family == AF_INET6 +#endif + ) + retry = 20; + else + retry = 0; + + while (bind (fd, sockname, namelen) < 0) + { + if (errno == EADDRINUSE) { + if (flags & ADDR_IN_USE_ALLOWED) + break; + else + return TRANS_ADDR_IN_USE; + } + + if (retry-- == 0) { + prmsg (1, "SocketCreateListener: failed to bind listener\n"); + close (fd); + return TRANS_CREATE_LISTENER_FAILED; + } +#ifdef SO_REUSEADDR + sleep (1); +#else + sleep (10); +#endif /* SO_REUSEDADDR */ + } + + if (Sockettrans2devtab[ciptr->index].family == AF_INET +#ifdef IPv6 + || Sockettrans2devtab[ciptr->index].family == AF_INET6 +#endif + ) { +#ifdef SO_DONTLINGER + setsockopt (fd, SOL_SOCKET, SO_DONTLINGER, (char *) NULL, 0); +#else +#ifdef SO_LINGER + { + static int linger[2] = { 0, 0 }; + setsockopt (fd, SOL_SOCKET, SO_LINGER, + (char *) linger, sizeof (linger)); + } +#endif +#endif +} + + if (listen (fd, BACKLOG) < 0) + { + prmsg (1, "SocketCreateListener: listen() failed\n"); + close (fd); + return TRANS_CREATE_LISTENER_FAILED; + } + + /* Set a flag to indicate that this connection is a listener */ + + ciptr->flags = 1 | (ciptr->flags & TRANS_KEEPFLAGS); + + return 0; +} + +#ifdef TCPCONN +static int +TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, + unsigned int flags) + +{ +#ifdef HAVE_STRUCT_SOCKADDR_STORAGE + struct sockaddr_storage sockname; +#else + struct sockaddr_in sockname; +#endif + unsigned short sport; + SOCKLEN_T namelen = sizeof(sockname); + int status; + long tmpport; +#ifdef XTHREADS_NEEDS_BYNAMEPARAMS + _Xgetservbynameparams sparams; +#endif + struct servent *servp; + +#ifdef X11_t + char portbuf[PORTBUFSIZE]; +#endif + + prmsg (2, "SocketINETCreateListener(%s)\n", port); + +#ifdef X11_t + /* + * X has a well known port, that is transport dependent. It is easier + * to handle it here, than try and come up with a transport independent + * representation that can be passed in and resolved the usual way. + * + * The port that is passed here is really a string containing the idisplay + * from ConnectDisplay(). + */ + + if (is_numeric (port)) + { + /* fixup the server port address */ + tmpport = X_TCP_PORT + strtol (port, (char**)NULL, 10); + snprintf (portbuf, sizeof(portbuf), "%lu", tmpport); + port = portbuf; + } +#endif + + if (port && *port) + { + /* Check to see if the port string is just a number (handles X11) */ + + if (!is_numeric (port)) + { + if ((servp = _XGetservbyname (port,"tcp",sparams)) == NULL) + { + prmsg (1, + "SocketINETCreateListener: Unable to get service for %s\n", + port); + return TRANS_CREATE_LISTENER_FAILED; + } + /* we trust getservbyname to return a valid number */ + sport = servp->s_port; + } + else + { + tmpport = strtol (port, (char**)NULL, 10); + /* + * check that somehow the port address isn't negative or in + * the range of reserved port addresses. This can happen and + * be very bad if the server is suid-root and the user does + * something (dumb) like `X :60049`. + */ + if (tmpport < 1024 || tmpport > USHRT_MAX) + return TRANS_CREATE_LISTENER_FAILED; + + sport = (unsigned short) tmpport; + } + } + else + sport = 0; + + bzero(&sockname, sizeof(sockname)); + if (Sockettrans2devtab[ciptr->index].family == AF_INET) { + namelen = sizeof (struct sockaddr_in); +#ifdef BSD44SOCKETS + ((struct sockaddr_in *)&sockname)->sin_len = namelen; +#endif + ((struct sockaddr_in *)&sockname)->sin_family = AF_INET; + ((struct sockaddr_in *)&sockname)->sin_port = htons(sport); + ((struct sockaddr_in *)&sockname)->sin_addr.s_addr = htonl(INADDR_ANY); + } else { +#ifdef IPv6 + namelen = sizeof (struct sockaddr_in6); +#ifdef SIN6_LEN + ((struct sockaddr_in6 *)&sockname)->sin6_len = sizeof(sockname); +#endif + ((struct sockaddr_in6 *)&sockname)->sin6_family = AF_INET6; + ((struct sockaddr_in6 *)&sockname)->sin6_port = htons(sport); + ((struct sockaddr_in6 *)&sockname)->sin6_addr = in6addr_any; +#else + prmsg (1, + "SocketINETCreateListener: unsupported address family %d\n", + Sockettrans2devtab[ciptr->index].family); + return TRANS_CREATE_LISTENER_FAILED; +#endif + } + + if ((status = TRANS(SocketCreateListener) (ciptr, + (struct sockaddr *) &sockname, namelen, flags)) < 0) + { + prmsg (1, + "SocketINETCreateListener: ...SocketCreateListener() failed\n"); + return status; + } + + if (TRANS(SocketINETGetAddr) (ciptr) < 0) + { + prmsg (1, + "SocketINETCreateListener: ...SocketINETGetAddr() failed\n"); + return TRANS_CREATE_LISTENER_FAILED; + } + + return 0; +} + +#endif /* TCPCONN */ + + +#ifdef UNIXCONN + +static int +TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port, + unsigned int flags) + +{ + struct sockaddr_un sockname; + int namelen; + int oldUmask; + int status; + unsigned int mode; + char tmpport[108]; + + int abstract = 0; +#ifdef HAVE_ABSTRACT_SOCKETS + abstract = ciptr->transptr->flags & TRANS_ABSTRACT; +#endif + + prmsg (2, "SocketUNIXCreateListener(%s)\n", + port ? port : "NULL"); + + /* Make sure the directory is created */ + + oldUmask = umask (0); + +#ifdef UNIX_DIR +#ifdef HAS_STICKY_DIR_BIT + mode = 01777; +#else + mode = 0777; +#endif + if (!abstract && trans_mkdir(UNIX_DIR, mode) == -1) { + prmsg (1, "SocketUNIXCreateListener: mkdir(%s) failed, errno = %d\n", + UNIX_DIR, errno); + (void) umask (oldUmask); + return TRANS_CREATE_LISTENER_FAILED; + } +#endif + + memset(&sockname, 0, sizeof(sockname)); + sockname.sun_family = AF_UNIX; + + if (!(port && *port)) { + snprintf (tmpport, sizeof(tmpport), "%s%ld", UNIX_PATH, (long)getpid()); + port = tmpport; + } + if (set_sun_path(port, UNIX_PATH, sockname.sun_path, abstract) != 0) { + prmsg (1, "SocketUNIXCreateListener: path too long\n"); + return TRANS_CREATE_LISTENER_FAILED; + } + +#if defined(BSD44SOCKETS) + sockname.sun_len = strlen(sockname.sun_path); +#endif + +#if defined(BSD44SOCKETS) || defined(SUN_LEN) + namelen = SUN_LEN(&sockname); +#else + namelen = strlen(sockname.sun_path) + offsetof(struct sockaddr_un, sun_path); +#endif + + if (abstract) { + sockname.sun_path[0] = '\0'; + namelen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&sockname.sun_path[1]); + } + else + unlink (sockname.sun_path); + + if ((status = TRANS(SocketCreateListener) (ciptr, + (struct sockaddr *) &sockname, namelen, flags)) < 0) + { + prmsg (1, + "SocketUNIXCreateListener: ...SocketCreateListener() failed\n"); + (void) umask (oldUmask); + return status; + } + + /* + * Now that the listener is esablished, create the addr info for + * this connection. getpeername() doesn't work for UNIX Domain Sockets + * on some systems (hpux at least), so we will just do it manually, instead + * of calling something like TRANS(SocketUNIXGetAddr). + */ + + namelen = sizeof (sockname); /* this will always make it the same size */ + + if ((ciptr->addr = malloc (namelen)) == NULL) + { + prmsg (1, + "SocketUNIXCreateListener: Can't allocate space for the addr\n"); + (void) umask (oldUmask); + return TRANS_CREATE_LISTENER_FAILED; + } + + if (abstract) + sockname.sun_path[0] = '@'; + + ciptr->family = sockname.sun_family; + ciptr->addrlen = namelen; + memcpy (ciptr->addr, &sockname, ciptr->addrlen); + + (void) umask (oldUmask); + + return 0; +} + + +static int +TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr) + +{ + /* + * See if the unix domain socket has disappeared. If it has, recreate it. + */ + + struct sockaddr_un *unsock = (struct sockaddr_un *) ciptr->addr; + struct stat statb; + int status = TRANS_RESET_NOOP; + unsigned int mode; + int abstract = 0; +#ifdef HAVE_ABSTRACT_SOCKETS + abstract = ciptr->transptr->flags & TRANS_ABSTRACT; +#endif + + prmsg (3, "SocketUNIXResetListener(%p,%d)\n", (void *) ciptr, ciptr->fd); + + if (!abstract && ( + stat (unsock->sun_path, &statb) == -1 || + ((statb.st_mode & S_IFMT) != +#if !defined(S_IFSOCK) + S_IFIFO +#else + S_IFSOCK +#endif + ))) + { + int oldUmask = umask (0); + +#ifdef UNIX_DIR +#ifdef HAS_STICKY_DIR_BIT + mode = 01777; +#else + mode = 0777; +#endif + if (trans_mkdir(UNIX_DIR, mode) == -1) { + prmsg (1, "SocketUNIXResetListener: mkdir(%s) failed, errno = %d\n", + UNIX_DIR, errno); + (void) umask (oldUmask); + return TRANS_RESET_FAILURE; + } +#endif + + close (ciptr->fd); + unlink (unsock->sun_path); + + if ((ciptr->fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0) + { + TRANS(FreeConnInfo) (ciptr); + (void) umask (oldUmask); + return TRANS_RESET_FAILURE; + } + + if (bind (ciptr->fd, (struct sockaddr *) unsock, ciptr->addrlen) < 0) + { + close (ciptr->fd); + TRANS(FreeConnInfo) (ciptr); + return TRANS_RESET_FAILURE; + } + + if (listen (ciptr->fd, BACKLOG) < 0) + { + close (ciptr->fd); + TRANS(FreeConnInfo) (ciptr); + (void) umask (oldUmask); + return TRANS_RESET_FAILURE; + } + + umask (oldUmask); + + status = TRANS_RESET_NEW_FD; + } + + return status; +} + +#endif /* UNIXCONN */ + + +#ifdef TCPCONN + +static XtransConnInfo +TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status) + +{ + XtransConnInfo newciptr; + struct sockaddr_in sockname; + SOCKLEN_T namelen = sizeof(sockname); + + prmsg (2, "SocketINETAccept(%p,%d)\n", (void *) ciptr, ciptr->fd); + + if ((newciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL) + { + prmsg (1, "SocketINETAccept: malloc failed\n"); + *status = TRANS_ACCEPT_BAD_MALLOC; + return NULL; + } + + if ((newciptr->fd = accept (ciptr->fd, + (struct sockaddr *) &sockname, (void *)&namelen)) < 0) + { +#ifdef WIN32 + errno = WSAGetLastError(); +#endif + prmsg (1, "SocketINETAccept: accept() failed\n"); + free (newciptr); + *status = TRANS_ACCEPT_FAILED; + return NULL; + } + +#ifdef TCP_NODELAY + { + /* + * turn off TCP coalescence for INET sockets + */ + + int tmp = 1; + setsockopt (newciptr->fd, IPPROTO_TCP, TCP_NODELAY, + (char *) &tmp, sizeof (int)); + } +#endif + + /* + * Get this address again because the transport may give a more + * specific address now that a connection is established. + */ + + if (TRANS(SocketINETGetAddr) (newciptr) < 0) + { + prmsg (1, + "SocketINETAccept: ...SocketINETGetAddr() failed:\n"); + close (newciptr->fd); + free (newciptr); + *status = TRANS_ACCEPT_MISC_ERROR; + return NULL; + } + + if (TRANS(SocketINETGetPeerAddr) (newciptr) < 0) + { + prmsg (1, + "SocketINETAccept: ...SocketINETGetPeerAddr() failed:\n"); + close (newciptr->fd); + if (newciptr->addr) free (newciptr->addr); + free (newciptr); + *status = TRANS_ACCEPT_MISC_ERROR; + return NULL; + } + + *status = 0; + + return newciptr; +} + +#endif /* TCPCONN */ + + +#ifdef UNIXCONN +static XtransConnInfo +TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) + +{ + XtransConnInfo newciptr; + struct sockaddr_un sockname; + SOCKLEN_T namelen = sizeof sockname; + + prmsg (2, "SocketUNIXAccept(%p,%d)\n", (void *) ciptr, ciptr->fd); + + if ((newciptr = calloc (1, sizeof(struct _XtransConnInfo))) == NULL) + { + prmsg (1, "SocketUNIXAccept: malloc() failed\n"); + *status = TRANS_ACCEPT_BAD_MALLOC; + return NULL; + } + + if ((newciptr->fd = accept (ciptr->fd, + (struct sockaddr *) &sockname, (void *)&namelen)) < 0) + { + prmsg (1, "SocketUNIXAccept: accept() failed\n"); + free (newciptr); + *status = TRANS_ACCEPT_FAILED; + return NULL; + } + + ciptr->addrlen = namelen; + /* + * Get the socket name and the peer name from the listener socket, + * since this is unix domain. + */ + + if ((newciptr->addr = malloc (ciptr->addrlen)) == NULL) + { + prmsg (1, + "SocketUNIXAccept: Can't allocate space for the addr\n"); + close (newciptr->fd); + free (newciptr); + *status = TRANS_ACCEPT_BAD_MALLOC; + return NULL; + } + + /* + * if the socket is abstract, we already modified the address to have a + * @ instead of the initial NUL, so no need to do that again here. + */ + + newciptr->addrlen = ciptr->addrlen; + memcpy (newciptr->addr, ciptr->addr, newciptr->addrlen); + + if ((newciptr->peeraddr = malloc (ciptr->addrlen)) == NULL) + { + prmsg (1, + "SocketUNIXAccept: Can't allocate space for the addr\n"); + close (newciptr->fd); + if (newciptr->addr) free (newciptr->addr); + free (newciptr); + *status = TRANS_ACCEPT_BAD_MALLOC; + return NULL; + } + + newciptr->peeraddrlen = ciptr->addrlen; + memcpy (newciptr->peeraddr, ciptr->addr, newciptr->addrlen); + + newciptr->family = AF_UNIX; + + *status = 0; + + return newciptr; +} + +#endif /* UNIXCONN */ + +#endif /* TRANS_SERVER */ + + +#ifdef TRANS_CLIENT + +#ifdef TCPCONN + +#ifdef HAVE_GETADDRINFO +struct addrlist { + struct addrinfo * addr; + struct addrinfo * firstaddr; + char port[PORTBUFSIZE]; + char host[MAXHOSTNAMELEN]; +}; +static struct addrlist *addrlist = NULL; +#endif + + +static int +TRANS(SocketINETConnect) (XtransConnInfo ciptr, + const char *host, const char *port) + +{ + struct sockaddr * socketaddr = NULL; + int socketaddrlen = 0; + int res; +#ifdef HAVE_GETADDRINFO + struct addrinfo hints; + char ntopbuf[INET6_ADDRSTRLEN]; + int resetonce = 0; +#else + struct sockaddr_in sockname; + struct hostent *hostp; + struct servent *servp; + unsigned long tmpaddr; +#endif +#ifdef XTHREADS_NEEDS_BYNAMEPARAMS + _Xgethostbynameparams hparams; + _Xgetservbynameparams sparams; +#endif +#ifdef X11_t + char portbuf[PORTBUFSIZE]; +#endif + + char hostnamebuf[256]; /* tmp space */ + + prmsg (2,"SocketINETConnect(%d,%s,%s)\n", ciptr->fd, host, port); + + if (!host) + { + hostnamebuf[0] = '\0'; + (void) TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf); + host = hostnamebuf; + } + +#ifdef X11_t + /* + * X has a well known port, that is transport dependent. It is easier + * to handle it here, than try and come up with a transport independent + * representation that can be passed in and resolved the usual way. + * + * The port that is passed here is really a string containing the idisplay + * from ConnectDisplay(). + */ + + if (is_numeric (port)) + { + long tmpport = X_TCP_PORT + strtol (port, (char**)NULL, 10); + snprintf (portbuf, sizeof(portbuf), "%lu", tmpport); + port = portbuf; + } +#endif + +#ifdef HAVE_GETADDRINFO + { + if (addrlist != NULL) { + if (strcmp(host,addrlist->host) || strcmp(port,addrlist->port)) { + if (addrlist->firstaddr) + freeaddrinfo(addrlist->firstaddr); + addrlist->firstaddr = NULL; + } + } else { + addrlist = malloc(sizeof(struct addrlist)); + if (addrlist == NULL) { + prmsg (1, "SocketINETConnect() can't allocate memory " + "for addrlist: %s\n", strerror(errno)); + return TRANS_CONNECT_FAILED; + } + addrlist->firstaddr = NULL; + } + + if (addrlist->firstaddr == NULL) { + strncpy(addrlist->port, port, sizeof(addrlist->port)); + addrlist->port[sizeof(addrlist->port) - 1] = '\0'; + strncpy(addrlist->host, host, sizeof(addrlist->host)); + addrlist->host[sizeof(addrlist->host) - 1] = '\0'; + + bzero(&hints,sizeof(hints)); +#ifdef IPv6 + if (strcmp(Sockettrans2devtab[ciptr->index].transname, "tcp") == 0) + hints.ai_family = AF_UNSPEC; + else +#endif + hints.ai_family = Sockettrans2devtab[ciptr->index].family; + hints.ai_socktype = Sockettrans2devtab[ciptr->index].devcotsname; + + res = getaddrinfo(host,port,&hints,&addrlist->firstaddr); + if (res != 0) { + prmsg (1, "SocketINETConnect() can't get address " + "for %s:%s: %s\n", host, port, gai_strerror(res)); + ESET(EINVAL); + return TRANS_CONNECT_FAILED; + } + for (res = 0, addrlist->addr = addrlist->firstaddr; + addrlist->addr ; res++) { + addrlist->addr = addrlist->addr->ai_next; + } + prmsg(4,"Got New Address list with %d addresses\n", res); + res = 0; + addrlist->addr = NULL; + } + + while (socketaddr == NULL) { + if (addrlist->addr == NULL) { + if (resetonce) { + /* Already checked entire list - no usable addresses */ + prmsg (1, "SocketINETConnect() no usable address " + "for %s:%s\n", host, port); + return TRANS_CONNECT_FAILED; + } else { + /* Go back to beginning of list */ + resetonce = 1; + addrlist->addr = addrlist->firstaddr; + } + } + + socketaddr = addrlist->addr->ai_addr; + socketaddrlen = addrlist->addr->ai_addrlen; + + if (addrlist->addr->ai_family == AF_INET) { + struct sockaddr_in *sin = (struct sockaddr_in *) socketaddr; + + prmsg (4,"SocketINETConnect() sockname.sin_addr = %s\n", + inet_ntop(addrlist->addr->ai_family,&sin->sin_addr, + ntopbuf,sizeof(ntopbuf))); + + prmsg (4,"SocketINETConnect() sockname.sin_port = %d\n", + ntohs(sin->sin_port)); + +#ifdef IPv6 + if (Sockettrans2devtab[ciptr->index].family == AF_INET6) { + if (strcmp(Sockettrans2devtab[ciptr->index].transname, + "tcp") == 0) { + XtransConnInfo newciptr; + + /* + * Our socket is an IPv6 socket, but the address is + * IPv4. Close it and get an IPv4 socket. This is + * needed for IPv4 connections to work on platforms + * that don't allow IPv4 over IPv6 sockets. + */ + TRANS(SocketINETClose)(ciptr); + newciptr = TRANS(SocketOpenCOTSClientBase)( + "tcp", "tcp", host, port, ciptr->index); + if (newciptr) + ciptr->fd = newciptr->fd; + if (!newciptr || + Sockettrans2devtab[newciptr->index].family != + AF_INET) { + socketaddr = NULL; + prmsg (4,"SocketINETConnect() Cannot get IPv4 " + " socketfor IPv4 address\n"); + } + if (newciptr) + free(newciptr); + } else { + socketaddr = NULL; + prmsg (4,"SocketINETConnect Skipping IPv4 address\n"); + } + } + } else if (addrlist->addr->ai_family == AF_INET6) { + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) socketaddr; + + prmsg (4,"SocketINETConnect() sockname.sin6_addr = %s\n", + inet_ntop(addrlist->addr->ai_family, + &sin6->sin6_addr,ntopbuf,sizeof(ntopbuf))); + prmsg (4,"SocketINETConnect() sockname.sin6_port = %d\n", + ntohs(sin6->sin6_port)); + + if (Sockettrans2devtab[ciptr->index].family == AF_INET) { + if (strcmp(Sockettrans2devtab[ciptr->index].transname, + "tcp") == 0) { + XtransConnInfo newciptr; + + /* + * Close the IPv4 socket and try to open an IPv6 socket. + */ + TRANS(SocketINETClose)(ciptr); + newciptr = TRANS(SocketOpenCOTSClientBase)( + "tcp", "tcp", host, port, -1); + if (newciptr) + ciptr->fd = newciptr->fd; + if (!newciptr || + Sockettrans2devtab[newciptr->index].family != + AF_INET6) { + socketaddr = NULL; + prmsg (4,"SocketINETConnect() Cannot get IPv6 " + "socket for IPv6 address\n"); + } + if (newciptr) + free(newciptr); + } + else + { + socketaddr = NULL; + prmsg (4,"SocketINETConnect() Skipping IPv6 address\n"); + } + } +#endif /* IPv6 */ + } else { + socketaddr = NULL; /* Unsupported address type */ + } + if (socketaddr == NULL) { + addrlist->addr = addrlist->addr->ai_next; + } + } + } +#else /* !HAVE_GETADDRINFO */ + { + /* + * Build the socket name. + */ + +#ifdef BSD44SOCKETS + sockname.sin_len = sizeof (struct sockaddr_in); +#endif + sockname.sin_family = AF_INET; + + /* + * fill in sin_addr + */ + +#ifndef INADDR_NONE +#define INADDR_NONE ((in_addr_t) 0xffffffff) +#endif + + /* check for ww.xx.yy.zz host string */ + + if (isascii (host[0]) && isdigit (host[0])) { + tmpaddr = inet_addr (host); /* returns network byte order */ + } else { + tmpaddr = INADDR_NONE; + } + + prmsg (4,"SocketINETConnect() inet_addr(%s) = %lx\n", host, tmpaddr); + + if (tmpaddr == INADDR_NONE) { + if ((hostp = _XGethostbyname(host,hparams)) == NULL) { + prmsg (1,"SocketINETConnect: Can't get address for %s\n", + host); + ESET(EINVAL); + return TRANS_CONNECT_FAILED; + } + if (hostp->h_addrtype != AF_INET) { /* is IP host? */ + prmsg (1,"SocketINETConnect: not INET host%s\n", host); + ESET(EPROTOTYPE); + return TRANS_CONNECT_FAILED; + } + + memcpy ((char *) &sockname.sin_addr, (char *) hostp->h_addr, + sizeof (sockname.sin_addr)); + + } else { + sockname.sin_addr.s_addr = tmpaddr; + } + + /* + * fill in sin_port + */ + + /* Check for number in the port string */ + + if (!is_numeric (port)) { + if ((servp = _XGetservbyname (port,"tcp",sparams)) == NULL) { + prmsg (1,"SocketINETConnect: can't get service for %s\n", + port); + return TRANS_CONNECT_FAILED; + } + sockname.sin_port = htons (servp->s_port); + } else { + long tmpport = strtol (port, (char**)NULL, 10); + if (tmpport < 1024 || tmpport > USHRT_MAX) + return TRANS_CONNECT_FAILED; + sockname.sin_port = htons (((unsigned short) tmpport)); + } + + prmsg (4,"SocketINETConnect: sockname.sin_port = %d\n", + ntohs(sockname.sin_port)); + socketaddr = (struct sockaddr *) &sockname; + socketaddrlen = sizeof(sockname); + } +#endif + + /* + * Turn on socket keepalive so the client process will eventually + * be notified with a SIGPIPE signal if the display server fails + * to respond to a periodic transmission of messages + * on the connected socket. + * This is useful to avoid hung application processes when the + * processes are not spawned from the xdm session and + * the display server terminates abnormally. + * (Someone turned off the power switch.) + */ + + { + int tmp = 1; + setsockopt (ciptr->fd, SOL_SOCKET, SO_KEEPALIVE, + (char *) &tmp, sizeof (int)); + } + + /* + * Do the connect() + */ + + if (connect (ciptr->fd, socketaddr, socketaddrlen ) < 0) + { +#ifdef WIN32 + int olderrno = WSAGetLastError(); +#else + int olderrno = errno; +#endif + + /* + * If the error was ECONNREFUSED, the server may be overloaded + * and we should try again. + * + * If the error was EWOULDBLOCK or EINPROGRESS then the socket + * was non-blocking and we should poll using select + * + * If the error was EINTR, the connect was interrupted and we + * should try again. + * + * If multiple addresses are found for a host then we should + * try to connect again with a different address for a larger + * number of errors that made us quit before, since those + * could be caused by trying to use an IPv6 address to contact + * a machine with an IPv4-only server or other reasons that + * only affect one of a set of addresses. + */ + + if (olderrno == ECONNREFUSED || olderrno == EINTR +#ifdef HAVE_GETADDRINFO + || (((addrlist->addr->ai_next != NULL) || + (addrlist->addr != addrlist->firstaddr)) && + (olderrno == ENETUNREACH || olderrno == EAFNOSUPPORT || + olderrno == EADDRNOTAVAIL || olderrno == ETIMEDOUT +#if defined(EHOSTDOWN) + || olderrno == EHOSTDOWN +#endif + )) +#endif + ) + res = TRANS_TRY_CONNECT_AGAIN; + else if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS) + res = TRANS_IN_PROGRESS; + else + { + prmsg (2,"SocketINETConnect: Can't connect: errno = %d\n", + olderrno); + + res = TRANS_CONNECT_FAILED; + } + } else { + res = 0; + + + /* + * Sync up the address fields of ciptr. + */ + + if (TRANS(SocketINETGetAddr) (ciptr) < 0) + { + prmsg (1, + "SocketINETConnect: ...SocketINETGetAddr() failed:\n"); + res = TRANS_CONNECT_FAILED; + } + + else if (TRANS(SocketINETGetPeerAddr) (ciptr) < 0) + { + prmsg (1, + "SocketINETConnect: ...SocketINETGetPeerAddr() failed:\n"); + res = TRANS_CONNECT_FAILED; + } + } + +#ifdef HAVE_GETADDRINFO + if (res != 0) { + addrlist->addr = addrlist->addr->ai_next; + } +#endif + + return res; +} + +#endif /* TCPCONN */ + + + +#ifdef UNIXCONN + +/* + * Make sure 'host' is really local. + */ + +static int +UnixHostReallyLocal (const char *host) + +{ + char hostnamebuf[256]; + + TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf)); + + if (strcmp (hostnamebuf, host) == 0) + { + return (1); + } else { +#ifdef HAVE_GETADDRINFO + struct addrinfo *localhostaddr; + struct addrinfo *otherhostaddr; + struct addrinfo *i, *j; + int equiv = 0; + + if (getaddrinfo(hostnamebuf, NULL, NULL, &localhostaddr) != 0) + return 0; + if (getaddrinfo(host, NULL, NULL, &otherhostaddr) != 0) { + freeaddrinfo(localhostaddr); + return 0; + } + + for (i = localhostaddr; i != NULL && equiv == 0; i = i->ai_next) { + for (j = otherhostaddr; j != NULL && equiv == 0; j = j->ai_next) { + if (i->ai_family == j->ai_family) { + if (i->ai_family == AF_INET) { + struct sockaddr_in *sinA + = (struct sockaddr_in *) i->ai_addr; + struct sockaddr_in *sinB + = (struct sockaddr_in *) j->ai_addr; + struct in_addr *A = &sinA->sin_addr; + struct in_addr *B = &sinB->sin_addr; + + if (memcmp(A,B,sizeof(struct in_addr)) == 0) { + equiv = 1; + } +#ifdef IPv6 + } else if (i->ai_family == AF_INET6) { + struct sockaddr_in6 *sinA + = (struct sockaddr_in6 *) i->ai_addr; + struct sockaddr_in6 *sinB + = (struct sockaddr_in6 *) j->ai_addr; + struct in6_addr *A = &sinA->sin6_addr; + struct in6_addr *B = &sinB->sin6_addr; + + if (memcmp(A,B,sizeof(struct in6_addr)) == 0) { + equiv = 1; + } +#endif /* IPv6 */ + } + } + } + } + + freeaddrinfo(localhostaddr); + freeaddrinfo(otherhostaddr); + return equiv; +#else /* !HAVE_GETADDRINFO */ + /* + * A host may have more than one network address. If any of the + * network addresses of 'host' (specified to the connect call) + * match any of the network addresses of 'hostname' (determined + * by TRANS(GetHostname)), then the two hostnames are equivalent, + * and we know that 'host' is really a local host. + */ + char specified_local_addr_list[10][4]; + int scount, equiv, i, j; +#ifdef XTHREADS_NEEDS_BYNAMEPARAMS + _Xgethostbynameparams hparams; +#endif + struct hostent *hostp; + + if ((hostp = _XGethostbyname (host,hparams)) == NULL) + return (0); + + scount = 0; + while (hostp->h_addr_list[scount] && scount <= 8) + { + /* + * The 2nd call to gethostname() overrides the data + * from the 1st call, so we must save the address list. + */ + + specified_local_addr_list[scount][0] = + hostp->h_addr_list[scount][0]; + specified_local_addr_list[scount][1] = + hostp->h_addr_list[scount][1]; + specified_local_addr_list[scount][2] = + hostp->h_addr_list[scount][2]; + specified_local_addr_list[scount][3] = + hostp->h_addr_list[scount][3]; + scount++; + } + if ((hostp = _XGethostbyname (hostnamebuf,hparams)) == NULL) + return (0); + + equiv = 0; + i = 0; + + while (i < scount && !equiv) + { + j = 0; + + while (hostp->h_addr_list[j]) + { + if ((specified_local_addr_list[i][0] == + hostp->h_addr_list[j][0]) && + (specified_local_addr_list[i][1] == + hostp->h_addr_list[j][1]) && + (specified_local_addr_list[i][2] == + hostp->h_addr_list[j][2]) && + (specified_local_addr_list[i][3] == + hostp->h_addr_list[j][3])) + { + /* They're equal, so we're done */ + + equiv = 1; + break; + } + + j++; + } + + i++; + } + return (equiv); +#endif + } +} + +static int +TRANS(SocketUNIXConnect) (XtransConnInfo ciptr, + const char *host, const char *port) + +{ + struct sockaddr_un sockname; + SOCKLEN_T namelen; + + prmsg (2,"SocketUNIXConnect(%d,%s,%s)\n", ciptr->fd, host, port); + + /* + * Make sure 'host' is really local. If not, we return failure. + * The reason we make this check is because a process may advertise + * a "local" network ID for which it can accept connections, but if + * a process on a remote machine tries to connect to this network ID, + * we know for sure it will fail. + */ + + if (host && *host && host[0]!='/' && strcmp (host, "unix") != 0 && !UnixHostReallyLocal (host)) + { + prmsg (1, + "SocketUNIXConnect: Cannot connect to non-local host %s\n", + host); + return TRANS_CONNECT_FAILED; + } + + + /* + * Check the port. + */ + + if (!port || !*port) + { + prmsg (1,"SocketUNIXConnect: Missing port specification\n"); + return TRANS_CONNECT_FAILED; + } + + /* + * Build the socket name. + */ + + sockname.sun_family = AF_UNIX; + + if (set_sun_path(port, UNIX_PATH, sockname.sun_path, 0) != 0) { + prmsg (1, "SocketUNIXConnect: path too long\n"); + return TRANS_CONNECT_FAILED; + } + +#if defined(BSD44SOCKETS) + sockname.sun_len = strlen (sockname.sun_path); +#endif + +#if defined(BSD44SOCKETS) || defined(SUN_LEN) + namelen = SUN_LEN (&sockname); +#else + namelen = strlen (sockname.sun_path) + offsetof(struct sockaddr_un, sun_path); +#endif + + + /* + * Do the connect() + */ + + if (connect (ciptr->fd, (struct sockaddr *) &sockname, namelen) < 0) + { + int olderrno = errno; + int connected = 0; + + if (!connected) + { + errno = olderrno; + + /* + * If the error was ENOENT, the server may be starting up; we used + * to suggest to try again in this case with + * TRANS_TRY_CONNECT_AGAIN, but this introduced problems for + * processes still referencing stale sockets in their environment. + * Hence, we now return a hard error, TRANS_CONNECT_FAILED, and it + * is suggested that higher level stacks handle retries on their + * level when they face a slow starting server. + * + * If the error was EWOULDBLOCK or EINPROGRESS then the socket + * was non-blocking and we should poll using select + * + * If the error was EINTR, the connect was interrupted and we + * should try again. + */ + + if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS) + return TRANS_IN_PROGRESS; + else if (olderrno == EINTR) + return TRANS_TRY_CONNECT_AGAIN; + else { + prmsg (2,"SocketUNIXConnect: Can't connect: errno = %d\n", + EGET()); + + return TRANS_CONNECT_FAILED; + } + } + } + + /* + * Get the socket name and the peer name from the connect socket, + * since this is unix domain. + */ + + if ((ciptr->addr = malloc(namelen)) == NULL || + (ciptr->peeraddr = malloc(namelen)) == NULL) + { + prmsg (1, + "SocketUNIXCreateListener: Can't allocate space for the addr\n"); + return TRANS_CONNECT_FAILED; + } + + ciptr->family = AF_UNIX; + ciptr->addrlen = namelen; + ciptr->peeraddrlen = namelen; + memcpy (ciptr->addr, &sockname, ciptr->addrlen); + memcpy (ciptr->peeraddr, &sockname, ciptr->peeraddrlen); + + return 0; +} + +#endif /* UNIXCONN */ + +#endif /* TRANS_CLIENT */ + + +static int +TRANS(SocketBytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) + +{ + prmsg (2,"SocketBytesReadable(%p,%d,%p)\n", + (void *) ciptr, ciptr->fd, (void *) pend); +#ifdef WIN32 + { + int ret = ioctlsocket ((SOCKET) ciptr->fd, FIONREAD, (u_long *) pend); + if (ret == SOCKET_ERROR) errno = WSAGetLastError(); + return ret; + } +#else + return ioctl (ciptr->fd, FIONREAD, (char *) pend); +#endif /* WIN32 */ +} + +#if XTRANS_SEND_FDS + +static void +appendFd(struct _XtransConnFd **prev, int fd, int do_close) +{ + struct _XtransConnFd *cf, *new; + + new = malloc (sizeof (struct _XtransConnFd)); + if (!new) { + /* XXX mark connection as broken */ + close(fd); + return; + } + new->next = 0; + new->fd = fd; + new->do_close = do_close; + /* search to end of list */ + for (; (cf = *prev); prev = &(cf->next)); + *prev = new; +} + +static int +removeFd(struct _XtransConnFd **prev) +{ + struct _XtransConnFd *cf; + int fd; + + if ((cf = *prev)) { + *prev = cf->next; + fd = cf->fd; + free(cf); + } else + fd = -1; + return fd; +} + +static void +discardFd(struct _XtransConnFd **prev, struct _XtransConnFd *upto, int do_close) +{ + struct _XtransConnFd *cf, *next; + + for (cf = *prev; cf != upto; cf = next) { + next = cf->next; + if (do_close || cf->do_close) + close(cf->fd); + free(cf); + } + *prev = upto; +} + +static void +cleanupFds(XtransConnInfo ciptr) +{ + /* Clean up the send list but don't close the fds */ + discardFd(&ciptr->send_fds, NULL, 0); + /* Clean up the recv list and *do* close the fds */ + discardFd(&ciptr->recv_fds, NULL, 1); +} + +static int +nFd(struct _XtransConnFd **prev) +{ + struct _XtransConnFd *cf; + int n = 0; + + for (cf = *prev; cf; cf = cf->next) + n++; + return n; +} + +static int +TRANS(SocketRecvFd) (XtransConnInfo ciptr) +{ + prmsg (2, "SocketRecvFd(%d)\n", ciptr->fd); + return removeFd(&ciptr->recv_fds); +} + +static int +TRANS(SocketSendFd) (XtransConnInfo ciptr, int fd, int do_close) +{ + appendFd(&ciptr->send_fds, fd, do_close); + return 0; +} + +static int +TRANS(SocketRecvFdInvalid)(XtransConnInfo ciptr) +{ + errno = EINVAL; + return -1; +} + +static int +TRANS(SocketSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close) +{ + errno = EINVAL; + return -1; +} + +#define MAX_FDS 128 + +union fd_pass { + struct cmsghdr cmsghdr; + char buf[CMSG_SPACE(MAX_FDS * sizeof(int))]; +}; + +#endif /* XTRANS_SEND_FDS */ + +static int +TRANS(SocketRead) (XtransConnInfo ciptr, char *buf, int size) + +{ + prmsg (2,"SocketRead(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); + +#if defined(WIN32) + { + int ret = recv ((SOCKET)ciptr->fd, buf, size, 0); +#ifdef WIN32 + if (ret == SOCKET_ERROR) errno = WSAGetLastError(); +#endif + return ret; + } +#else +#if XTRANS_SEND_FDS + { + struct iovec iov = { + .iov_base = buf, + .iov_len = size + }; + union fd_pass cmsgbuf; + struct msghdr msg = { + .msg_name = NULL, + .msg_namelen = 0, + .msg_iov = &iov, + .msg_iovlen = 1, + .msg_control = cmsgbuf.buf, + .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int)) + }; + + size = recvmsg(ciptr->fd, &msg, 0); + if (size >= 0) { + struct cmsghdr *hdr; + + for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) { + if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) { + int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int); + int i; + int *fd = (int *) CMSG_DATA(hdr); + + for (i = 0; i < nfd; i++) + appendFd(&ciptr->recv_fds, fd[i], 0); + } + } + } + return size; + } +#else + return read(ciptr->fd, buf, size); +#endif /* XTRANS_SEND_FDS */ +#endif /* WIN32 */ +} + +static int +TRANS(SocketReadv) (XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + prmsg (2,"SocketReadv(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); + +#if XTRANS_SEND_FDS + { + union fd_pass cmsgbuf; + struct msghdr msg = { + .msg_name = NULL, + .msg_namelen = 0, + .msg_iov = buf, + .msg_iovlen = size, + .msg_control = cmsgbuf.buf, + .msg_controllen = CMSG_LEN(MAX_FDS * sizeof(int)) + }; + + size = recvmsg(ciptr->fd, &msg, 0); + if (size >= 0) { + struct cmsghdr *hdr; + + for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) { + if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) { + int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int); + int i; + int *fd = (int *) CMSG_DATA(hdr); + + for (i = 0; i < nfd; i++) + appendFd(&ciptr->recv_fds, fd[i], 0); + } + } + } + return size; + } +#else + return READV (ciptr, buf, size); +#endif +} + + +static int +TRANS(SocketWritev) (XtransConnInfo ciptr, struct iovec *buf, int size) + +{ + prmsg (2,"SocketWritev(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); + +#if XTRANS_SEND_FDS + if (ciptr->send_fds) + { + union fd_pass cmsgbuf; + int nfd = nFd(&ciptr->send_fds); + struct _XtransConnFd *cf = ciptr->send_fds; + struct msghdr msg = { + .msg_name = NULL, + .msg_namelen = 0, + .msg_iov = buf, + .msg_iovlen = size, + .msg_control = cmsgbuf.buf, + .msg_controllen = CMSG_LEN(nfd * sizeof(int)) + }; + struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg); + int i; + int *fds; + + hdr->cmsg_len = msg.msg_controllen; + hdr->cmsg_level = SOL_SOCKET; + hdr->cmsg_type = SCM_RIGHTS; + + fds = (int *) CMSG_DATA(hdr); + /* Set up fds */ + for (i = 0; i < nfd; i++) { + fds[i] = cf->fd; + cf = cf->next; + } + + i = sendmsg(ciptr->fd, &msg, 0); + if (i > 0) + discardFd(&ciptr->send_fds, cf, 0); + return i; + } +#endif + return WRITEV (ciptr, buf, size); +} + + +static int +TRANS(SocketWrite) (XtransConnInfo ciptr, const char *buf, int size) + +{ + prmsg (2,"SocketWrite(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size); + +#if defined(WIN32) + { + int ret = send ((SOCKET)ciptr->fd, buf, size, 0); +#ifdef WIN32 + if (ret == SOCKET_ERROR) errno = WSAGetLastError(); +#endif + return ret; + } +#else +#if XTRANS_SEND_FDS + if (ciptr->send_fds) + { + struct iovec iov; + + iov.iov_base = (void *) buf; + iov.iov_len = size; + return TRANS(SocketWritev)(ciptr, &iov, 1); + } +#endif /* XTRANS_SEND_FDS */ + return write (ciptr->fd, buf, size); +#endif /* WIN32 */ +} + +static int +TRANS(SocketDisconnect) (XtransConnInfo ciptr) + +{ + prmsg (2,"SocketDisconnect(%p,%d)\n", (void *) ciptr, ciptr->fd); + +#ifdef WIN32 + { + int ret = shutdown (ciptr->fd, 2); + if (ret == SOCKET_ERROR) errno = WSAGetLastError(); + return ret; + } +#else + return shutdown (ciptr->fd, 2); /* disallow further sends and receives */ +#endif +} + + +#ifdef TCPCONN +static int +TRANS(SocketINETClose) (XtransConnInfo ciptr) + +{ + prmsg (2,"SocketINETClose(%p,%d)\n", (void *) ciptr, ciptr->fd); + +#ifdef WIN32 + { + int ret = close (ciptr->fd); + if (ret == SOCKET_ERROR) errno = WSAGetLastError(); + return ret; + } +#else + return close (ciptr->fd); +#endif +} + +#endif /* TCPCONN */ + + +#ifdef UNIXCONN +static int +TRANS(SocketUNIXClose) (XtransConnInfo ciptr) +{ + /* + * If this is the server side, then once the socket is closed, + * it must be unlinked to completely close it + */ + + struct sockaddr_un *sockname = (struct sockaddr_un *) ciptr->addr; + int ret; + + prmsg (2,"SocketUNIXClose(%p,%d)\n", (void *) ciptr, ciptr->fd); + +#if XTRANS_SEND_FDS + cleanupFds(ciptr); +#endif + ret = close(ciptr->fd); + + if (ciptr->flags + && sockname + && sockname->sun_family == AF_UNIX + && sockname->sun_path[0]) + { + if (!(ciptr->flags & TRANS_NOUNLINK + || ciptr->transptr->flags & TRANS_ABSTRACT)) + unlink (sockname->sun_path); + } + + return ret; +} + +static int +TRANS(SocketUNIXCloseForCloning) (XtransConnInfo ciptr) + +{ + /* + * Don't unlink path. + */ + + int ret; + + prmsg (2,"SocketUNIXCloseForCloning(%p,%d)\n", + (void *) ciptr, ciptr->fd); + +#if XTRANS_SEND_FDS + cleanupFds(ciptr); +#endif + ret = close(ciptr->fd); + + return ret; +} + +#endif /* UNIXCONN */ + + +#ifdef TCPCONN +# ifdef TRANS_SERVER +static const char* tcp_nolisten[] = { + "inet", +#ifdef IPv6 + "inet6", +#endif + NULL +}; +# endif + +static Xtransport TRANS(SocketTCPFuncs) = { + /* Socket Interface */ + "tcp", + TRANS_ALIAS, +#ifdef TRANS_CLIENT + TRANS(SocketOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + tcp_nolisten, + TRANS(SocketOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(SocketReopenCOTSServer), +#endif + TRANS(SocketSetOption), +#ifdef TRANS_SERVER + TRANS(SocketINETCreateListener), + NULL, /* ResetListener */ + TRANS(SocketINETAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(SocketINETConnect), +#endif /* TRANS_CLIENT */ + TRANS(SocketBytesReadable), + TRANS(SocketRead), + TRANS(SocketWrite), + TRANS(SocketReadv), + TRANS(SocketWritev), +#if XTRANS_SEND_FDS + TRANS(SocketSendFdInvalid), + TRANS(SocketRecvFdInvalid), +#endif + TRANS(SocketDisconnect), + TRANS(SocketINETClose), + TRANS(SocketINETClose), + }; + +static Xtransport TRANS(SocketINETFuncs) = { + /* Socket Interface */ + "inet", + 0, +#ifdef TRANS_CLIENT + TRANS(SocketOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + NULL, + TRANS(SocketOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(SocketReopenCOTSServer), +#endif + TRANS(SocketSetOption), +#ifdef TRANS_SERVER + TRANS(SocketINETCreateListener), + NULL, /* ResetListener */ + TRANS(SocketINETAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(SocketINETConnect), +#endif /* TRANS_CLIENT */ + TRANS(SocketBytesReadable), + TRANS(SocketRead), + TRANS(SocketWrite), + TRANS(SocketReadv), + TRANS(SocketWritev), +#if XTRANS_SEND_FDS + TRANS(SocketSendFdInvalid), + TRANS(SocketRecvFdInvalid), +#endif + TRANS(SocketDisconnect), + TRANS(SocketINETClose), + TRANS(SocketINETClose), + }; + +#ifdef IPv6 +static Xtransport TRANS(SocketINET6Funcs) = { + /* Socket Interface */ + "inet6", + 0, +#ifdef TRANS_CLIENT + TRANS(SocketOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + NULL, + TRANS(SocketOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(SocketReopenCOTSServer), +#endif + TRANS(SocketSetOption), +#ifdef TRANS_SERVER + TRANS(SocketINETCreateListener), + NULL, /* ResetListener */ + TRANS(SocketINETAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(SocketINETConnect), +#endif /* TRANS_CLIENT */ + TRANS(SocketBytesReadable), + TRANS(SocketRead), + TRANS(SocketWrite), + TRANS(SocketReadv), + TRANS(SocketWritev), +#if XTRANS_SEND_FDS + TRANS(SocketSendFdInvalid), + TRANS(SocketRecvFdInvalid), +#endif + TRANS(SocketDisconnect), + TRANS(SocketINETClose), + TRANS(SocketINETClose), + }; +#endif /* IPv6 */ +#endif /* TCPCONN */ + +#ifdef UNIXCONN +#if !defined(LOCALCONN) +static Xtransport TRANS(SocketLocalFuncs) = { + /* Socket Interface */ + "local", +#ifdef HAVE_ABSTRACT_SOCKETS + TRANS_ABSTRACT, +#else + 0, +#endif +#ifdef TRANS_CLIENT + TRANS(SocketOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER + NULL, + TRANS(SocketOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(SocketReopenCOTSServer), +#endif + TRANS(SocketSetOption), +#ifdef TRANS_SERVER + TRANS(SocketUNIXCreateListener), + TRANS(SocketUNIXResetListener), + TRANS(SocketUNIXAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(SocketUNIXConnect), +#endif /* TRANS_CLIENT */ + TRANS(SocketBytesReadable), + TRANS(SocketRead), + TRANS(SocketWrite), + TRANS(SocketReadv), + TRANS(SocketWritev), +#if XTRANS_SEND_FDS + TRANS(SocketSendFd), + TRANS(SocketRecvFd), +#endif + TRANS(SocketDisconnect), + TRANS(SocketUNIXClose), + TRANS(SocketUNIXCloseForCloning), + }; +#endif /* !LOCALCONN */ +# ifdef TRANS_SERVER +# if !defined(LOCALCONN) +static const char* unix_nolisten[] = { "local" , NULL }; +# endif +# endif + +static Xtransport TRANS(SocketUNIXFuncs) = { + /* Socket Interface */ + "unix", +#if !defined(LOCALCONN) && !defined(HAVE_ABSTRACT_SOCKETS) + TRANS_ALIAS, +#else + 0, +#endif +#ifdef TRANS_CLIENT + TRANS(SocketOpenCOTSClient), +#endif /* TRANS_CLIENT */ +#ifdef TRANS_SERVER +#if !defined(LOCALCONN) + unix_nolisten, +#else + NULL, +#endif + TRANS(SocketOpenCOTSServer), +#endif /* TRANS_SERVER */ +#ifdef TRANS_REOPEN + TRANS(SocketReopenCOTSServer), +#endif + TRANS(SocketSetOption), +#ifdef TRANS_SERVER + TRANS(SocketUNIXCreateListener), + TRANS(SocketUNIXResetListener), + TRANS(SocketUNIXAccept), +#endif /* TRANS_SERVER */ +#ifdef TRANS_CLIENT + TRANS(SocketUNIXConnect), +#endif /* TRANS_CLIENT */ + TRANS(SocketBytesReadable), + TRANS(SocketRead), + TRANS(SocketWrite), + TRANS(SocketReadv), + TRANS(SocketWritev), +#if XTRANS_SEND_FDS + TRANS(SocketSendFd), + TRANS(SocketRecvFd), +#endif + TRANS(SocketDisconnect), + TRANS(SocketUNIXClose), + TRANS(SocketUNIXCloseForCloning), + }; + +#endif /* UNIXCONN */ diff --git a/os/Xtransutil.c b/os/Xtransutil.c new file mode 100644 index 000000000..2aa468625 --- /dev/null +++ b/os/Xtransutil.c @@ -0,0 +1,631 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCRS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * These are some utility functions created for convenience or to provide + * an interface that is similar to an existing interface. These are built + * only using the Transport Independent API, and have no knowledge of + * the internal implementation. + */ + +#ifdef XTHREADS +#include +#endif +#ifdef WIN32 +#include +#include +#endif + +#if defined(IPv6) && !defined(AF_INET6) +#error "Cannot build IPv6 support without AF_INET6" +#endif + +/* Temporary workaround for consumers whose configure scripts were + generated with pre-1.6 versions of xtrans.m4 */ +#if defined(IPv6) && !defined(HAVE_INET_NTOP) +#define HAVE_INET_NTOP +#endif + +#ifdef X11_t + +/* + * These values come from X.h and Xauth.h, and MUST match them. Some + * of these values are also defined by the ChangeHost protocol message. + */ + +#define FamilyInternet 0 /* IPv4 */ +#define FamilyDECnet 1 +#define FamilyChaos 2 +#define FamilyInternet6 6 +#define FamilyAmoeba 33 +#define FamilyLocalHost 252 +#define FamilyKrb5Principal 253 +#define FamilyNetname 254 +#define FamilyLocal 256 +#define FamilyWild 65535 + +/* + * TRANS(ConvertAddress) converts a sockaddr based address to an + * X authorization based address. Some of this is defined as part of + * the ChangeHost protocol. The rest is just done in a consistent manner. + */ + +int +TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) + +{ + + prmsg(2,"ConvertAddress(%d,%d,%p)\n",*familyp,*addrlenp,*addrp); + + switch( *familyp ) + { +#if defined(TCPCONN) + case AF_INET: + { + /* + * Check for the BSD hack localhost address 127.0.0.1. + * In this case, we are really FamilyLocal. + */ + + struct sockaddr_in saddr; + int len = sizeof(saddr.sin_addr.s_addr); + char *cp = (char *) &saddr.sin_addr.s_addr; + + memcpy (&saddr, *addrp, sizeof (struct sockaddr_in)); + + if ((len == 4) && (cp[0] == 127) && (cp[1] == 0) && + (cp[2] == 0) && (cp[3] == 1)) + { + *familyp=FamilyLocal; + } + else + { + *familyp=FamilyInternet; + *addrlenp=len; + memcpy(*addrp,&saddr.sin_addr,len); + } + break; + } + +#ifdef IPv6 + case AF_INET6: + { + struct sockaddr_in6 saddr6; + + memcpy (&saddr6, *addrp, sizeof (struct sockaddr_in6)); + + if (IN6_IS_ADDR_LOOPBACK(&saddr6.sin6_addr)) + { + *familyp=FamilyLocal; + } + else if (IN6_IS_ADDR_V4MAPPED(&(saddr6.sin6_addr))) { + char *cp = (char *) &saddr6.sin6_addr.s6_addr[12]; + + if ((cp[0] == 127) && (cp[1] == 0) && + (cp[2] == 0) && (cp[3] == 1)) + { + *familyp=FamilyLocal; + } + else + { + *familyp=FamilyInternet; + *addrlenp = sizeof (struct in_addr); + memcpy(*addrp,cp,*addrlenp); + } + } + else + { + *familyp=FamilyInternet6; + *addrlenp=sizeof(saddr6.sin6_addr); + memcpy(*addrp,&saddr6.sin6_addr,sizeof(saddr6.sin6_addr)); + } + break; + } +#endif /* IPv6 */ +#endif /* defined(TCPCONN) */ + + +#if defined(UNIXCONN) || defined(LOCALCONN) + case AF_UNIX: + { + *familyp=FamilyLocal; + break; + } +#endif /* defined(UNIXCONN) || defined(LOCALCONN) */ + + + default: + prmsg(1,"ConvertAddress: Unknown family type %d\n", + *familyp); + return -1; + } + + + if (*familyp == FamilyLocal) + { + /* + * In the case of a local connection, we need to get the + * host name for authentication. + */ + + char hostnamebuf[256]; + int len = TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf); + + if (len > 0) { + if (*addrp && *addrlenp < (len + 1)) + { + free (*addrp); + *addrp = NULL; + } + if (!*addrp) + *addrp = malloc (len + 1); + if (*addrp) { + strcpy ((char *) *addrp, hostnamebuf); + *addrlenp = len; + } else { + *addrlenp = 0; + } + } + else + { + if (*addrp) + free (*addrp); + *addrp = NULL; + *addrlenp = 0; + } + } + + return 0; +} + +#endif /* X11_t */ + +#ifdef ICE_t + +/* Needed for _XGethostbyaddr usage in TRANS(GetPeerNetworkId) */ +# if defined(TCPCONN) || defined(UNIXCONN) +# define X_INCLUDE_NETDB_H +# define XOS_USE_NO_LOCKING +# include +# endif + +#include + +char * +TRANS(GetMyNetworkId) (XtransConnInfo ciptr) + +{ + int family = ciptr->family; + char *addr = ciptr->addr; + char hostnamebuf[256]; + char *networkId = NULL; + const char *transName = ciptr->transptr->TransName; + + if (gethostname (hostnamebuf, sizeof (hostnamebuf)) < 0) + { + return (NULL); + } + + switch (family) + { +#if defined(UNIXCONN) || defined(LOCALCONN) + case AF_UNIX: + { + struct sockaddr_un *saddr = (struct sockaddr_un *) addr; + networkId = malloc (3 + strlen (transName) + + strlen (hostnamebuf) + strlen (saddr->sun_path)); + if (networkId != NULL) + sprintf (networkId, "%s/%s:%s", transName, + hostnamebuf, saddr->sun_path); + break; + } +#endif /* defined(UNIXCONN) || defined(LOCALCONN) */ + +#if defined(TCPCONN) + case AF_INET: +#ifdef IPv6 + case AF_INET6: +#endif + { + struct sockaddr_in *saddr = (struct sockaddr_in *) addr; +#ifdef IPv6 + struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) addr; +#endif + int portnum; + char portnumbuf[10]; + + +#ifdef IPv6 + if (family == AF_INET6) + portnum = ntohs (saddr6->sin6_port); + else +#endif + portnum = ntohs (saddr->sin_port); + + snprintf (portnumbuf, sizeof(portnumbuf), "%d", portnum); + networkId = malloc (3 + strlen (transName) + + strlen (hostnamebuf) + strlen (portnumbuf)); + if (networkId != NULL) + sprintf (networkId, "%s/%s:%s", transName, hostnamebuf, portnumbuf); + break; + } +#endif /* defined(TCPCONN) */ + + + default: + break; + } + + return (networkId); +} + +#include +static jmp_buf env; + +#ifdef SIGALRM +static volatile int nameserver_timedout = 0; + +static void +nameserver_lost(int sig _X_UNUSED) +{ + nameserver_timedout = 1; + longjmp (env, -1); + /* NOTREACHED */ +} +#endif /* SIGALARM */ + + +char * +TRANS(GetPeerNetworkId) (XtransConnInfo ciptr) + +{ + int family = ciptr->family; + char *peer_addr = ciptr->peeraddr; + char *hostname; + char addrbuf[256]; + const char *addr = NULL; + + switch (family) + { + case AF_UNSPEC: +#if defined(UNIXCONN) || defined(LOCALCONN) + case AF_UNIX: + { + if (gethostname (addrbuf, sizeof (addrbuf)) == 0) + addr = addrbuf; + break; + } +#endif /* defined(UNIXCONN) || defined(LOCALCONN) */ + +#if defined(TCPCONN) + case AF_INET: +#ifdef IPv6 + case AF_INET6: +#endif + { + struct sockaddr_in *saddr = (struct sockaddr_in *) peer_addr; +#ifdef IPv6 + struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) peer_addr; +#endif + char *address; + int addresslen; +#ifdef XTHREADS_NEEDS_BYNAMEPARAMS + _Xgethostbynameparams hparams; +#endif + struct hostent * volatile hostp = NULL; + +#ifdef IPv6 + if (family == AF_INET6) + { + address = (char *) &saddr6->sin6_addr; + addresslen = sizeof (saddr6->sin6_addr); + } + else +#endif + { + address = (char *) &saddr->sin_addr; + addresslen = sizeof (saddr->sin_addr); + } + +#ifdef SIGALRM + /* + * gethostbyaddr can take a LONG time if the host does not exist. + * Assume that if it does not respond in NAMESERVER_TIMEOUT seconds + * that something is wrong and do not make the user wait. + * gethostbyaddr will continue after a signal, so we have to + * jump out of it. + */ + + nameserver_timedout = 0; + signal (SIGALRM, nameserver_lost); + alarm (4); + if (setjmp(env) == 0) { +#endif + hostp = _XGethostbyaddr (address, addresslen, family, hparams); +#ifdef SIGALRM + } + alarm (0); +#endif + if (hostp != NULL) + addr = hostp->h_name; + else +#ifdef HAVE_INET_NTOP + addr = inet_ntop (family, address, addrbuf, sizeof (addrbuf)); +#else + addr = inet_ntoa (saddr->sin_addr); +#endif + break; + } + +#endif /* defined(TCPCONN) */ + + + default: + return (NULL); + } + + + hostname = malloc (strlen (ciptr->transptr->TransName) + + (addr ? strlen (addr) : 0) + 2); + if (hostname) + { + strcpy (hostname, ciptr->transptr->TransName); + strcat (hostname, "/"); + if (addr) + strcat (hostname, addr); + } + return (hostname); +} + +#endif /* ICE_t */ + + +#if defined(WIN32) && defined(TCPCONN) +int +TRANS(WSAStartup) (void) +{ + static WSADATA wsadata; + + prmsg (2,"WSAStartup()\n"); + + if (!wsadata.wVersion && WSAStartup(MAKEWORD(2,2), &wsadata)) + return 1; + return 0; +} +#endif + +#ifdef TRANS_SERVER +#include +#include +#include + +#if !defined(S_IFLNK) && !defined(S_ISLNK) +#undef lstat +#define lstat(a,b) stat(a,b) +#endif + +#define FAIL_IF_NOMODE 1 +#define FAIL_IF_NOT_ROOT 2 +#define WARN_NO_ACCESS 4 + +/* + * We make the assumption that when the 'sticky' (t) bit is requested + * it's not save if the directory has non-root ownership or the sticky + * bit cannot be set and fail. + */ +static int +trans_mkdir(const char *path, int mode) +{ + struct stat buf; + + if (lstat(path, &buf) != 0) { + if (errno != ENOENT) { + prmsg(1, "mkdir: ERROR: (l)stat failed for %s (%d)\n", + path, errno); + return -1; + } + /* Dir doesn't exist. Try to create it */ + +#if !defined(WIN32) && !defined(__CYGWIN__) + /* + * 'sticky' bit requested: assume application makes + * certain security implications. If effective user ID + * is != 0: fail as we may not be able to meet them. + */ + if (geteuid() != 0) { + if (mode & 01000) { + prmsg(1, "mkdir: ERROR: euid != 0," + "directory %s will not be created.\n", + path); +#ifdef FAIL_HARD + return -1; +#endif + } else { + prmsg(1, "mkdir: Cannot create %s with root ownership\n", + path); + } + } +#endif + +#ifndef WIN32 + if (mkdir(path, mode) == 0) { + if (chmod(path, mode)) { + prmsg(1, "mkdir: ERROR: Mode of %s should be set to %04o\n", + path, mode); +#ifdef FAIL_HARD + return -1; +#endif + } +#else + if (mkdir(path) == 0) { +#endif + } else { + prmsg(1, "mkdir: ERROR: Cannot create %s\n", + path); + return -1; + } + + return 0; + + } else { + if (S_ISDIR(buf.st_mode)) { + int updateOwner = 0; + int updateMode = 0; + int updatedOwner = 0; + int updatedMode = 0; + int status = 0; + /* Check if the directory's ownership is OK. */ + if (buf.st_uid != 0) + updateOwner = 1; + + /* + * Check if the directory's mode is OK. An exact match isn't + * required, just a mode that isn't more permissive than the + * one requested. + */ + if ((~mode) & 0077 & buf.st_mode) + updateMode = 1; + + /* + * If the directory is not writeable not everybody may + * be able to create sockets. Therefore warn if mode + * cannot be fixed. + */ + if ((~buf.st_mode) & 0022 & mode) { + updateMode = 1; + status |= WARN_NO_ACCESS; + } + + /* + * If 'sticky' bit is requested fail if owner isn't root + * as we assume the caller makes certain security implications + */ + if (mode & 01000) { + status |= FAIL_IF_NOT_ROOT; + if (!(buf.st_mode & 01000)) { + status |= FAIL_IF_NOMODE; + updateMode = 1; + } + } + +#ifdef HAS_FCHOWN + /* + * If fchown(2) and fchmod(2) are available, try to correct the + * directory's owner and mode. Otherwise it isn't safe to attempt + * to do this. + */ + if (updateMode || updateOwner) { + int fd = -1; + struct stat fbuf; + if ((fd = open(path, O_RDONLY)) != -1) { + if (fstat(fd, &fbuf) == -1) { + prmsg(1, "mkdir: ERROR: fstat failed for %s (%d)\n", + path, errno); + close(fd); + return -1; + } + /* + * Verify that we've opened the same directory as was + * checked above. + */ + if (!S_ISDIR(fbuf.st_mode) || + buf.st_dev != fbuf.st_dev || + buf.st_ino != fbuf.st_ino) { + prmsg(1, "mkdir: ERROR: inode for %s changed\n", + path); + close(fd); + return -1; + } + if (updateOwner && fchown(fd, 0, 0) == 0) + updatedOwner = 1; + if (updateMode && fchmod(fd, mode) == 0) + updatedMode = 1; + close(fd); + } + } +#endif + + if (updateOwner && !updatedOwner) { +#ifdef FAIL_HARD + if (status & FAIL_IF_NOT_ROOT) { + prmsg(1, "mkdir: ERROR: Owner of %s must be set to root\n", + path); + return -1; + } +#endif +#if !defined(__APPLE_CC__) && !defined(__CYGWIN__) + prmsg(1, "mkdir: Owner of %s should be set to root\n", + path); +#endif + } + + if (updateMode && !updatedMode) { +#ifdef FAIL_HARD + if (status & FAIL_IF_NOMODE) { + prmsg(1, "mkdir: ERROR: Mode of %s must be set to %04o\n", + path, mode); + return -1; + } +#endif + prmsg(1, "mkdir: Mode of %s should be set to %04o\n", + path, mode); + if (status & WARN_NO_ACCESS) { + prmsg(1, "mkdir: this may cause subsequent errors\n"); + } + } + return 0; + } + return -1; + } + + /* In all other cases, fail */ + return -1; +} + +#endif /* TRANS_SERVER */ diff --git a/os/transport.c b/os/transport.c new file mode 100644 index 000000000..b62fc7b64 --- /dev/null +++ b/os/transport.c @@ -0,0 +1,74 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + * Copyright 1993, 1994 NCR Corporation - Dayton, Ohio, USA + * + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name NCR not be used in advertising + * or publicity pertaining to distribution of the software without specific, + * written prior permission. NCR makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL NCR BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#define XTRANS_TRANSPORT_C /* used to flag Xtransint.h that it's being used + here, not just #included in another file */ + +#include "Xtransint.h" + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wformat-nonliteral" +#pragma clang diagnostic ignored "-Wdeprecated-declarations" +#endif + +#ifdef LOCALCONN +#include "Xtranslcl.c" +#endif +#if defined(TCPCONN) || defined(UNIXCONN) +#include "Xtranssock.c" +#endif +#include "Xtrans.c" +#include "Xtransutil.c" + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif From 6a0c1a7d9f30a1b750fc8eb673b16274fd82c432 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Tue, 5 Nov 2024 15:51:46 +0100 Subject: [PATCH 02/23] os: use internal xtrans instead of external library Now that we've got xtrans bundled in our source tree, use this one and drop the external dependency. Closes: https://gitlab.freedesktop.org/xorg/xserver/-/issues/691 Signed-off-by: Enrico Weigelt, metux IT consult --- .appveyor.yml | 3 +-- .gitlab-ci.yml | 2 +- .gitlab-ci/cross-prereqs-build.sh | 1 - .gitlab-ci/debian-install.sh | 1 - hw/xwin/windisplay.c | 2 +- meson.build | 2 -- os/Xtransint.h | 2 +- os/access.c | 2 +- os/connection.c | 4 ++-- os/io.c | 2 +- os/utils.c | 2 +- os/xdmauth.c | 2 +- os/xdmcp.c | 4 ++-- os/xstrans.c | 2 +- 14 files changed, 13 insertions(+), 18 deletions(-) diff --git a/.appveyor.yml b/.appveyor.yml index c023790cf..a925a84b7 100644 --- a/.appveyor.yml +++ b/.appveyor.yml @@ -64,8 +64,7 @@ font-util,\ khronos-opengl-registry,\ python38-lxml,\ xkbcomp-devel,\ -xkeyboard-config,\ -xtrans" +xkeyboard-config" - echo Install done - "%CYGWIN_ROOT%\\%SETUP% -qnNdO -R %CYGWIN_ROOT% -s %CYGWIN_MIRROR% -l %CACHE% -g" cache: diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index f208bd119..c6420f9c1 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -108,7 +108,7 @@ stages: FDO_DISTRIBUTION_TAG: '$XORG_FREEBSD_TAG' FDO_DISTRIBUTION_VERSION: '$XORG_FREEBSD_VERSION' FDO_DISTRIBUTION_EXEC: '' - FDO_DISTRIBUTION_PACKAGES: 'git gcc pkgconf autoconf automake libtool xorg-macros xorgproto bash meson ninja pixman xtrans libXau libXdmcp libXfont2 libxkbfile libxcvt libpciaccess font-util libepoll-shim libxvmc xcb-util xcb-util-wm' + FDO_DISTRIBUTION_PACKAGES: 'git gcc pkgconf autoconf automake libtool xorg-macros xorgproto bash meson ninja pixman libXau libXdmcp libXfont2 libxkbfile libxcvt libpciaccess font-util libepoll-shim libxvmc xcb-util xcb-util-wm' FDO_IMAGE_SIZE: '30G' debian-bullseye: diff --git a/.gitlab-ci/cross-prereqs-build.sh b/.gitlab-ci/cross-prereqs-build.sh index fb788895b..2c1f3464a 100755 --- a/.gitlab-ci/cross-prereqs-build.sh +++ b/.gitlab-ci/cross-prereqs-build.sh @@ -53,7 +53,6 @@ build 'https://gitlab.freedesktop.org/xorg/proto/xorgproto.git' 'xorgproto-2024. build 'https://gitlab.freedesktop.org/xorg/lib/libXau.git' 'libXau-1.0.9' build 'https://gitlab.freedesktop.org/xorg/proto/xcbproto.git' 'xcb-proto-1.14.1' build 'https://gitlab.freedesktop.org/xorg/lib/libxcb.git' 'libxcb-1.14' -build 'https://gitlab.freedesktop.org/xorg/lib/libxtrans.git' 'xtrans-1.4.0' # the default value of keysymdefdir is taken from the includedir variable for # xproto, which isn't adjusted by pkg-config for the sysroot # Using -fcommon to address build failure when cross-compiling for windows. diff --git a/.gitlab-ci/debian-install.sh b/.gitlab-ci/debian-install.sh index ff4f62eb2..b505d45a1 100644 --- a/.gitlab-ci/debian-install.sh +++ b/.gitlab-ci/debian-install.sh @@ -122,7 +122,6 @@ apt-get install -y \ x11-xkb-utils \ xfonts-utils \ xkb-data \ - xtrans-dev \ xutils-dev .gitlab-ci/cross-prereqs-build.sh i686-w64-mingw32 diff --git a/hw/xwin/windisplay.c b/hw/xwin/windisplay.c index 52ece1d88..637ab0283 100644 --- a/hw/xwin/windisplay.c +++ b/hw/xwin/windisplay.c @@ -37,7 +37,7 @@ #define XSERV_t #define TRANS_SERVER -#include +#include "os/Xtrans.h" /* Generate a display name string referring to the display of this server, diff --git a/meson.build b/meson.build index 2a5500635..c579f207e 100644 --- a/meson.build +++ b/meson.build @@ -83,7 +83,6 @@ damageproto_dep = dependency('damageproto', version: '>= 1.1', fallback: ['xorgp xcmiscproto_dep = dependency('xcmiscproto', version: '>= 1.2.0', fallback: ['xorgproto', 'ext_xorgproto']) bigreqsproto_dep = dependency('bigreqsproto', version: '>= 1.1.0', fallback: ['xorgproto', 'ext_xorgproto']) presentproto_dep = dependency('presentproto', version: '>= 1.4', fallback: ['xorgproto', 'ext_xorgproto']) -xtrans_dep = dependency('xtrans', version: '>= 1.3.5') videoproto_dep = dependency('videoproto', fallback: ['xorgproto', 'ext_xorgproto']) compositeproto_dep = dependency('compositeproto', version: '>= 0.4', fallback: ['xorgproto', 'ext_xorgproto']) @@ -578,7 +577,6 @@ common_dep = [ xcmiscproto_dep, bigreqsproto_dep, presentproto_dep, - xtrans_dep, libsystemd_daemon_dep, videoproto_dep, diff --git a/os/Xtransint.h b/os/Xtransint.h index 82c8755c8..13a668ba3 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -76,7 +76,7 @@ from The Open Group. # define _WILLWINSOCK_ #endif -#include "Xtrans.h" +#include "os/Xtrans.h" #ifndef _X_UNUSED /* Defined in Xfuncproto.h in xproto >= 7.0.22 */ # define _X_UNUSED /* */ diff --git a/os/access.c b/os/access.c index 34d735bfa..ce74eafbc 100644 --- a/os/access.c +++ b/os/access.c @@ -87,7 +87,7 @@ SOFTWARE. #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include +#include "os/Xtrans.h" #include #include #include diff --git a/os/connection.c b/os/connection.c index 64245af6b..cee77fa9f 100644 --- a/os/connection.c +++ b/os/connection.c @@ -70,8 +70,8 @@ SOFTWARE. #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include -#include +#include "os/Xtrans.h" +#include "os/Xtransint.h" #include #include #include diff --git a/os/io.c b/os/io.c index 948660996..10a666c0c 100644 --- a/os/io.c +++ b/os/io.c @@ -64,7 +64,7 @@ SOFTWARE. #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include +#include "os/Xtrans.h" #include #include #if !defined(WIN32) diff --git a/os/utils.c b/os/utils.c index 00c6ebb3e..198e3e0cc 100644 --- a/os/utils.c +++ b/os/utils.c @@ -65,7 +65,7 @@ OR PERFORMANCE OF THIS SOFTWARE. #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include +#include "os/Xtrans.h" #include diff --git a/os/xdmauth.c b/os/xdmauth.c index fc5cbe5c5..8f30ef946 100644 --- a/os/xdmauth.c +++ b/os/xdmauth.c @@ -40,9 +40,9 @@ from The Open Group. #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include #include "os/auth.h" +#include "os/Xtrans.h" #include "os.h" #include "osdep.h" diff --git a/os/xdmcp.c b/os/xdmcp.c index 550979e51..3168d8608 100644 --- a/os/xdmcp.c +++ b/os/xdmcp.c @@ -20,7 +20,7 @@ #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include +#include "os/Xtrans.h" #endif #include @@ -51,7 +51,7 @@ #define XSERV_t #define TRANS_SERVER #define TRANS_REOPEN -#include +#include "os/Xtrans.h" #ifdef XDMCP #undef REQUEST diff --git a/os/xstrans.c b/os/xstrans.c index c9363db71..bd60a18be 100644 --- a/os/xstrans.c +++ b/os/xstrans.c @@ -5,4 +5,4 @@ #define TRANS_REOPEN #define TRANS_SERVER #define XSERV_t -#include +#include "os/transport.c" From 6f317307851c69ba20a97ab8ad4545f6802e5ef5 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 17:01:47 +0200 Subject: [PATCH 03/23] os: xtrans: drop X_NO_SYS_UN Not defined anywhere, so no need to check for it. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtranslcl.c | 2 -- os/Xtranssock.c | 2 -- 2 files changed, 4 deletions(-) diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index ba33bce38..4e79c68d8 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -90,9 +90,7 @@ from The Open Group. */ #include -#ifndef X_NO_SYS_UN #include -#endif /* Types of local connections supported: diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 4c7f80bec..168148a3b 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -89,9 +89,7 @@ from the copyright holders. #endif #ifdef UNIXCONN -#ifndef X_NO_SYS_UN #include -#endif #include #endif From ada655a52563afca23be5c6f3553f223ddb17ba7 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 15:39:26 +0200 Subject: [PATCH 04/23] os: xtrans: drop unused GetPeerNetworkId() Not used anywhere, so let's drop it. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.h | 5 -- os/Xtransutil.c | 122 ------------------------------------------------ 2 files changed, 127 deletions(-) diff --git a/os/Xtrans.h b/os/Xtrans.h index 8cf0dafc0..0ff212309 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -402,11 +402,6 @@ TRANS(GetMyNetworkId)( XtransConnInfo /* ciptr */ ); -char * -TRANS(GetPeerNetworkId)( - XtransConnInfo /* ciptr */ -); - #endif /* ICE_t */ int diff --git a/os/Xtransutil.c b/os/Xtransutil.c index 2aa468625..447b1c4e9 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -228,13 +228,6 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) #ifdef ICE_t -/* Needed for _XGethostbyaddr usage in TRANS(GetPeerNetworkId) */ -# if defined(TCPCONN) || defined(UNIXCONN) -# define X_INCLUDE_NETDB_H -# define XOS_USE_NO_LOCKING -# include -# endif - #include char * @@ -308,121 +301,6 @@ TRANS(GetMyNetworkId) (XtransConnInfo ciptr) #include static jmp_buf env; -#ifdef SIGALRM -static volatile int nameserver_timedout = 0; - -static void -nameserver_lost(int sig _X_UNUSED) -{ - nameserver_timedout = 1; - longjmp (env, -1); - /* NOTREACHED */ -} -#endif /* SIGALARM */ - - -char * -TRANS(GetPeerNetworkId) (XtransConnInfo ciptr) - -{ - int family = ciptr->family; - char *peer_addr = ciptr->peeraddr; - char *hostname; - char addrbuf[256]; - const char *addr = NULL; - - switch (family) - { - case AF_UNSPEC: -#if defined(UNIXCONN) || defined(LOCALCONN) - case AF_UNIX: - { - if (gethostname (addrbuf, sizeof (addrbuf)) == 0) - addr = addrbuf; - break; - } -#endif /* defined(UNIXCONN) || defined(LOCALCONN) */ - -#if defined(TCPCONN) - case AF_INET: -#ifdef IPv6 - case AF_INET6: -#endif - { - struct sockaddr_in *saddr = (struct sockaddr_in *) peer_addr; -#ifdef IPv6 - struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) peer_addr; -#endif - char *address; - int addresslen; -#ifdef XTHREADS_NEEDS_BYNAMEPARAMS - _Xgethostbynameparams hparams; -#endif - struct hostent * volatile hostp = NULL; - -#ifdef IPv6 - if (family == AF_INET6) - { - address = (char *) &saddr6->sin6_addr; - addresslen = sizeof (saddr6->sin6_addr); - } - else -#endif - { - address = (char *) &saddr->sin_addr; - addresslen = sizeof (saddr->sin_addr); - } - -#ifdef SIGALRM - /* - * gethostbyaddr can take a LONG time if the host does not exist. - * Assume that if it does not respond in NAMESERVER_TIMEOUT seconds - * that something is wrong and do not make the user wait. - * gethostbyaddr will continue after a signal, so we have to - * jump out of it. - */ - - nameserver_timedout = 0; - signal (SIGALRM, nameserver_lost); - alarm (4); - if (setjmp(env) == 0) { -#endif - hostp = _XGethostbyaddr (address, addresslen, family, hparams); -#ifdef SIGALRM - } - alarm (0); -#endif - if (hostp != NULL) - addr = hostp->h_name; - else -#ifdef HAVE_INET_NTOP - addr = inet_ntop (family, address, addrbuf, sizeof (addrbuf)); -#else - addr = inet_ntoa (saddr->sin_addr); -#endif - break; - } - -#endif /* defined(TCPCONN) */ - - - default: - return (NULL); - } - - - hostname = malloc (strlen (ciptr->transptr->TransName) + - (addr ? strlen (addr) : 0) + 2); - if (hostname) - { - strcpy (hostname, ciptr->transptr->TransName); - strcat (hostname, "/"); - if (addr) - strcat (hostname, addr); - } - return (hostname); -} - #endif /* ICE_t */ From 12da711d7ccb6aecd3926d5894e333abde55928f Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 15:42:15 +0200 Subject: [PATCH 05/23] os: xtrans: drop GetMyNetworkId() Not used anywhere, so lets drop it. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.h | 9 ------- os/Xtransutil.c | 68 ------------------------------------------------- 2 files changed, 77 deletions(-) diff --git a/os/Xtrans.h b/os/Xtrans.h index 0ff212309..cacdf94e4 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -395,15 +395,6 @@ int TRANS(ConvertAddress)( #endif /* X11_t */ -#ifdef ICE_t - -char * -TRANS(GetMyNetworkId)( - XtransConnInfo /* ciptr */ -); - -#endif /* ICE_t */ - int TRANS(GetHostname) ( char * /* buf */, diff --git a/os/Xtransutil.c b/os/Xtransutil.c index 447b1c4e9..ebc33851b 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -230,74 +230,6 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) #include -char * -TRANS(GetMyNetworkId) (XtransConnInfo ciptr) - -{ - int family = ciptr->family; - char *addr = ciptr->addr; - char hostnamebuf[256]; - char *networkId = NULL; - const char *transName = ciptr->transptr->TransName; - - if (gethostname (hostnamebuf, sizeof (hostnamebuf)) < 0) - { - return (NULL); - } - - switch (family) - { -#if defined(UNIXCONN) || defined(LOCALCONN) - case AF_UNIX: - { - struct sockaddr_un *saddr = (struct sockaddr_un *) addr; - networkId = malloc (3 + strlen (transName) + - strlen (hostnamebuf) + strlen (saddr->sun_path)); - if (networkId != NULL) - sprintf (networkId, "%s/%s:%s", transName, - hostnamebuf, saddr->sun_path); - break; - } -#endif /* defined(UNIXCONN) || defined(LOCALCONN) */ - -#if defined(TCPCONN) - case AF_INET: -#ifdef IPv6 - case AF_INET6: -#endif - { - struct sockaddr_in *saddr = (struct sockaddr_in *) addr; -#ifdef IPv6 - struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) addr; -#endif - int portnum; - char portnumbuf[10]; - - -#ifdef IPv6 - if (family == AF_INET6) - portnum = ntohs (saddr6->sin6_port); - else -#endif - portnum = ntohs (saddr->sin_port); - - snprintf (portnumbuf, sizeof(portnumbuf), "%d", portnum); - networkId = malloc (3 + strlen (transName) + - strlen (hostnamebuf) + strlen (portnumbuf)); - if (networkId != NULL) - sprintf (networkId, "%s/%s:%s", transName, hostnamebuf, portnumbuf); - break; - } -#endif /* defined(TCPCONN) */ - - - default: - break; - } - - return (networkId); -} - #include static jmp_buf env; From be255fd05944b71577fec04605a83a24546b5732 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 6 Nov 2024 11:36:49 +0100 Subject: [PATCH 06/23] os: xtrans: drop ICE_t Not used anywhere. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.h | 7 ------- os/Xtranslcl.c | 6 ------ os/Xtranssock.c | 5 ----- os/Xtransutil.c | 10 ---------- 4 files changed, 28 deletions(-) diff --git a/os/Xtrans.h b/os/Xtrans.h index cacdf94e4..4f84a6d1b 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -104,13 +104,6 @@ static const char *__xtransname = "_FontTrans"; #endif #endif /* FONT_t */ -#ifdef ICE_t -#define TRANS(func) _IceTrans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_IceTrans"; -#endif -#endif /* ICE_t */ - #if !defined(TRANS) #define TRANS(func) _XTrans##func #ifdef XTRANSDEBUG diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 4e79c68d8..e6ee5fc04 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -226,12 +226,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, #if defined(FS_t) || defined (FONT_t) #define NAMEDNODENAME "/tmp/.font-pipe/fs" #endif -#if defined(ICE_t) -#define NAMEDNODENAME "/tmp/.ICE-pipe/" -#endif - - - #ifdef LOCAL_TRANS_NAMED diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 168148a3b..a89f67335 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -242,11 +242,6 @@ is_numeric (const char *str) #define UNIX_PATH "/tmp/.font-unix/fs" #define UNIX_DIR "/tmp/.font-unix" #endif /* FS_t || FONT_t */ -#if defined(ICE_t) -#define UNIX_PATH "/tmp/.ICE-unix/" -#define UNIX_DIR "/tmp/.ICE-unix" -#endif /* ICE_t */ - #endif /* UNIXCONN */ diff --git a/os/Xtransutil.c b/os/Xtransutil.c index ebc33851b..5cb937521 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -226,16 +226,6 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) #endif /* X11_t */ -#ifdef ICE_t - -#include - -#include -static jmp_buf env; - -#endif /* ICE_t */ - - #if defined(WIN32) && defined(TCPCONN) int TRANS(WSAStartup) (void) From 6a2f1e7bdb6a0ef4cabe42a5cc3e3405a71bbf91 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 16:31:45 +0200 Subject: [PATCH 07/23] os: xtrans: drop FONT_t Not used anywhere, so no need to keep it around anymore. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 2 +- os/Xtrans.h | 7 ------- os/Xtranslcl.c | 2 +- os/Xtranssock.c | 6 +++--- 4 files changed, 5 insertions(+), 12 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index 617084165..eb347516e 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -342,7 +342,7 @@ TRANS(ParseAddress) (const char *address, _port = mybuf; -#if defined(FONT_t) || defined(FS_t) +#if defined(FS_t) /* * Is there an optional catalogue list? */ diff --git a/os/Xtrans.h b/os/Xtrans.h index 4f84a6d1b..b383fb231 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -97,13 +97,6 @@ static const char *__xtransname = "_FSTrans"; #endif #endif /* FS_t */ -#ifdef FONT_t -#define TRANS(func) _FontTrans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_FontTrans"; -#endif -#endif /* FONT_t */ - #if !defined(TRANS) #define TRANS(func) _XTrans##func #ifdef XTRANSDEBUG diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index e6ee5fc04..9defc902b 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -223,7 +223,7 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, #if defined(XIM_t) #define NAMEDNODENAME "/tmp/.XIM-pipe/XIM" #endif -#if defined(FS_t) || defined (FONT_t) +#if defined(FS_t) #define NAMEDNODENAME "/tmp/.font-pipe/fs" #endif diff --git a/os/Xtranssock.c b/os/Xtranssock.c index a89f67335..28857d137 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -238,10 +238,10 @@ is_numeric (const char *str) #define UNIX_PATH "/tmp/.XIM-unix/XIM" #define UNIX_DIR "/tmp/.XIM-unix" #endif /* XIM_t */ -#if defined(FS_t) || defined(FONT_t) +#if defined(FS_t) #define UNIX_PATH "/tmp/.font-unix/fs" #define UNIX_DIR "/tmp/.font-unix" -#endif /* FS_t || FONT_t */ +#endif /* FS_t */ #endif /* UNIXCONN */ @@ -400,7 +400,7 @@ TRANS(SocketOpen) (int i, int type) Sockettrans2devtab[i].protocol); #ifndef WIN32 -#if (defined(X11_t) && !defined(USE_POLL)) || defined(FS_t) || defined(FONT_t) +#if (defined(X11_t) && !defined(USE_POLL)) || defined(FS_t) if (ciptr->fd >= sysconf(_SC_OPEN_MAX)) { prmsg (2, "SocketOpen: socket() returned out of range fd %d\n", From 70981fffb06867a4b6cce1075ae7d6e84860ab6c Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 6 Nov 2024 11:39:09 +0100 Subject: [PATCH 08/23] os: xtrans: drop FS_t Not defined anywhere, so no need to keep it around anymore. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 15 --------------- os/Xtrans.h | 7 ------- os/Xtranslcl.c | 3 --- os/Xtranssock.c | 6 +----- 4 files changed, 1 insertion(+), 30 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index eb347516e..4c1286fc8 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -342,21 +342,6 @@ TRANS(ParseAddress) (const char *address, _port = mybuf; -#if defined(FS_t) - /* - * Is there an optional catalogue list? - */ - - if ((mybuf = strchr (mybuf,'/')) != NULL) - *mybuf ++= '\0'; - - /* - * The rest, if any, is the (currently unused) catalogue list. - * - * _catalogue = mybuf; - */ -#endif - done_parsing: /* * Now that we have all of the components, allocate new diff --git a/os/Xtrans.h b/os/Xtrans.h index b383fb231..792324343 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -90,13 +90,6 @@ static const char *__xtransname = "_XimTrans"; #endif #endif /* XIM_t */ -#ifdef FS_t -#define TRANS(func) _FSTrans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_FSTrans"; -#endif -#endif /* FS_t */ - #if !defined(TRANS) #define TRANS(func) _XTrans##func #ifdef XTRANSDEBUG diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 9defc902b..1958c667d 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -223,9 +223,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, #if defined(XIM_t) #define NAMEDNODENAME "/tmp/.XIM-pipe/XIM" #endif -#if defined(FS_t) -#define NAMEDNODENAME "/tmp/.font-pipe/fs" -#endif #ifdef LOCAL_TRANS_NAMED diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 28857d137..8181726d3 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -238,10 +238,6 @@ is_numeric (const char *str) #define UNIX_PATH "/tmp/.XIM-unix/XIM" #define UNIX_DIR "/tmp/.XIM-unix" #endif /* XIM_t */ -#if defined(FS_t) -#define UNIX_PATH "/tmp/.font-unix/fs" -#define UNIX_DIR "/tmp/.font-unix" -#endif /* FS_t */ #endif /* UNIXCONN */ @@ -400,7 +396,7 @@ TRANS(SocketOpen) (int i, int type) Sockettrans2devtab[i].protocol); #ifndef WIN32 -#if (defined(X11_t) && !defined(USE_POLL)) || defined(FS_t) +#if (defined(X11_t) && !defined(USE_POLL)) if (ciptr->fd >= sysconf(_SC_OPEN_MAX)) { prmsg (2, "SocketOpen: socket() returned out of range fd %d\n", From baf23b30d247d908005f29291dc8476b9f7d6aad Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 6 Nov 2024 11:41:40 +0100 Subject: [PATCH 09/23] os: xtrans: drop XIM_t Not defined anywhere. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.h | 7 ------- os/Xtranslcl.c | 3 --- os/Xtranssock.c | 4 ---- 3 files changed, 14 deletions(-) diff --git a/os/Xtrans.h b/os/Xtrans.h index 792324343..3b7296dcb 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -83,13 +83,6 @@ static const char *__xtransname = "_XSERVTrans"; #define X11_t #endif /* XSERV_t */ -#ifdef XIM_t -#define TRANS(func) _XimXTrans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_XimTrans"; -#endif -#endif /* XIM_t */ - #if !defined(TRANS) #define TRANS(func) _XTrans##func #ifdef XTRANSDEBUG diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 1958c667d..a37f5066c 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -220,9 +220,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, #define NAMEDNODENAME "/tmp/.X11-pipe/X" #endif -#if defined(XIM_t) -#define NAMEDNODENAME "/tmp/.XIM-pipe/XIM" -#endif #ifdef LOCAL_TRANS_NAMED diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 8181726d3..6128bdb38 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -234,10 +234,6 @@ is_numeric (const char *str) #define UNIX_PATH "/tmp/.X11-unix/X" #define UNIX_DIR "/tmp/.X11-unix" #endif /* X11_t */ -#if defined(XIM_t) -#define UNIX_PATH "/tmp/.XIM-unix/XIM" -#define UNIX_DIR "/tmp/.XIM-unix" -#endif /* XIM_t */ #endif /* UNIXCONN */ From 258057b08563d25b266baf528de8034922eb745c Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 6 Nov 2024 11:46:19 +0100 Subject: [PATCH 10/23] os: xtrans: replace bzero by memset Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtranssock.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 6128bdb38..ec735dee8 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -292,7 +292,7 @@ TRANS(SocketINETGetAddr) (XtransConnInfo ciptr) prmsg (3,"SocketINETGetAddr(%p)\n", (void *) ciptr); - bzero(socknamePtr, namelen); + memset(socknamePtr, 0, namelen); if (getsockname (ciptr->fd,(struct sockaddr *) socknamePtr, (void *)&namelen) < 0) @@ -341,7 +341,7 @@ TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr) void *socknamePtr = &sockname; SOCKLEN_T namelen = sizeof(sockname); - bzero(socknamePtr, namelen); + memset(socknamePtr, 0, namelen); prmsg (3,"SocketINETGetPeerAddr(%p)\n", (void *) ciptr); @@ -898,7 +898,7 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, else sport = 0; - bzero(&sockname, sizeof(sockname)); + memset(&sockname, 0, sizeof(sockname)); if (Sockettrans2devtab[ciptr->index].family == AF_INET) { namelen = sizeof (struct sockaddr_in); #ifdef BSD44SOCKETS @@ -1382,7 +1382,7 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, strncpy(addrlist->host, host, sizeof(addrlist->host)); addrlist->host[sizeof(addrlist->host) - 1] = '\0'; - bzero(&hints,sizeof(hints)); + memset(&hints, 0, sizeof(hints)); #ifdef IPv6 if (strcmp(Sockettrans2devtab[ciptr->index].transname, "tcp") == 0) hints.ai_family = AF_UNSPEC; From 53de959813016bb3211fd189071b94efe9c29902 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 6 Nov 2024 11:48:33 +0100 Subject: [PATCH 11/23] os: xtrans: drop own VErrorF() and ErrorF() Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtransint.h | 26 +------------------------- 1 file changed, 1 insertion(+), 25 deletions(-) diff --git a/os/Xtransint.h b/os/Xtransint.h index 13a668ba3..2c87d7e08 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -371,31 +371,7 @@ static int trans_mkdir ( #ifdef XTRANSDEBUG #include -/* - * The X server and the font server both provide ErrorF() & VErrorF(). For - * other software that uses xtrans, we provide our own simple - * versions. - */ -# if (defined(XSERV_t) || defined(TRANS_HAS_ERRORF)) && defined(TRANS_SERVER) -# include "os.h" -# else -static inline void _X_ATTRIBUTE_PRINTF(1, 0) -VErrorF(const char *f, va_list args) -{ - vfprintf(stderr, f, args); - fflush(stderr); -} - -static inline void _X_ATTRIBUTE_PRINTF(1, 2) -ErrorF(const char *f, ...) -{ - va_list args; - - va_start(args, f); - VErrorF(f, args); - va_end(args); -} -# endif /* xserver */ +#include "os.h" #endif /* XTRANSDEBUG */ static inline void _X_ATTRIBUTE_PRINTF(2, 3) From 00316d71a7f6b9df6e2d66804a39ea668ac4f22f Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 15:56:57 +0100 Subject: [PATCH 12/23] os: xtrans: drop _WILLWINSOCK_ Not used anywhere. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtransint.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/os/Xtransint.h b/os/Xtransint.h index 2c87d7e08..b5f31ffd0 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -72,10 +72,6 @@ from The Open Group. # define XTRANSDEBUG 1 #endif -#ifdef WIN32 -# define _WILLWINSOCK_ -#endif - #include "os/Xtrans.h" #ifndef _X_UNUSED /* Defined in Xfuncproto.h in xproto >= 7.0.22 */ From 1dbc9d03ac9a6b4fba8e18b7cecad250f56ec190 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 16:10:51 +0100 Subject: [PATCH 13/23] os: xtrans: drop NEED_UTSNAME All our supported platforms have this utsname.h. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 22 +++------------------- os/Xtransint.h | 21 ++------------------- os/Xtranslcl.c | 6 ------ 3 files changed, 5 insertions(+), 44 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index 4c1286fc8..888a559df 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -53,6 +53,7 @@ from The Open Group. #ifdef HAVE_SYSTEMD_DAEMON #include #endif +#include /* * The transport table contains a definition for every transport (protocol) @@ -1316,35 +1317,18 @@ static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) #endif /* WIN32 */ -#if defined(_POSIX_SOURCE) || defined(SVR4) || defined(__SVR4) -#ifndef NEED_UTSNAME -#define NEED_UTSNAME -#endif -#include -#endif - /* * TRANS(GetHostname) - similar to gethostname but allows special processing. */ int TRANS(GetHostname) (char *buf, int maxlen) - { - int len; - -#ifdef NEED_UTSNAME struct utsname name; - uname (&name); - len = strlen (name.nodename); + + int len = strlen (name.nodename); if (len >= maxlen) len = maxlen - 1; memcpy (buf, name.nodename, len); buf[len] = '\0'; -#else - buf[0] = '\0'; - (void) gethostname (buf, maxlen); - buf [maxlen - 1] = '\0'; - len = strlen(buf); -#endif /* NEED_UTSNAME */ return len; } diff --git a/os/Xtransint.h b/os/Xtransint.h index b5f31ffd0..baf1f728b 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -74,10 +74,6 @@ from The Open Group. #include "os/Xtrans.h" -#ifndef _X_UNUSED /* Defined in Xfuncproto.h in xproto >= 7.0.22 */ -# define _X_UNUSED /* */ -#endif - #ifdef XTRANSDEBUG # include #endif /* XTRANSDEBUG */ @@ -85,23 +81,10 @@ from The Open Group. #include #ifndef WIN32 -# include +# include # include # include - -/* - * Moved the setting of NEED_UTSNAME to this header file from Xtrans.c, - * to avoid a race condition. JKJ (6/5/97) - */ - -# if defined(_POSIX_SOURCE) || defined(SVR4) || defined(__SVR4) -# ifndef NEED_UTSNAME -# define NEED_UTSNAME -# endif -# include -# endif - -# define ESET(val) errno = val +# define ESET(val) errno = val # define EGET() errno #else /* WIN32 */ diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index a37f5066c..b981ba441 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -798,9 +798,7 @@ TRANS(LocalGetNextTransport)(void) #endif } -#ifdef NEED_UTSNAME #include -#endif /* * Make sure 'host' is really local. @@ -815,15 +813,11 @@ HostReallyLocal (const char *host) * by either uname() or gethostname(). We try both if possible. */ -#ifdef NEED_UTSNAME struct utsname name; -#endif char buf[256]; -#ifdef NEED_UTSNAME if (uname (&name) >= 0 && strcmp (host, name.nodename) == 0) return (1); -#endif buf[0] = '\0'; (void) gethostname (buf, 256); From 13fd772406ae376c1aa6bcc6b6b527378dbdead3 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 19:44:43 +0100 Subject: [PATCH 14/23] os: xtrans: drop ifdef TRANS_SERVER it's always defined, no extra guards needed. Signed-off-by: Enrico Weigelt, metux IT consult --- hw/xwin/windisplay.c | 1 - os/Xtrans.c | 28 ----------------- os/Xtrans.h | 13 -------- os/Xtransint.h | 8 ----- os/Xtranslcl.c | 74 -------------------------------------------- os/Xtranssock.c | 39 +---------------------- os/Xtransutil.c | 3 -- os/access.c | 1 - os/connection.c | 1 - os/io.c | 1 - os/utils.c | 1 - os/xdmauth.c | 1 - os/xdmcp.c | 2 -- os/xstrans.c | 1 - 14 files changed, 1 insertion(+), 173 deletions(-) diff --git a/hw/xwin/windisplay.c b/hw/xwin/windisplay.c index 637ab0283..6ad8f6651 100644 --- a/hw/xwin/windisplay.c +++ b/hw/xwin/windisplay.c @@ -36,7 +36,6 @@ #include "winmsg.h" #define XSERV_t -#define TRANS_SERVER #include "os/Xtrans.h" /* diff --git a/os/Xtrans.c b/os/Xtrans.c index 888a559df..b7e0eb442 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -443,9 +443,7 @@ TRANS(Open) (int type, const char *address) #endif /* TRANS_CLIENT */ break; case XTRANS_OPEN_COTS_SERVER: -#ifdef TRANS_SERVER ciptr = thistrans->OpenCOTSServer(thistrans, protocol, host, port); -#endif /* TRANS_SERVER */ break; default: prmsg (1,"Open: Unknown Open type %d\n", type); @@ -564,9 +562,6 @@ TRANS(OpenCOTSClient) (const char *address) #endif /* TRANS_CLIENT */ - -#ifdef TRANS_SERVER - XtransConnInfo TRANS(OpenCOTSServer) (const char *address) @@ -575,9 +570,6 @@ TRANS(OpenCOTSServer) (const char *address) return TRANS(Open) (XTRANS_OPEN_COTS_SERVER, address); } -#endif /* TRANS_SERVER */ - - #ifdef TRANS_REOPEN XtransConnInfo @@ -696,18 +688,14 @@ TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) return ret; } -#ifdef TRANS_SERVER - int TRANS(CreateListener) (XtransConnInfo ciptr, const char *port, unsigned int flags) - { return ciptr->transptr->CreateListener (ciptr, port, flags); } int TRANS(Received) (const char * protocol) - { Xtransport *trans; int i = 0, ret = 0; @@ -735,7 +723,6 @@ TRANS(Received) (const char * protocol) int TRANS(NoListen) (const char * protocol) - { Xtransport *trans; int i = 0, ret = 0; @@ -802,7 +789,6 @@ TRANS(IsListening) (const char * protocol) int TRANS(ResetListener) (XtransConnInfo ciptr) - { if (ciptr->transptr->ResetListener) return ciptr->transptr->ResetListener (ciptr); @@ -810,10 +796,8 @@ TRANS(ResetListener) (XtransConnInfo ciptr) return TRANS_RESET_NOOP; } - XtransConnInfo TRANS(Accept) (XtransConnInfo ciptr, int *status) - { XtransConnInfo newciptr; @@ -827,9 +811,6 @@ TRANS(Accept) (XtransConnInfo ciptr, int *status) return newciptr; } -#endif /* TRANS_SERVER */ - - #ifdef TRANS_CLIENT int @@ -996,18 +977,13 @@ TRANS(GetConnectionNumber) (XtransConnInfo ciptr) return ciptr->fd; } - /* * These functions are really utility functions, but they require knowledge * of the internal data structures, so they have to be part of the Transport * Independent API. */ - -#ifdef TRANS_SERVER - static int complete_network_count (void) - { int count = 0; int found_local = 0; @@ -1245,10 +1221,6 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, return 0; } -#endif /* TRANS_SERVER */ - - - /* * These routines are not part of the X Transport Interface, but they * may be used by it. diff --git a/os/Xtrans.h b/os/Xtrans.h index 3b7296dcb..9ebe16744 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -205,14 +205,10 @@ XtransConnInfo TRANS(OpenCOTSClient)( #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER - XtransConnInfo TRANS(OpenCOTSServer)( const char * /* address */ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_REOPEN XtransConnInfo TRANS(ReopenCOTSServer)( @@ -237,8 +233,6 @@ int TRANS(SetOption)( int /* arg */ ); -#ifdef TRANS_SERVER - int TRANS(CreateListener)( XtransConnInfo, /* ciptr */ const char *, /* port */ @@ -270,8 +264,6 @@ XtransConnInfo TRANS(Accept)( int * /* status */ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_CLIENT int TRANS(Connect)( @@ -341,8 +333,6 @@ int TRANS(GetConnectionNumber)( XtransConnInfo /* ciptr */ ); -#ifdef TRANS_SERVER - int TRANS(MakeAllCOTSServerListeners)( const char *, /* port */ int *, /* partial */ @@ -350,9 +340,6 @@ int TRANS(MakeAllCOTSServerListeners)( XtransConnInfo ** /* ciptrs_ret */ ); -#endif /* TRANS_SERVER */ - - /* * Function Prototypes for Utility Functions. */ diff --git a/os/Xtransint.h b/os/Xtransint.h index baf1f728b..6927b741f 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -146,7 +146,6 @@ typedef struct _Xtransport { #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER const char ** nolisten; XtransConnInfo (*OpenCOTSServer)( struct _Xtransport *, /* transport */ @@ -155,8 +154,6 @@ typedef struct _Xtransport { const char * /* port */ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_REOPEN XtransConnInfo (*ReopenCOTSServer)( @@ -174,7 +171,6 @@ typedef struct _Xtransport { int /* arg */ ); -#ifdef TRANS_SERVER /* Flags */ # define ADDR_IN_USE_ALLOWED 1 @@ -193,8 +189,6 @@ typedef struct _Xtransport { int * /* status */ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_CLIENT int (*Connect)( @@ -332,12 +326,10 @@ static int TRANS(WriteV)( #endif /* WIN32 */ -#ifdef TRANS_SERVER static int trans_mkdir ( const char *, /* path */ int /* mode */ ); -#endif #ifdef __clang__ #pragma clang diagnostic pop diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index b981ba441..063612fce 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -297,10 +297,6 @@ TRANS(NAMEDOpenClient)(XtransConnInfo ciptr, const char *port) #endif /* TRANS_CLIENT */ - -#ifdef TRANS_SERVER - - #ifdef NAMEDNODENAME static int TRANS(NAMEDOpenPipe)(const char *server_path) @@ -484,8 +480,6 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) return str.fd; } -#endif /* TRANS_SERVER */ - #endif /* LOCAL_TRANS_NAMED */ @@ -562,14 +556,10 @@ typedef struct _LOCALtrans2dev { #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER - int (*devcotsopenserver)( XtransConnInfo, const char * /*port*/ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_CLIENT int (*devcltsopenclient)( @@ -578,14 +568,10 @@ typedef struct _LOCALtrans2dev { #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER - int (*devcltsopenserver)( XtransConnInfo, const char * /*port*/ ); -#endif /* TRANS_SERVER */ - #ifdef TRANS_REOPEN int (*devcotsreopenserver)( @@ -602,8 +588,6 @@ typedef struct _LOCALtrans2dev { #endif /* TRANS_REOPEN */ -#ifdef TRANS_SERVER - int (*devreset)( XtransConnInfo /* ciptr */ ); @@ -612,8 +596,6 @@ typedef struct _LOCALtrans2dev { XtransConnInfo, XtransConnInfo, int * ); -#endif /* TRANS_SERVER */ - } LOCALtrans2dev; static LOCALtrans2dev LOCALtrans2devtab[] = { @@ -621,46 +603,34 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { #ifdef TRANS_CLIENT TRANS(NAMEDOpenClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(NAMEDOpenServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(OpenFail), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(OpenFail), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), #endif -#ifdef TRANS_SERVER TRANS(NAMEDResetListener), TRANS(NAMEDAccept) -#endif /* TRANS_SERVER */ }, {"local", #ifdef TRANS_CLIENT TRANS(NAMEDOpenClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(NAMEDOpenServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(OpenFail), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(OpenFail), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), #endif -#ifdef TRANS_SERVER TRANS(NAMEDResetListener), TRANS(NAMEDAccept) -#endif /* TRANS_SERVER */ }, #ifdef LOCAL_TRANS_NAMED @@ -668,46 +638,34 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { #ifdef TRANS_CLIENT TRANS(NAMEDOpenClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(NAMEDOpenServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(OpenFail), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(OpenFail), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), #endif -#ifdef TRANS_SERVER TRANS(NAMEDResetListener), TRANS(NAMEDAccept) -#endif /* TRANS_SERVER */ }, {"pipe", #ifdef TRANS_CLIENT TRANS(NAMEDOpenClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(NAMEDOpenServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(OpenFail), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER TRANS(OpenFail), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), #endif -#ifdef TRANS_SERVER TRANS(NAMEDResetListener), TRANS(NAMEDAccept) -#endif /* TRANS_SERVER */ }, #endif /* LOCAL_TRANS_NAMED */ @@ -919,9 +877,6 @@ TRANS(LocalOpenClient)(int type, const char *protocol, #endif /* TRANS_CLIENT */ - -#ifdef TRANS_SERVER - static XtransConnInfo TRANS(LocalOpenServer)(int type, const char *protocol, const char *host _X_UNUSED, const char *port) @@ -976,9 +931,6 @@ TRANS(LocalOpenServer)(int type, const char *protocol, return NULL; } -#endif /* TRANS_SERVER */ - - #ifdef TRANS_REOPEN static XtransConnInfo @@ -1042,9 +994,6 @@ TRANS(LocalOpenCOTSClient)(Xtransport *thistrans _X_UNUSED, const char *protocol #endif /* TRANS_CLIENT */ - -#ifdef TRANS_SERVER - static XtransConnInfo TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, const char *host, const char *port) @@ -1090,8 +1039,6 @@ TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, return TRANS(LocalOpenServer)(XTRANS_OPEN_COTS_SERVER, protocol, host, port); } -#endif /* TRANS_SERVER */ - #ifdef TRANS_REOPEN static XtransConnInfo @@ -1131,9 +1078,6 @@ TRANS(LocalSetOption)(XtransConnInfo ciptr, int option, int arg) return -1; } - -#ifdef TRANS_SERVER - static int TRANS(LocalCreateListener)(XtransConnInfo ciptr, const char *port, unsigned int flags _X_UNUSED) @@ -1195,9 +1139,6 @@ TRANS(LocalAccept)(XtransConnInfo ciptr, int *status) return newciptr; } -#endif /* TRANS_SERVER */ - - #ifdef TRANS_CLIENT static int @@ -1316,13 +1257,10 @@ TRANS(LocalCloseForCloning)(XtransConnInfo ciptr) * The TransName is in lowercase, so it will never match during a normal * call to SelectTransport() in Xtrans.c. */ - -#ifdef TRANS_SERVER static const char * local_aliases[] = { "named", "pipe", /* compatibility with Solaris Xlib */ NULL }; -#endif static Xtransport TRANS(LocalFuncs) = { /* Local Interface */ @@ -1331,19 +1269,15 @@ static Xtransport TRANS(LocalFuncs) = { #ifdef TRANS_CLIENT TRANS(LocalOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER local_aliases, TRANS(LocalOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), #endif TRANS(LocalSetOption), -#ifdef TRANS_SERVER TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(LocalConnect), #endif /* TRANS_CLIENT */ @@ -1371,19 +1305,15 @@ static Xtransport TRANS(NAMEDFuncs) = { #ifdef TRANS_CLIENT TRANS(LocalOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER NULL, TRANS(LocalOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), #endif TRANS(LocalSetOption), -#ifdef TRANS_SERVER TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(LocalConnect), #endif /* TRANS_CLIENT */ @@ -1408,19 +1338,15 @@ static Xtransport TRANS(PIPEFuncs) = { #ifdef TRANS_CLIENT TRANS(LocalOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER NULL, TRANS(LocalOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), #endif TRANS(LocalSetOption), -#ifdef TRANS_SERVER TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(LocalConnect), #endif /* TRANS_CLIENT */ diff --git a/os/Xtranssock.c b/os/Xtranssock.c index ec735dee8..92c796d6a 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -211,9 +211,7 @@ static Sockettrans2dev Sockettrans2devtab[] = { static int TRANS(SocketINETClose) (XtransConnInfo ciptr); #endif -#if (defined(TCPCONN) && \ - (defined(TRANS_SERVER) || defined(X11_t) || !defined(HAVE_GETADDRINFO))) \ - || defined(TRANS_REOPEN) +#if (defined(TCPCONN) || defined(TRANS_REOPEN)) static int is_numeric (const char *str) { @@ -592,9 +590,6 @@ TRANS(SocketOpenCOTSClient) (Xtransport *thistrans, const char *protocol, #endif /* TRANS_CLIENT */ - -#ifdef TRANS_SERVER - static XtransConnInfo TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, const char *host, const char *port) @@ -664,9 +659,6 @@ TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, return ciptr; } -#endif /* TRANS_SERVER */ - - #ifdef TRANS_REOPEN static XtransConnInfo @@ -743,8 +735,6 @@ set_sun_path(const char *port, const char *upath, char *path, int abstract) } #endif -#ifdef TRANS_SERVER - static int TRANS(SocketCreateListener) (XtransConnInfo ciptr, struct sockaddr *sockname, @@ -1285,9 +1275,6 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) #endif /* UNIXCONN */ -#endif /* TRANS_SERVER */ - - #ifdef TRANS_CLIENT #ifdef TCPCONN @@ -2349,7 +2336,6 @@ TRANS(SocketUNIXCloseForCloning) (XtransConnInfo ciptr) #ifdef TCPCONN -# ifdef TRANS_SERVER static const char* tcp_nolisten[] = { "inet", #ifdef IPv6 @@ -2357,7 +2343,6 @@ static const char* tcp_nolisten[] = { #endif NULL }; -# endif static Xtransport TRANS(SocketTCPFuncs) = { /* Socket Interface */ @@ -2366,19 +2351,15 @@ static Xtransport TRANS(SocketTCPFuncs) = { #ifdef TRANS_CLIENT TRANS(SocketOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER tcp_nolisten, TRANS(SocketOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), #endif TRANS(SocketSetOption), -#ifdef TRANS_SERVER TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(SocketINETConnect), #endif /* TRANS_CLIENT */ @@ -2403,19 +2384,15 @@ static Xtransport TRANS(SocketINETFuncs) = { #ifdef TRANS_CLIENT TRANS(SocketOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER NULL, TRANS(SocketOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), #endif TRANS(SocketSetOption), -#ifdef TRANS_SERVER TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(SocketINETConnect), #endif /* TRANS_CLIENT */ @@ -2441,19 +2418,15 @@ static Xtransport TRANS(SocketINET6Funcs) = { #ifdef TRANS_CLIENT TRANS(SocketOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER NULL, TRANS(SocketOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), #endif TRANS(SocketSetOption), -#ifdef TRANS_SERVER TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(SocketINETConnect), #endif /* TRANS_CLIENT */ @@ -2486,19 +2459,15 @@ static Xtransport TRANS(SocketLocalFuncs) = { #ifdef TRANS_CLIENT TRANS(SocketOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER NULL, TRANS(SocketOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), #endif TRANS(SocketSetOption), -#ifdef TRANS_SERVER TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), TRANS(SocketUNIXAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(SocketUNIXConnect), #endif /* TRANS_CLIENT */ @@ -2516,11 +2485,9 @@ static Xtransport TRANS(SocketLocalFuncs) = { TRANS(SocketUNIXCloseForCloning), }; #endif /* !LOCALCONN */ -# ifdef TRANS_SERVER # if !defined(LOCALCONN) static const char* unix_nolisten[] = { "local" , NULL }; # endif -# endif static Xtransport TRANS(SocketUNIXFuncs) = { /* Socket Interface */ @@ -2533,23 +2500,19 @@ static Xtransport TRANS(SocketUNIXFuncs) = { #ifdef TRANS_CLIENT TRANS(SocketOpenCOTSClient), #endif /* TRANS_CLIENT */ -#ifdef TRANS_SERVER #if !defined(LOCALCONN) unix_nolisten, #else NULL, #endif TRANS(SocketOpenCOTSServer), -#endif /* TRANS_SERVER */ #ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), #endif TRANS(SocketSetOption), -#ifdef TRANS_SERVER TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), TRANS(SocketUNIXAccept), -#endif /* TRANS_SERVER */ #ifdef TRANS_CLIENT TRANS(SocketUNIXConnect), #endif /* TRANS_CLIENT */ diff --git a/os/Xtransutil.c b/os/Xtransutil.c index 5cb937521..8690e67e5 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -240,7 +240,6 @@ TRANS(WSAStartup) (void) } #endif -#ifdef TRANS_SERVER #include #include #include @@ -427,5 +426,3 @@ trans_mkdir(const char *path, int mode) /* In all other cases, fail */ return -1; } - -#endif /* TRANS_SERVER */ diff --git a/os/access.c b/os/access.c index ce74eafbc..c7b7a03c8 100644 --- a/os/access.c +++ b/os/access.c @@ -85,7 +85,6 @@ SOFTWARE. #include #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" #include diff --git a/os/connection.c b/os/connection.c index cee77fa9f..153d727d0 100644 --- a/os/connection.c +++ b/os/connection.c @@ -68,7 +68,6 @@ SOFTWARE. #include #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" #include "os/Xtransint.h" diff --git a/os/io.c b/os/io.c index 10a666c0c..c90f78f3d 100644 --- a/os/io.c +++ b/os/io.c @@ -62,7 +62,6 @@ SOFTWARE. #endif #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" #include diff --git a/os/utils.c b/os/utils.c index 198e3e0cc..4b0c88b28 100644 --- a/os/utils.c +++ b/os/utils.c @@ -63,7 +63,6 @@ OR PERFORMANCE OF THIS SOFTWARE. #include "misc.h" #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" diff --git a/os/xdmauth.c b/os/xdmauth.c index 8f30ef946..42d7956d3 100644 --- a/os/xdmauth.c +++ b/os/xdmauth.c @@ -38,7 +38,6 @@ from The Open Group. #include #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/auth.h" diff --git a/os/xdmcp.c b/os/xdmcp.c index 3168d8608..66efa9470 100644 --- a/os/xdmcp.c +++ b/os/xdmcp.c @@ -18,7 +18,6 @@ #ifdef WIN32 #include #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" #endif @@ -49,7 +48,6 @@ #include "dixstruct.h" #define XSERV_t -#define TRANS_SERVER #define TRANS_REOPEN #include "os/Xtrans.h" diff --git a/os/xstrans.c b/os/xstrans.c index bd60a18be..aea79114b 100644 --- a/os/xstrans.c +++ b/os/xstrans.c @@ -3,6 +3,5 @@ #include #define TRANS_REOPEN -#define TRANS_SERVER #define XSERV_t #include "os/transport.c" From f6dd15f8d4e43df144fa75b4b02761dbb2bd11fe Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 19:49:00 +0100 Subject: [PATCH 15/23] os: xtrans: drop ifdef TRANS_REOPEN It's always defined, so the guards aren't necessary. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 12 ----------- os/Xtrans.h | 5 ----- os/Xtransint.h | 5 ----- os/Xtranslcl.c | 53 ------------------------------------------------- os/Xtranssock.c | 23 --------------------- os/access.c | 1 - os/connection.c | 1 - os/io.c | 1 - os/utils.c | 1 - os/xdmauth.c | 1 - os/xdmcp.c | 2 -- os/xstrans.c | 1 - 12 files changed, 106 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index b7e0eb442..e0187f0f4 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -471,9 +471,6 @@ TRANS(Open) (int type, const char *address) return ciptr; } - -#ifdef TRANS_REOPEN - /* * We might want to create an XtransConnInfo object based on a previously * opened connection. For example, the font server may clone itself and @@ -540,10 +537,6 @@ TRANS(Reopen) (int type, int trans_id, int fd, const char *port) return ciptr; } -#endif /* TRANS_REOPEN */ - - - /* * These are the public interfaces to this Transport interface. * These are the only functions that should have knowledge of the transport @@ -570,8 +563,6 @@ TRANS(OpenCOTSServer) (const char *address) return TRANS(Open) (XTRANS_OPEN_COTS_SERVER, address); } -#ifdef TRANS_REOPEN - XtransConnInfo TRANS(ReopenCOTSServer) (int trans_id, int fd, const char *port) @@ -602,9 +593,6 @@ TRANS(GetReopenInfo) (XtransConnInfo ciptr, return 0; } -#endif /* TRANS_REOPEN */ - - int TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) diff --git a/os/Xtrans.h b/os/Xtrans.h index 9ebe16744..cf4172ed7 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -209,8 +209,6 @@ XtransConnInfo TRANS(OpenCOTSServer)( const char * /* address */ ); -#ifdef TRANS_REOPEN - XtransConnInfo TRANS(ReopenCOTSServer)( int, /* trans_id */ int, /* fd */ @@ -224,9 +222,6 @@ int TRANS(GetReopenInfo)( char ** /* port */ ); -#endif /* TRANS_REOPEN */ - - int TRANS(SetOption)( XtransConnInfo, /* ciptr */ int, /* option */ diff --git a/os/Xtransint.h b/os/Xtransint.h index 6927b741f..4437da16b 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -154,17 +154,12 @@ typedef struct _Xtransport { const char * /* port */ ); -#ifdef TRANS_REOPEN - XtransConnInfo (*ReopenCOTSServer)( struct _Xtransport *, /* transport */ int, /* fd */ const char * /* port */ ); -#endif /* TRANS_REOPEN */ - - int (*SetOption)( XtransConnInfo, /* connection */ int, /* option */ diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 063612fce..d3b0c5793 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -116,8 +116,6 @@ TRANS(OpenFail)(XtransConnInfo ciptr _X_UNUSED, const char *port _X_UNUSED) return -1; } -#ifdef TRANS_REOPEN - static int TRANS(ReopenFail)(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED, const char *port _X_UNUSED) @@ -126,8 +124,6 @@ TRANS(ReopenFail)(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED, return 0; } -#endif /* TRANS_REOPEN */ - #if XTRANS_SEND_FDS static int TRANS(LocalRecvFdInvalid)(XtransConnInfo ciptr) @@ -482,17 +478,6 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) #endif /* LOCAL_TRANS_NAMED */ - - - - - - - - - -#ifdef TRANS_REOPEN - #ifdef LOCAL_TRANS_NAMED static int @@ -534,12 +519,6 @@ TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *por #endif /* LOCAL_TRANS_NAMED */ - - -#endif /* TRANS_REOPEN */ - - - /* * This table contains all of the entry points for the different local * connection mechanisms. @@ -572,8 +551,6 @@ typedef struct _LOCALtrans2dev { XtransConnInfo, const char * /*port*/ ); -#ifdef TRANS_REOPEN - int (*devcotsreopenserver)( XtransConnInfo, int, /* fd */ @@ -586,8 +563,6 @@ typedef struct _LOCALtrans2dev { const char * /* port */ ); -#endif /* TRANS_REOPEN */ - int (*devreset)( XtransConnInfo /* ciptr */ ); @@ -608,10 +583,8 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { TRANS(OpenFail), #endif /* TRANS_CLIENT */ TRANS(OpenFail), -#ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), -#endif TRANS(NAMEDResetListener), TRANS(NAMEDAccept) }, @@ -625,10 +598,8 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { TRANS(OpenFail), #endif /* TRANS_CLIENT */ TRANS(OpenFail), -#ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), -#endif TRANS(NAMEDResetListener), TRANS(NAMEDAccept) }, @@ -643,10 +614,8 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { TRANS(OpenFail), #endif /* TRANS_CLIENT */ TRANS(OpenFail), -#ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), -#endif TRANS(NAMEDResetListener), TRANS(NAMEDAccept) }, @@ -660,10 +629,8 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { TRANS(OpenFail), #endif /* TRANS_CLIENT */ TRANS(OpenFail), -#ifdef TRANS_REOPEN TRANS(NAMEDReopenServer), TRANS(ReopenFail), -#endif TRANS(NAMEDResetListener), TRANS(NAMEDAccept) }, @@ -931,8 +898,6 @@ TRANS(LocalOpenServer)(int type, const char *protocol, return NULL; } -#ifdef TRANS_REOPEN - static XtransConnInfo TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) @@ -972,10 +937,6 @@ TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) return NULL; } -#endif /* TRANS_REOPEN */ - - - /* * This is the Local implementation of the X Transport service layer */ @@ -1039,8 +1000,6 @@ TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, return TRANS(LocalOpenServer)(XTRANS_OPEN_COTS_SERVER, protocol, host, port); } -#ifdef TRANS_REOPEN - static XtransConnInfo TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port) @@ -1065,10 +1024,6 @@ TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port) index, fd, port); } -#endif /* TRANS_REOPEN */ - - - static int TRANS(LocalSetOption)(XtransConnInfo ciptr, int option, int arg) @@ -1271,9 +1226,7 @@ static Xtransport TRANS(LocalFuncs) = { #endif /* TRANS_CLIENT */ local_aliases, TRANS(LocalOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), -#endif TRANS(LocalSetOption), TRANS(LocalCreateListener), TRANS(LocalResetListener), @@ -1307,9 +1260,7 @@ static Xtransport TRANS(NAMEDFuncs) = { #endif /* TRANS_CLIENT */ NULL, TRANS(LocalOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), -#endif TRANS(LocalSetOption), TRANS(LocalCreateListener), TRANS(LocalResetListener), @@ -1340,9 +1291,7 @@ static Xtransport TRANS(PIPEFuncs) = { #endif /* TRANS_CLIENT */ NULL, TRANS(LocalOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(LocalReopenCOTSServer), -#endif TRANS(LocalSetOption), TRANS(LocalCreateListener), TRANS(LocalResetListener), @@ -1364,5 +1313,3 @@ static Xtransport TRANS(PIPEFuncs) = { TRANS(LocalCloseForCloning), }; #endif /* LOCAL_TRANS_NAMED */ - - diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 92c796d6a..5a2ba8a28 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -211,7 +211,6 @@ static Sockettrans2dev Sockettrans2devtab[] = { static int TRANS(SocketINETClose) (XtransConnInfo ciptr); #endif -#if (defined(TCPCONN) || defined(TRANS_REOPEN)) static int is_numeric (const char *str) { @@ -223,7 +222,6 @@ is_numeric (const char *str) return (1); } -#endif #ifdef UNIXCONN @@ -453,9 +451,6 @@ TRANS(SocketOpen) (int i, int type) return ciptr; } - -#ifdef TRANS_REOPEN - static XtransConnInfo TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) @@ -536,9 +531,6 @@ TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) return ciptr; } -#endif /* TRANS_REOPEN */ - - /* * These functions are the interface supplied in the Xtransport structure */ @@ -659,8 +651,6 @@ TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, return ciptr; } -#ifdef TRANS_REOPEN - static XtransConnInfo TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) @@ -695,9 +685,6 @@ TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) return ciptr; } -#endif /* TRANS_REOPEN */ - - static int TRANS(SocketSetOption) (XtransConnInfo ciptr, int option, int arg) @@ -2353,9 +2340,7 @@ static Xtransport TRANS(SocketTCPFuncs) = { #endif /* TRANS_CLIENT */ tcp_nolisten, TRANS(SocketOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), -#endif TRANS(SocketSetOption), TRANS(SocketINETCreateListener), NULL, /* ResetListener */ @@ -2386,9 +2371,7 @@ static Xtransport TRANS(SocketINETFuncs) = { #endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), -#endif TRANS(SocketSetOption), TRANS(SocketINETCreateListener), NULL, /* ResetListener */ @@ -2420,9 +2403,7 @@ static Xtransport TRANS(SocketINET6Funcs) = { #endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), -#endif TRANS(SocketSetOption), TRANS(SocketINETCreateListener), NULL, /* ResetListener */ @@ -2461,9 +2442,7 @@ static Xtransport TRANS(SocketLocalFuncs) = { #endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), -#endif TRANS(SocketSetOption), TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), @@ -2506,9 +2485,7 @@ static Xtransport TRANS(SocketUNIXFuncs) = { NULL, #endif TRANS(SocketOpenCOTSServer), -#ifdef TRANS_REOPEN TRANS(SocketReopenCOTSServer), -#endif TRANS(SocketSetOption), TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), diff --git a/os/access.c b/os/access.c index c7b7a03c8..cc9580c60 100644 --- a/os/access.c +++ b/os/access.c @@ -85,7 +85,6 @@ SOFTWARE. #include #include #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #include #include diff --git a/os/connection.c b/os/connection.c index 153d727d0..04d23bca3 100644 --- a/os/connection.c +++ b/os/connection.c @@ -68,7 +68,6 @@ SOFTWARE. #include #include #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #include "os/Xtransint.h" #include diff --git a/os/io.c b/os/io.c index c90f78f3d..72faef24f 100644 --- a/os/io.c +++ b/os/io.c @@ -62,7 +62,6 @@ SOFTWARE. #endif #include #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #include #include diff --git a/os/utils.c b/os/utils.c index 4b0c88b28..86a0fb7bf 100644 --- a/os/utils.c +++ b/os/utils.c @@ -63,7 +63,6 @@ OR PERFORMANCE OF THIS SOFTWARE. #include "misc.h" #include #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #include diff --git a/os/xdmauth.c b/os/xdmauth.c index 42d7956d3..9b8aaa5b2 100644 --- a/os/xdmauth.c +++ b/os/xdmauth.c @@ -38,7 +38,6 @@ from The Open Group. #include #include #define XSERV_t -#define TRANS_REOPEN #include "os/auth.h" #include "os/Xtrans.h" diff --git a/os/xdmcp.c b/os/xdmcp.c index 66efa9470..4da75ae78 100644 --- a/os/xdmcp.c +++ b/os/xdmcp.c @@ -18,7 +18,6 @@ #ifdef WIN32 #include #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #endif @@ -48,7 +47,6 @@ #include "dixstruct.h" #define XSERV_t -#define TRANS_REOPEN #include "os/Xtrans.h" #ifdef XDMCP diff --git a/os/xstrans.c b/os/xstrans.c index aea79114b..0c8fc7f1a 100644 --- a/os/xstrans.c +++ b/os/xstrans.c @@ -2,6 +2,5 @@ #include -#define TRANS_REOPEN #define XSERV_t #include "os/transport.c" From c62c0f093f112a3434b58610a0f5bc1f5783817c Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 16:21:58 +0100 Subject: [PATCH 16/23] os: xtrans: drop XSERV_t and x11_t defines These are always enablde (x11_t is defined when XSERV_t is defined), so no need for the #ifdef's anymore. Signed-off-by: Enrico Weigelt, metux IT consult --- hw/xwin/windisplay.c | 1 - os/Xtrans.h | 21 --------------------- os/Xtransint.h | 2 -- os/Xtranslcl.c | 14 -------------- os/Xtranssock.c | 12 +----------- os/Xtransutil.c | 4 ---- os/access.c | 1 - os/connection.c | 1 - os/io.c | 1 - os/utils.c | 1 - os/xdmauth.c | 1 - os/xdmcp.c | 2 -- os/xstrans.c | 1 - 13 files changed, 1 insertion(+), 61 deletions(-) diff --git a/hw/xwin/windisplay.c b/hw/xwin/windisplay.c index 6ad8f6651..c1c02f581 100644 --- a/hw/xwin/windisplay.c +++ b/hw/xwin/windisplay.c @@ -35,7 +35,6 @@ #include "windisplay.h" #include "winmsg.h" -#define XSERV_t #include "os/Xtrans.h" /* diff --git a/os/Xtrans.h b/os/Xtrans.h index cf4172ed7..3972783af 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -68,27 +68,10 @@ from The Open Group. * Set the functions names according to where this code is being compiled. */ -#ifdef X11_t -#define TRANS(func) _X11Trans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_X11Trans"; -#endif -#endif /* X11_t */ - -#ifdef XSERV_t #define TRANS(func) _XSERVTrans##func #ifdef XTRANSDEBUG static const char *__xtransname = "_XSERVTrans"; #endif -#define X11_t -#endif /* XSERV_t */ - -#if !defined(TRANS) -#define TRANS(func) _XTrans##func -#ifdef XTRANSDEBUG -static const char *__xtransname = "_XTrans"; -#endif -#endif /* !TRANS */ #ifdef __clang__ #pragma clang diagnostic pop @@ -339,16 +322,12 @@ int TRANS(MakeAllCOTSServerListeners)( * Function Prototypes for Utility Functions. */ -#ifdef X11_t - int TRANS(ConvertAddress)( int *, /* familyp */ int *, /* addrlenp */ Xtransaddr ** /* addrp */ ); -#endif /* X11_t */ - int TRANS(GetHostname) ( char * /* buf */, diff --git a/os/Xtransint.h b/os/Xtransint.h index 4437da16b..6133b69a9 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -98,9 +98,7 @@ from The Open Group. #include -#ifdef X11_t #define X_TCP_PORT 6000 -#endif #if XTRANS_SEND_FDS diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index d3b0c5793..c267ab838 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -202,22 +202,12 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, } - - -#ifndef X11_t -#define X_STREAMS_DIR "/dev/X" -#else #define X_STREAMS_DIR "/tmp/.X11-pipe" -#endif #define DEV_PTMX "/dev/ptmx" -#if defined(X11_t) - #define NAMEDNODENAME "/tmp/.X11-pipe/X" -#endif - #ifdef LOCAL_TRANS_NAMED /* NAMED */ @@ -783,7 +773,6 @@ TRANS(LocalOpenClient)(int type, const char *protocol, } -#if defined(X11_t) /* * X has a well known port, that is transport dependent. It is easier * to handle it here, than try and come up with a transport independent @@ -793,7 +782,6 @@ TRANS(LocalOpenClient)(int type, const char *protocol, * from ConnectDisplay(). Since that is what we want for the local transports, * we don't have to do anything special. */ -#endif /* X11_t */ if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) { @@ -853,14 +841,12 @@ TRANS(LocalOpenServer)(int type, const char *protocol, prmsg(2,"LocalOpenServer(%d,%s,%s)\n", type, protocol, port); -#if defined(X11_t) /* * For X11, the port will be in the format xserverN where N is the * display number. All of the local connections just need to know * the display number because they don't do any name resolution on * the port. This just truncates port to the display portion. */ -#endif /* X11_t */ if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) { diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 5a2ba8a28..14c1ae371 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -226,10 +226,8 @@ is_numeric (const char *str) #ifdef UNIXCONN -#if defined(X11_t) #define UNIX_PATH "/tmp/.X11-unix/X" #define UNIX_DIR "/tmp/.X11-unix" -#endif /* X11_t */ #endif /* UNIXCONN */ @@ -388,7 +386,7 @@ TRANS(SocketOpen) (int i, int type) Sockettrans2devtab[i].protocol); #ifndef WIN32 -#if (defined(X11_t) && !defined(USE_POLL)) +#if !defined(USE_POLL) if (ciptr->fd >= sysconf(_SC_OPEN_MAX)) { prmsg (2, "SocketOpen: socket() returned out of range fd %d\n", @@ -816,13 +814,10 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, #endif struct servent *servp; -#ifdef X11_t char portbuf[PORTBUFSIZE]; -#endif prmsg (2, "SocketINETCreateListener(%s)\n", port); -#ifdef X11_t /* * X has a well known port, that is transport dependent. It is easier * to handle it here, than try and come up with a transport independent @@ -839,7 +834,6 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, snprintf (portbuf, sizeof(portbuf), "%lu", tmpport); port = portbuf; } -#endif if (port && *port) { @@ -1299,9 +1293,7 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, _Xgethostbynameparams hparams; _Xgetservbynameparams sparams; #endif -#ifdef X11_t char portbuf[PORTBUFSIZE]; -#endif char hostnamebuf[256]; /* tmp space */ @@ -1314,7 +1306,6 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, host = hostnamebuf; } -#ifdef X11_t /* * X has a well known port, that is transport dependent. It is easier * to handle it here, than try and come up with a transport independent @@ -1330,7 +1321,6 @@ TRANS(SocketINETConnect) (XtransConnInfo ciptr, snprintf (portbuf, sizeof(portbuf), "%lu", tmpport); port = portbuf; } -#endif #ifdef HAVE_GETADDRINFO { diff --git a/os/Xtransutil.c b/os/Xtransutil.c index 8690e67e5..43cc728c9 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -72,8 +72,6 @@ from The Open Group. #define HAVE_INET_NTOP #endif -#ifdef X11_t - /* * These values come from X.h and Xauth.h, and MUST match them. Some * of these values are also defined by the ChangeHost protocol message. @@ -224,8 +222,6 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) return 0; } -#endif /* X11_t */ - #if defined(WIN32) && defined(TCPCONN) int TRANS(WSAStartup) (void) diff --git a/os/access.c b/os/access.c index cc9580c60..fd9fa91ef 100644 --- a/os/access.c +++ b/os/access.c @@ -84,7 +84,6 @@ SOFTWARE. #include #include -#define XSERV_t #include "os/Xtrans.h" #include #include diff --git a/os/connection.c b/os/connection.c index 04d23bca3..482a83e7b 100644 --- a/os/connection.c +++ b/os/connection.c @@ -67,7 +67,6 @@ SOFTWARE. #endif #include #include -#define XSERV_t #include "os/Xtrans.h" #include "os/Xtransint.h" #include diff --git a/os/io.c b/os/io.c index 72faef24f..f61f6bb9c 100644 --- a/os/io.c +++ b/os/io.c @@ -61,7 +61,6 @@ SOFTWARE. #include #endif #include -#define XSERV_t #include "os/Xtrans.h" #include #include diff --git a/os/utils.c b/os/utils.c index 86a0fb7bf..9ec93f39c 100644 --- a/os/utils.c +++ b/os/utils.c @@ -62,7 +62,6 @@ OR PERFORMANCE OF THIS SOFTWARE. #endif #include "misc.h" #include -#define XSERV_t #include "os/Xtrans.h" #include diff --git a/os/xdmauth.c b/os/xdmauth.c index 9b8aaa5b2..1ff7ab75c 100644 --- a/os/xdmauth.c +++ b/os/xdmauth.c @@ -37,7 +37,6 @@ from The Open Group. #include #include -#define XSERV_t #include "os/auth.h" #include "os/Xtrans.h" diff --git a/os/xdmcp.c b/os/xdmcp.c index 4da75ae78..a4cb3e2dc 100644 --- a/os/xdmcp.c +++ b/os/xdmcp.c @@ -17,7 +17,6 @@ #ifdef WIN32 #include -#define XSERV_t #include "os/Xtrans.h" #endif @@ -46,7 +45,6 @@ #include "input.h" #include "dixstruct.h" -#define XSERV_t #include "os/Xtrans.h" #ifdef XDMCP diff --git a/os/xstrans.c b/os/xstrans.c index 0c8fc7f1a..889dec329 100644 --- a/os/xstrans.c +++ b/os/xstrans.c @@ -2,5 +2,4 @@ #include -#define XSERV_t #include "os/transport.c" From 1d5789635830c010e8c6c580d55e805c77517b3d Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 16:46:30 +0100 Subject: [PATCH 17/23] os: xtrans: drop TRANS_CLIENT code pathes Not needed in server-only code base. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 60 ---- os/Xtrans.h | 17 -- os/Xtransint.h | 22 -- os/Xtranslcl.c | 326 --------------------- os/Xtranssock.c | 745 ------------------------------------------------ 5 files changed, 1170 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index e0187f0f4..dce2f953d 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -438,9 +438,6 @@ TRANS(Open) (int type, const char *address) switch (type) { case XTRANS_OPEN_COTS_CLIENT: -#ifdef TRANS_CLIENT - ciptr = thistrans->OpenCOTSClient(thistrans, protocol, host, port); -#endif /* TRANS_CLIENT */ break; case XTRANS_OPEN_COTS_SERVER: ciptr = thistrans->OpenCOTSServer(thistrans, protocol, host, port); @@ -543,18 +540,6 @@ TRANS(Reopen) (int type, int trans_id, int fd, const char *port) * table. */ -#ifdef TRANS_CLIENT - -XtransConnInfo -TRANS(OpenCOTSClient) (const char *address) - -{ - prmsg (2,"OpenCOTSClient(%s)\n", address); - return TRANS(Open) (XTRANS_OPEN_COTS_CLIENT, address); -} - -#endif /* TRANS_CLIENT */ - XtransConnInfo TRANS(OpenCOTSServer) (const char *address) @@ -799,51 +784,6 @@ TRANS(Accept) (XtransConnInfo ciptr, int *status) return newciptr; } -#ifdef TRANS_CLIENT - -int -TRANS(Connect) (XtransConnInfo ciptr, const char *address) - -{ - char *protocol; - char *host; - char *port; - int ret; - - prmsg (2,"Connect(%d,%s)\n", ciptr->fd, address); - - if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0) - { - prmsg (1,"Connect: Unable to Parse address %s\n", - address); - return -1; - } - -#ifdef HAVE_LAUNCHD - if (!host) host=strdup(""); -#endif - - if (!port || !*port) - { - prmsg (1,"Connect: Missing port specification in %s\n", - address); - if (protocol) free (protocol); - if (host) free (host); - return -1; - } - - ret = ciptr->transptr->Connect (ciptr, host, port); - - if (protocol) free (protocol); - if (host) free (host); - if (port) free (port); - - return ret; -} - -#endif /* TRANS_CLIENT */ - - int TRANS(BytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) diff --git a/os/Xtrans.h b/os/Xtrans.h index 3972783af..83dd2b4d0 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -180,14 +180,6 @@ void TRANS(FreeConnInfo) ( XtransConnInfo /* ciptr */ ); -#ifdef TRANS_CLIENT - -XtransConnInfo TRANS(OpenCOTSClient)( - const char * /* address */ -); - -#endif /* TRANS_CLIENT */ - XtransConnInfo TRANS(OpenCOTSServer)( const char * /* address */ ); @@ -242,15 +234,6 @@ XtransConnInfo TRANS(Accept)( int * /* status */ ); -#ifdef TRANS_CLIENT - -int TRANS(Connect)( - XtransConnInfo, /* ciptr */ - const char * /* address */ -); - -#endif /* TRANS_CLIENT */ - int TRANS(BytesReadable)( XtransConnInfo, /* ciptr */ BytesReadable_t * /* pend */ diff --git a/os/Xtransint.h b/os/Xtransint.h index 6133b69a9..f02bfbec7 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -132,18 +132,6 @@ struct _XtransConnInfo { typedef struct _Xtransport { const char *TransName; int flags; - -#ifdef TRANS_CLIENT - - XtransConnInfo (*OpenCOTSClient)( - struct _Xtransport *, /* transport */ - const char *, /* protocol */ - const char *, /* host */ - const char * /* port */ - ); - -#endif /* TRANS_CLIENT */ - const char ** nolisten; XtransConnInfo (*OpenCOTSServer)( struct _Xtransport *, /* transport */ @@ -182,16 +170,6 @@ typedef struct _Xtransport { int * /* status */ ); -#ifdef TRANS_CLIENT - - int (*Connect)( - XtransConnInfo, /* connection */ - const char *, /* host */ - const char * /* port */ - ); - -#endif /* TRANS_CLIENT */ - int (*BytesReadable)( XtransConnInfo, /* connection */ BytesReadable_t * /* pend */ diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index c267ab838..dfa30c0b6 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -212,77 +212,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, /* NAMED */ -#ifdef TRANS_CLIENT - -static int -TRANS(NAMEDOpenClient)(XtransConnInfo ciptr, const char *port) - -{ -#ifdef NAMEDNODENAME - int fd; - char server_path[64]; - struct stat filestat; -#endif - - prmsg(2,"NAMEDOpenClient(%s)\n", port); - -#if !defined(NAMEDNODENAME) - prmsg(1,"NAMEDOpenClient: Protocol is not supported by a NAMED connection\n"); - return -1; -#else - if ( port && *port ) { - if( *port == '/' ) { /* A full pathname */ - (void) snprintf(server_path, sizeof(server_path), "%s", port); - } else { - (void) snprintf(server_path, sizeof(server_path), "%s%s", NAMEDNODENAME, port); - } - } else { - (void) snprintf(server_path, sizeof(server_path), "%s%ld", NAMEDNODENAME, (long)getpid()); - } - - if ((fd = open(server_path, O_RDWR)) < 0) { - prmsg(1,"NAMEDOpenClient: Cannot open %s for NAMED connection\n", server_path); - return -1; - } - - if (fstat(fd, &filestat) < 0 ) { - prmsg(1,"NAMEDOpenClient: Cannot stat %s for NAMED connection\n", server_path); - (void) close(fd); - return -1; - } - - if ((filestat.st_mode & S_IFMT) != S_IFIFO) { - prmsg(1,"NAMEDOpenClient: Device %s is not a FIFO\n", server_path); - /* Is this really a failure? */ - (void) close(fd); - return -1; - } - - - if (isastream(fd) <= 0) { - prmsg(1,"NAMEDOpenClient: %s is not a streams device\n", server_path); - (void) close(fd); - return -1; - } - - /* - * Everything looks good: fill in the XtransConnInfo structure. - */ - - if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) - { - prmsg(1,"NAMEDOpenClient: failed to fill in addr info\n"); - close(fd); - return -1; - } - - return(fd); - -#endif /* !NAMEDNODENAME */ -} - -#endif /* TRANS_CLIENT */ - #ifdef NAMEDNODENAME static int TRANS(NAMEDOpenPipe)(const char *server_path) @@ -516,27 +445,9 @@ TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *por typedef struct _LOCALtrans2dev { const char *transname; - -#ifdef TRANS_CLIENT - - int (*devcotsopenclient)( - XtransConnInfo, const char * /*port*/ -); - -#endif /* TRANS_CLIENT */ - int (*devcotsopenserver)( XtransConnInfo, const char * /*port*/ ); - -#ifdef TRANS_CLIENT - - int (*devcltsopenclient)( - XtransConnInfo, const char * /*port*/ -); - -#endif /* TRANS_CLIENT */ - int (*devcltsopenserver)( XtransConnInfo, const char * /*port*/ ); @@ -565,13 +476,7 @@ typedef struct _LOCALtrans2dev { static LOCALtrans2dev LOCALtrans2devtab[] = { {"", -#ifdef TRANS_CLIENT - TRANS(NAMEDOpenClient), -#endif /* TRANS_CLIENT */ TRANS(NAMEDOpenServer), -#ifdef TRANS_CLIENT - TRANS(OpenFail), -#endif /* TRANS_CLIENT */ TRANS(OpenFail), TRANS(NAMEDReopenServer), TRANS(ReopenFail), @@ -580,13 +485,7 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { }, {"local", -#ifdef TRANS_CLIENT - TRANS(NAMEDOpenClient), -#endif /* TRANS_CLIENT */ TRANS(NAMEDOpenServer), -#ifdef TRANS_CLIENT - TRANS(OpenFail), -#endif /* TRANS_CLIENT */ TRANS(OpenFail), TRANS(NAMEDReopenServer), TRANS(ReopenFail), @@ -596,13 +495,7 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { #ifdef LOCAL_TRANS_NAMED {"named", -#ifdef TRANS_CLIENT - TRANS(NAMEDOpenClient), -#endif /* TRANS_CLIENT */ TRANS(NAMEDOpenServer), -#ifdef TRANS_CLIENT - TRANS(OpenFail), -#endif /* TRANS_CLIENT */ TRANS(OpenFail), TRANS(NAMEDReopenServer), TRANS(ReopenFail), @@ -611,13 +504,7 @@ static LOCALtrans2dev LOCALtrans2devtab[] = { }, {"pipe", -#ifdef TRANS_CLIENT - TRANS(NAMEDOpenClient), -#endif /* TRANS_CLIENT */ TRANS(NAMEDOpenServer), -#ifdef TRANS_CLIENT - TRANS(OpenFail), -#endif /* TRANS_CLIENT */ TRANS(OpenFail), TRANS(NAMEDReopenServer), TRANS(ReopenFail), @@ -666,172 +553,6 @@ TRANS(LocalEndTransports)(void) #define TYPEBUFSIZE 32 -#ifdef TRANS_CLIENT - -static LOCALtrans2dev * -TRANS(LocalGetNextTransport)(void) - -{ - char *typetocheck; - prmsg(3,"LocalGetNextTransport()\n"); - - while(1) - { - if( workingXLOCAL == NULL || *workingXLOCAL == '\0' ) - return NULL; - - typetocheck=workingXLOCAL; - workingXLOCAL=strchr(workingXLOCAL,':'); - if(workingXLOCAL && *workingXLOCAL) - *workingXLOCAL++='\0'; - - for (unsigned int i = 0; i < NUMTRANSPORTS; i++) - { -#ifndef HAVE_STRCASECMP - int j; - char typebuf[TYPEBUFSIZE]; - /* - * This is equivalent to a case insensitive strcmp(), - * but should be more portable. - */ - strncpy(typebuf,typetocheck,TYPEBUFSIZE); - for(j=0;j - -/* - * Make sure 'host' is really local. - */ - -static int -HostReallyLocal (const char *host) - -{ - /* - * The 'host' passed to this function may have been generated - * by either uname() or gethostname(). We try both if possible. - */ - - struct utsname name; - char buf[256]; - - if (uname (&name) >= 0 && strcmp (host, name.nodename) == 0) - return (1); - - buf[0] = '\0'; - (void) gethostname (buf, 256); - buf[255] = '\0'; - - if (strcmp (host, buf) == 0) - return (1); - - return (0); -} - - -static XtransConnInfo -TRANS(LocalOpenClient)(int type, const char *protocol, - const char *host, const char *port) - -{ - LOCALtrans2dev *transptr; - XtransConnInfo ciptr; - int index; - - prmsg(3,"LocalOpenClient()\n"); - - /* - * Make sure 'host' is really local. If not, we return failure. - * The reason we make this check is because a process may advertise - * a "local" address for which it can accept connections, but if a - * process on a remote machine tries to connect to this address, - * we know for sure it will fail. - */ - - if (strcmp (host, "unix") != 0 && !HostReallyLocal (host)) - { - prmsg (1, - "LocalOpenClient: Cannot connect to non-local host %s\n", - host); - return NULL; - } - - - /* - * X has a well known port, that is transport dependent. It is easier - * to handle it here, than try and come up with a transport independent - * representation that can be passed in and resolved the usual way. - * - * The port that is passed here is really a string containing the idisplay - * from ConnectDisplay(). Since that is what we want for the local transports, - * we don't have to do anything special. - */ - - if( (ciptr = calloc(1,sizeof(struct _XtransConnInfo))) == NULL ) - { - prmsg(1,"LocalOpenClient: calloc(1,%lu) failed\n", - sizeof(struct _XtransConnInfo)); - return NULL; - } - - ciptr->fd = -1; - - TRANS(LocalInitTransports)(protocol); - - index = 0; - for(transptr=TRANS(LocalGetNextTransport)(); - transptr!=NULL;transptr=TRANS(LocalGetNextTransport)(), index++) - { - switch( type ) - { - case XTRANS_OPEN_COTS_CLIENT: - ciptr->fd=transptr->devcotsopenclient(ciptr,port); - break; - case XTRANS_OPEN_COTS_SERVER: - prmsg(1, - "LocalOpenClient: Should not be opening a server with this function\n"); - break; - default: - prmsg(1, - "LocalOpenClient: Unknown Open type %d\n", - type); - } - if( ciptr->fd >= 0 ) - break; - } - - TRANS(LocalEndTransports)(); - - if( ciptr->fd < 0 ) - { - free(ciptr); - return NULL; - } - - ciptr->priv=(char *)transptr; - ciptr->index = index; - - return ciptr; -} - -#endif /* TRANS_CLIENT */ - static XtransConnInfo TRANS(LocalOpenServer)(int type, const char *protocol, const char *host _X_UNUSED, const char *port) @@ -927,20 +648,6 @@ TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) * This is the Local implementation of the X Transport service layer */ -#ifdef TRANS_CLIENT - -static XtransConnInfo -TRANS(LocalOpenCOTSClient)(Xtransport *thistrans _X_UNUSED, const char *protocol, - const char *host, const char *port) - -{ - prmsg(2,"LocalOpenCOTSClient(%s,%s,%s)\n",protocol,host,port); - - return TRANS(LocalOpenClient)(XTRANS_OPEN_COTS_CLIENT, protocol, host, port); -} - -#endif /* TRANS_CLIENT */ - static XtransConnInfo TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, const char *host, const char *port) @@ -1080,21 +787,6 @@ TRANS(LocalAccept)(XtransConnInfo ciptr, int *status) return newciptr; } -#ifdef TRANS_CLIENT - -static int -TRANS(LocalConnect)(XtransConnInfo ciptr, - const char *host _X_UNUSED, const char *port) - -{ - prmsg(2,"LocalConnect(%p->%d,%s)\n", (void *) ciptr, ciptr->fd, port); - - return 0; -} - -#endif /* TRANS_CLIENT */ - - static int TRANS(LocalBytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend ) @@ -1207,9 +899,6 @@ static Xtransport TRANS(LocalFuncs) = { /* Local Interface */ "local", TRANS_ALIAS | TRANS_LOCAL, -#ifdef TRANS_CLIENT - TRANS(LocalOpenCOTSClient), -#endif /* TRANS_CLIENT */ local_aliases, TRANS(LocalOpenCOTSServer), TRANS(LocalReopenCOTSServer), @@ -1217,9 +906,6 @@ static Xtransport TRANS(LocalFuncs) = { TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#ifdef TRANS_CLIENT - TRANS(LocalConnect), -#endif /* TRANS_CLIENT */ TRANS(LocalBytesReadable), TRANS(LocalRead), TRANS(LocalWrite), @@ -1241,9 +927,6 @@ static Xtransport TRANS(NAMEDFuncs) = { /* Local Interface */ "named", TRANS_LOCAL, -#ifdef TRANS_CLIENT - TRANS(LocalOpenCOTSClient), -#endif /* TRANS_CLIENT */ NULL, TRANS(LocalOpenCOTSServer), TRANS(LocalReopenCOTSServer), @@ -1251,9 +934,6 @@ static Xtransport TRANS(NAMEDFuncs) = { TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#ifdef TRANS_CLIENT - TRANS(LocalConnect), -#endif /* TRANS_CLIENT */ TRANS(LocalBytesReadable), TRANS(LocalRead), TRANS(LocalWrite), @@ -1272,9 +952,6 @@ static Xtransport TRANS(PIPEFuncs) = { /* Local Interface */ "pipe", TRANS_ALIAS | TRANS_LOCAL, -#ifdef TRANS_CLIENT - TRANS(LocalOpenCOTSClient), -#endif /* TRANS_CLIENT */ NULL, TRANS(LocalOpenCOTSServer), TRANS(LocalReopenCOTSServer), @@ -1282,9 +959,6 @@ static Xtransport TRANS(PIPEFuncs) = { TRANS(LocalCreateListener), TRANS(LocalResetListener), TRANS(LocalAccept), -#ifdef TRANS_CLIENT - TRANS(LocalConnect), -#endif /* TRANS_CLIENT */ TRANS(LocalBytesReadable), TRANS(LocalRead), TRANS(LocalWrite), diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 14c1ae371..1b1581656 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -533,53 +533,6 @@ TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) * These functions are the interface supplied in the Xtransport structure */ -#ifdef TRANS_CLIENT - -static XtransConnInfo -TRANS(SocketOpenCOTSClientBase) (const char *transname, const char *protocol, - const char *host, const char *port, int previndex) -{ - XtransConnInfo ciptr = NULL; - int i = previndex; - - prmsg (2, "SocketOpenCOTSClient(%s,%s,%s)\n", - protocol, host, port); - - SocketInitOnce(); - - while ((i = TRANS(SocketSelectFamily) (i, transname)) >= 0) { - if ((ciptr = TRANS(SocketOpen) ( - i, Sockettrans2devtab[i].devcotsname)) != NULL) { - /* Save the index for later use */ - - ciptr->index = i; - break; - } - } - if (i < 0) { - if (i == -1) - prmsg (1,"SocketOpenCOTSClient: Unable to open socket for %s\n", - transname); - else - prmsg (1,"SocketOpenCOTSClient: Unable to determine socket type for %s\n", - transname); - return NULL; - } - - return ciptr; -} - -static XtransConnInfo -TRANS(SocketOpenCOTSClient) (Xtransport *thistrans, const char *protocol, - const char *host, const char *port) -{ - return TRANS(SocketOpenCOTSClientBase)( - thistrans->TransName, protocol, host, port, -1); -} - - -#endif /* TRANS_CLIENT */ - static XtransConnInfo TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, const char *host, const char *port) @@ -1256,674 +1209,6 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) #endif /* UNIXCONN */ -#ifdef TRANS_CLIENT - -#ifdef TCPCONN - -#ifdef HAVE_GETADDRINFO -struct addrlist { - struct addrinfo * addr; - struct addrinfo * firstaddr; - char port[PORTBUFSIZE]; - char host[MAXHOSTNAMELEN]; -}; -static struct addrlist *addrlist = NULL; -#endif - - -static int -TRANS(SocketINETConnect) (XtransConnInfo ciptr, - const char *host, const char *port) - -{ - struct sockaddr * socketaddr = NULL; - int socketaddrlen = 0; - int res; -#ifdef HAVE_GETADDRINFO - struct addrinfo hints; - char ntopbuf[INET6_ADDRSTRLEN]; - int resetonce = 0; -#else - struct sockaddr_in sockname; - struct hostent *hostp; - struct servent *servp; - unsigned long tmpaddr; -#endif -#ifdef XTHREADS_NEEDS_BYNAMEPARAMS - _Xgethostbynameparams hparams; - _Xgetservbynameparams sparams; -#endif - char portbuf[PORTBUFSIZE]; - - char hostnamebuf[256]; /* tmp space */ - - prmsg (2,"SocketINETConnect(%d,%s,%s)\n", ciptr->fd, host, port); - - if (!host) - { - hostnamebuf[0] = '\0'; - (void) TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf); - host = hostnamebuf; - } - - /* - * X has a well known port, that is transport dependent. It is easier - * to handle it here, than try and come up with a transport independent - * representation that can be passed in and resolved the usual way. - * - * The port that is passed here is really a string containing the idisplay - * from ConnectDisplay(). - */ - - if (is_numeric (port)) - { - long tmpport = X_TCP_PORT + strtol (port, (char**)NULL, 10); - snprintf (portbuf, sizeof(portbuf), "%lu", tmpport); - port = portbuf; - } - -#ifdef HAVE_GETADDRINFO - { - if (addrlist != NULL) { - if (strcmp(host,addrlist->host) || strcmp(port,addrlist->port)) { - if (addrlist->firstaddr) - freeaddrinfo(addrlist->firstaddr); - addrlist->firstaddr = NULL; - } - } else { - addrlist = malloc(sizeof(struct addrlist)); - if (addrlist == NULL) { - prmsg (1, "SocketINETConnect() can't allocate memory " - "for addrlist: %s\n", strerror(errno)); - return TRANS_CONNECT_FAILED; - } - addrlist->firstaddr = NULL; - } - - if (addrlist->firstaddr == NULL) { - strncpy(addrlist->port, port, sizeof(addrlist->port)); - addrlist->port[sizeof(addrlist->port) - 1] = '\0'; - strncpy(addrlist->host, host, sizeof(addrlist->host)); - addrlist->host[sizeof(addrlist->host) - 1] = '\0'; - - memset(&hints, 0, sizeof(hints)); -#ifdef IPv6 - if (strcmp(Sockettrans2devtab[ciptr->index].transname, "tcp") == 0) - hints.ai_family = AF_UNSPEC; - else -#endif - hints.ai_family = Sockettrans2devtab[ciptr->index].family; - hints.ai_socktype = Sockettrans2devtab[ciptr->index].devcotsname; - - res = getaddrinfo(host,port,&hints,&addrlist->firstaddr); - if (res != 0) { - prmsg (1, "SocketINETConnect() can't get address " - "for %s:%s: %s\n", host, port, gai_strerror(res)); - ESET(EINVAL); - return TRANS_CONNECT_FAILED; - } - for (res = 0, addrlist->addr = addrlist->firstaddr; - addrlist->addr ; res++) { - addrlist->addr = addrlist->addr->ai_next; - } - prmsg(4,"Got New Address list with %d addresses\n", res); - res = 0; - addrlist->addr = NULL; - } - - while (socketaddr == NULL) { - if (addrlist->addr == NULL) { - if (resetonce) { - /* Already checked entire list - no usable addresses */ - prmsg (1, "SocketINETConnect() no usable address " - "for %s:%s\n", host, port); - return TRANS_CONNECT_FAILED; - } else { - /* Go back to beginning of list */ - resetonce = 1; - addrlist->addr = addrlist->firstaddr; - } - } - - socketaddr = addrlist->addr->ai_addr; - socketaddrlen = addrlist->addr->ai_addrlen; - - if (addrlist->addr->ai_family == AF_INET) { - struct sockaddr_in *sin = (struct sockaddr_in *) socketaddr; - - prmsg (4,"SocketINETConnect() sockname.sin_addr = %s\n", - inet_ntop(addrlist->addr->ai_family,&sin->sin_addr, - ntopbuf,sizeof(ntopbuf))); - - prmsg (4,"SocketINETConnect() sockname.sin_port = %d\n", - ntohs(sin->sin_port)); - -#ifdef IPv6 - if (Sockettrans2devtab[ciptr->index].family == AF_INET6) { - if (strcmp(Sockettrans2devtab[ciptr->index].transname, - "tcp") == 0) { - XtransConnInfo newciptr; - - /* - * Our socket is an IPv6 socket, but the address is - * IPv4. Close it and get an IPv4 socket. This is - * needed for IPv4 connections to work on platforms - * that don't allow IPv4 over IPv6 sockets. - */ - TRANS(SocketINETClose)(ciptr); - newciptr = TRANS(SocketOpenCOTSClientBase)( - "tcp", "tcp", host, port, ciptr->index); - if (newciptr) - ciptr->fd = newciptr->fd; - if (!newciptr || - Sockettrans2devtab[newciptr->index].family != - AF_INET) { - socketaddr = NULL; - prmsg (4,"SocketINETConnect() Cannot get IPv4 " - " socketfor IPv4 address\n"); - } - if (newciptr) - free(newciptr); - } else { - socketaddr = NULL; - prmsg (4,"SocketINETConnect Skipping IPv4 address\n"); - } - } - } else if (addrlist->addr->ai_family == AF_INET6) { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) socketaddr; - - prmsg (4,"SocketINETConnect() sockname.sin6_addr = %s\n", - inet_ntop(addrlist->addr->ai_family, - &sin6->sin6_addr,ntopbuf,sizeof(ntopbuf))); - prmsg (4,"SocketINETConnect() sockname.sin6_port = %d\n", - ntohs(sin6->sin6_port)); - - if (Sockettrans2devtab[ciptr->index].family == AF_INET) { - if (strcmp(Sockettrans2devtab[ciptr->index].transname, - "tcp") == 0) { - XtransConnInfo newciptr; - - /* - * Close the IPv4 socket and try to open an IPv6 socket. - */ - TRANS(SocketINETClose)(ciptr); - newciptr = TRANS(SocketOpenCOTSClientBase)( - "tcp", "tcp", host, port, -1); - if (newciptr) - ciptr->fd = newciptr->fd; - if (!newciptr || - Sockettrans2devtab[newciptr->index].family != - AF_INET6) { - socketaddr = NULL; - prmsg (4,"SocketINETConnect() Cannot get IPv6 " - "socket for IPv6 address\n"); - } - if (newciptr) - free(newciptr); - } - else - { - socketaddr = NULL; - prmsg (4,"SocketINETConnect() Skipping IPv6 address\n"); - } - } -#endif /* IPv6 */ - } else { - socketaddr = NULL; /* Unsupported address type */ - } - if (socketaddr == NULL) { - addrlist->addr = addrlist->addr->ai_next; - } - } - } -#else /* !HAVE_GETADDRINFO */ - { - /* - * Build the socket name. - */ - -#ifdef BSD44SOCKETS - sockname.sin_len = sizeof (struct sockaddr_in); -#endif - sockname.sin_family = AF_INET; - - /* - * fill in sin_addr - */ - -#ifndef INADDR_NONE -#define INADDR_NONE ((in_addr_t) 0xffffffff) -#endif - - /* check for ww.xx.yy.zz host string */ - - if (isascii (host[0]) && isdigit (host[0])) { - tmpaddr = inet_addr (host); /* returns network byte order */ - } else { - tmpaddr = INADDR_NONE; - } - - prmsg (4,"SocketINETConnect() inet_addr(%s) = %lx\n", host, tmpaddr); - - if (tmpaddr == INADDR_NONE) { - if ((hostp = _XGethostbyname(host,hparams)) == NULL) { - prmsg (1,"SocketINETConnect: Can't get address for %s\n", - host); - ESET(EINVAL); - return TRANS_CONNECT_FAILED; - } - if (hostp->h_addrtype != AF_INET) { /* is IP host? */ - prmsg (1,"SocketINETConnect: not INET host%s\n", host); - ESET(EPROTOTYPE); - return TRANS_CONNECT_FAILED; - } - - memcpy ((char *) &sockname.sin_addr, (char *) hostp->h_addr, - sizeof (sockname.sin_addr)); - - } else { - sockname.sin_addr.s_addr = tmpaddr; - } - - /* - * fill in sin_port - */ - - /* Check for number in the port string */ - - if (!is_numeric (port)) { - if ((servp = _XGetservbyname (port,"tcp",sparams)) == NULL) { - prmsg (1,"SocketINETConnect: can't get service for %s\n", - port); - return TRANS_CONNECT_FAILED; - } - sockname.sin_port = htons (servp->s_port); - } else { - long tmpport = strtol (port, (char**)NULL, 10); - if (tmpport < 1024 || tmpport > USHRT_MAX) - return TRANS_CONNECT_FAILED; - sockname.sin_port = htons (((unsigned short) tmpport)); - } - - prmsg (4,"SocketINETConnect: sockname.sin_port = %d\n", - ntohs(sockname.sin_port)); - socketaddr = (struct sockaddr *) &sockname; - socketaddrlen = sizeof(sockname); - } -#endif - - /* - * Turn on socket keepalive so the client process will eventually - * be notified with a SIGPIPE signal if the display server fails - * to respond to a periodic transmission of messages - * on the connected socket. - * This is useful to avoid hung application processes when the - * processes are not spawned from the xdm session and - * the display server terminates abnormally. - * (Someone turned off the power switch.) - */ - - { - int tmp = 1; - setsockopt (ciptr->fd, SOL_SOCKET, SO_KEEPALIVE, - (char *) &tmp, sizeof (int)); - } - - /* - * Do the connect() - */ - - if (connect (ciptr->fd, socketaddr, socketaddrlen ) < 0) - { -#ifdef WIN32 - int olderrno = WSAGetLastError(); -#else - int olderrno = errno; -#endif - - /* - * If the error was ECONNREFUSED, the server may be overloaded - * and we should try again. - * - * If the error was EWOULDBLOCK or EINPROGRESS then the socket - * was non-blocking and we should poll using select - * - * If the error was EINTR, the connect was interrupted and we - * should try again. - * - * If multiple addresses are found for a host then we should - * try to connect again with a different address for a larger - * number of errors that made us quit before, since those - * could be caused by trying to use an IPv6 address to contact - * a machine with an IPv4-only server or other reasons that - * only affect one of a set of addresses. - */ - - if (olderrno == ECONNREFUSED || olderrno == EINTR -#ifdef HAVE_GETADDRINFO - || (((addrlist->addr->ai_next != NULL) || - (addrlist->addr != addrlist->firstaddr)) && - (olderrno == ENETUNREACH || olderrno == EAFNOSUPPORT || - olderrno == EADDRNOTAVAIL || olderrno == ETIMEDOUT -#if defined(EHOSTDOWN) - || olderrno == EHOSTDOWN -#endif - )) -#endif - ) - res = TRANS_TRY_CONNECT_AGAIN; - else if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS) - res = TRANS_IN_PROGRESS; - else - { - prmsg (2,"SocketINETConnect: Can't connect: errno = %d\n", - olderrno); - - res = TRANS_CONNECT_FAILED; - } - } else { - res = 0; - - - /* - * Sync up the address fields of ciptr. - */ - - if (TRANS(SocketINETGetAddr) (ciptr) < 0) - { - prmsg (1, - "SocketINETConnect: ...SocketINETGetAddr() failed:\n"); - res = TRANS_CONNECT_FAILED; - } - - else if (TRANS(SocketINETGetPeerAddr) (ciptr) < 0) - { - prmsg (1, - "SocketINETConnect: ...SocketINETGetPeerAddr() failed:\n"); - res = TRANS_CONNECT_FAILED; - } - } - -#ifdef HAVE_GETADDRINFO - if (res != 0) { - addrlist->addr = addrlist->addr->ai_next; - } -#endif - - return res; -} - -#endif /* TCPCONN */ - - - -#ifdef UNIXCONN - -/* - * Make sure 'host' is really local. - */ - -static int -UnixHostReallyLocal (const char *host) - -{ - char hostnamebuf[256]; - - TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf)); - - if (strcmp (hostnamebuf, host) == 0) - { - return (1); - } else { -#ifdef HAVE_GETADDRINFO - struct addrinfo *localhostaddr; - struct addrinfo *otherhostaddr; - struct addrinfo *i, *j; - int equiv = 0; - - if (getaddrinfo(hostnamebuf, NULL, NULL, &localhostaddr) != 0) - return 0; - if (getaddrinfo(host, NULL, NULL, &otherhostaddr) != 0) { - freeaddrinfo(localhostaddr); - return 0; - } - - for (i = localhostaddr; i != NULL && equiv == 0; i = i->ai_next) { - for (j = otherhostaddr; j != NULL && equiv == 0; j = j->ai_next) { - if (i->ai_family == j->ai_family) { - if (i->ai_family == AF_INET) { - struct sockaddr_in *sinA - = (struct sockaddr_in *) i->ai_addr; - struct sockaddr_in *sinB - = (struct sockaddr_in *) j->ai_addr; - struct in_addr *A = &sinA->sin_addr; - struct in_addr *B = &sinB->sin_addr; - - if (memcmp(A,B,sizeof(struct in_addr)) == 0) { - equiv = 1; - } -#ifdef IPv6 - } else if (i->ai_family == AF_INET6) { - struct sockaddr_in6 *sinA - = (struct sockaddr_in6 *) i->ai_addr; - struct sockaddr_in6 *sinB - = (struct sockaddr_in6 *) j->ai_addr; - struct in6_addr *A = &sinA->sin6_addr; - struct in6_addr *B = &sinB->sin6_addr; - - if (memcmp(A,B,sizeof(struct in6_addr)) == 0) { - equiv = 1; - } -#endif /* IPv6 */ - } - } - } - } - - freeaddrinfo(localhostaddr); - freeaddrinfo(otherhostaddr); - return equiv; -#else /* !HAVE_GETADDRINFO */ - /* - * A host may have more than one network address. If any of the - * network addresses of 'host' (specified to the connect call) - * match any of the network addresses of 'hostname' (determined - * by TRANS(GetHostname)), then the two hostnames are equivalent, - * and we know that 'host' is really a local host. - */ - char specified_local_addr_list[10][4]; - int scount, equiv, i, j; -#ifdef XTHREADS_NEEDS_BYNAMEPARAMS - _Xgethostbynameparams hparams; -#endif - struct hostent *hostp; - - if ((hostp = _XGethostbyname (host,hparams)) == NULL) - return (0); - - scount = 0; - while (hostp->h_addr_list[scount] && scount <= 8) - { - /* - * The 2nd call to gethostname() overrides the data - * from the 1st call, so we must save the address list. - */ - - specified_local_addr_list[scount][0] = - hostp->h_addr_list[scount][0]; - specified_local_addr_list[scount][1] = - hostp->h_addr_list[scount][1]; - specified_local_addr_list[scount][2] = - hostp->h_addr_list[scount][2]; - specified_local_addr_list[scount][3] = - hostp->h_addr_list[scount][3]; - scount++; - } - if ((hostp = _XGethostbyname (hostnamebuf,hparams)) == NULL) - return (0); - - equiv = 0; - i = 0; - - while (i < scount && !equiv) - { - j = 0; - - while (hostp->h_addr_list[j]) - { - if ((specified_local_addr_list[i][0] == - hostp->h_addr_list[j][0]) && - (specified_local_addr_list[i][1] == - hostp->h_addr_list[j][1]) && - (specified_local_addr_list[i][2] == - hostp->h_addr_list[j][2]) && - (specified_local_addr_list[i][3] == - hostp->h_addr_list[j][3])) - { - /* They're equal, so we're done */ - - equiv = 1; - break; - } - - j++; - } - - i++; - } - return (equiv); -#endif - } -} - -static int -TRANS(SocketUNIXConnect) (XtransConnInfo ciptr, - const char *host, const char *port) - -{ - struct sockaddr_un sockname; - SOCKLEN_T namelen; - - prmsg (2,"SocketUNIXConnect(%d,%s,%s)\n", ciptr->fd, host, port); - - /* - * Make sure 'host' is really local. If not, we return failure. - * The reason we make this check is because a process may advertise - * a "local" network ID for which it can accept connections, but if - * a process on a remote machine tries to connect to this network ID, - * we know for sure it will fail. - */ - - if (host && *host && host[0]!='/' && strcmp (host, "unix") != 0 && !UnixHostReallyLocal (host)) - { - prmsg (1, - "SocketUNIXConnect: Cannot connect to non-local host %s\n", - host); - return TRANS_CONNECT_FAILED; - } - - - /* - * Check the port. - */ - - if (!port || !*port) - { - prmsg (1,"SocketUNIXConnect: Missing port specification\n"); - return TRANS_CONNECT_FAILED; - } - - /* - * Build the socket name. - */ - - sockname.sun_family = AF_UNIX; - - if (set_sun_path(port, UNIX_PATH, sockname.sun_path, 0) != 0) { - prmsg (1, "SocketUNIXConnect: path too long\n"); - return TRANS_CONNECT_FAILED; - } - -#if defined(BSD44SOCKETS) - sockname.sun_len = strlen (sockname.sun_path); -#endif - -#if defined(BSD44SOCKETS) || defined(SUN_LEN) - namelen = SUN_LEN (&sockname); -#else - namelen = strlen (sockname.sun_path) + offsetof(struct sockaddr_un, sun_path); -#endif - - - /* - * Do the connect() - */ - - if (connect (ciptr->fd, (struct sockaddr *) &sockname, namelen) < 0) - { - int olderrno = errno; - int connected = 0; - - if (!connected) - { - errno = olderrno; - - /* - * If the error was ENOENT, the server may be starting up; we used - * to suggest to try again in this case with - * TRANS_TRY_CONNECT_AGAIN, but this introduced problems for - * processes still referencing stale sockets in their environment. - * Hence, we now return a hard error, TRANS_CONNECT_FAILED, and it - * is suggested that higher level stacks handle retries on their - * level when they face a slow starting server. - * - * If the error was EWOULDBLOCK or EINPROGRESS then the socket - * was non-blocking and we should poll using select - * - * If the error was EINTR, the connect was interrupted and we - * should try again. - */ - - if (olderrno == EWOULDBLOCK || olderrno == EINPROGRESS) - return TRANS_IN_PROGRESS; - else if (olderrno == EINTR) - return TRANS_TRY_CONNECT_AGAIN; - else { - prmsg (2,"SocketUNIXConnect: Can't connect: errno = %d\n", - EGET()); - - return TRANS_CONNECT_FAILED; - } - } - } - - /* - * Get the socket name and the peer name from the connect socket, - * since this is unix domain. - */ - - if ((ciptr->addr = malloc(namelen)) == NULL || - (ciptr->peeraddr = malloc(namelen)) == NULL) - { - prmsg (1, - "SocketUNIXCreateListener: Can't allocate space for the addr\n"); - return TRANS_CONNECT_FAILED; - } - - ciptr->family = AF_UNIX; - ciptr->addrlen = namelen; - ciptr->peeraddrlen = namelen; - memcpy (ciptr->addr, &sockname, ciptr->addrlen); - memcpy (ciptr->peeraddr, &sockname, ciptr->peeraddrlen); - - return 0; -} - -#endif /* UNIXCONN */ - -#endif /* TRANS_CLIENT */ - - static int TRANS(SocketBytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) @@ -2325,9 +1610,6 @@ static Xtransport TRANS(SocketTCPFuncs) = { /* Socket Interface */ "tcp", TRANS_ALIAS, -#ifdef TRANS_CLIENT - TRANS(SocketOpenCOTSClient), -#endif /* TRANS_CLIENT */ tcp_nolisten, TRANS(SocketOpenCOTSServer), TRANS(SocketReopenCOTSServer), @@ -2335,9 +1617,6 @@ static Xtransport TRANS(SocketTCPFuncs) = { TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#ifdef TRANS_CLIENT - TRANS(SocketINETConnect), -#endif /* TRANS_CLIENT */ TRANS(SocketBytesReadable), TRANS(SocketRead), TRANS(SocketWrite), @@ -2356,9 +1635,6 @@ static Xtransport TRANS(SocketINETFuncs) = { /* Socket Interface */ "inet", 0, -#ifdef TRANS_CLIENT - TRANS(SocketOpenCOTSClient), -#endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), TRANS(SocketReopenCOTSServer), @@ -2366,9 +1642,6 @@ static Xtransport TRANS(SocketINETFuncs) = { TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#ifdef TRANS_CLIENT - TRANS(SocketINETConnect), -#endif /* TRANS_CLIENT */ TRANS(SocketBytesReadable), TRANS(SocketRead), TRANS(SocketWrite), @@ -2388,9 +1661,6 @@ static Xtransport TRANS(SocketINET6Funcs) = { /* Socket Interface */ "inet6", 0, -#ifdef TRANS_CLIENT - TRANS(SocketOpenCOTSClient), -#endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), TRANS(SocketReopenCOTSServer), @@ -2398,9 +1668,6 @@ static Xtransport TRANS(SocketINET6Funcs) = { TRANS(SocketINETCreateListener), NULL, /* ResetListener */ TRANS(SocketINETAccept), -#ifdef TRANS_CLIENT - TRANS(SocketINETConnect), -#endif /* TRANS_CLIENT */ TRANS(SocketBytesReadable), TRANS(SocketRead), TRANS(SocketWrite), @@ -2427,9 +1694,6 @@ static Xtransport TRANS(SocketLocalFuncs) = { #else 0, #endif -#ifdef TRANS_CLIENT - TRANS(SocketOpenCOTSClient), -#endif /* TRANS_CLIENT */ NULL, TRANS(SocketOpenCOTSServer), TRANS(SocketReopenCOTSServer), @@ -2437,9 +1701,6 @@ static Xtransport TRANS(SocketLocalFuncs) = { TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), TRANS(SocketUNIXAccept), -#ifdef TRANS_CLIENT - TRANS(SocketUNIXConnect), -#endif /* TRANS_CLIENT */ TRANS(SocketBytesReadable), TRANS(SocketRead), TRANS(SocketWrite), @@ -2466,9 +1727,6 @@ static Xtransport TRANS(SocketUNIXFuncs) = { #else 0, #endif -#ifdef TRANS_CLIENT - TRANS(SocketOpenCOTSClient), -#endif /* TRANS_CLIENT */ #if !defined(LOCALCONN) unix_nolisten, #else @@ -2480,9 +1738,6 @@ static Xtransport TRANS(SocketUNIXFuncs) = { TRANS(SocketUNIXCreateListener), TRANS(SocketUNIXResetListener), TRANS(SocketUNIXAccept), -#ifdef TRANS_CLIENT - TRANS(SocketUNIXConnect), -#endif /* TRANS_CLIENT */ TRANS(SocketBytesReadable), TRANS(SocketRead), TRANS(SocketWrite), From 053f43e6aed3817903a6d08579aba19734f4219a Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Wed, 12 Feb 2025 19:26:16 +0100 Subject: [PATCH 18/23] os: xtrans: drop DEV_PTMX Not used anywhere. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtranslcl.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index dfa30c0b6..63f2f4662 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -204,8 +204,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, #define X_STREAMS_DIR "/tmp/.X11-pipe" -#define DEV_PTMX "/dev/ptmx" - #define NAMEDNODENAME "/tmp/.X11-pipe/X" #ifdef LOCAL_TRANS_NAMED From cbcb9718effa6364c40fe4f14cde02263e148bc5 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 16:58:55 +0200 Subject: [PATCH 19/23] os: xtrans: drop ifdefs on NAMEDNODENAME It's always defined, so no ifdefs needed. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtranslcl.c | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 63f2f4662..4bd345806 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -210,7 +210,6 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, /* NAMED */ -#ifdef NAMEDNODENAME static int TRANS(NAMEDOpenPipe)(const char *server_path) { @@ -270,22 +269,15 @@ TRANS(NAMEDOpenPipe)(const char *server_path) return(pipefd[1]); } -#endif static int TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) { -#ifdef NAMEDNODENAME int fd; char server_path[64]; -#endif prmsg(2,"NAMEDOpenServer(%s)\n", port); -#if !defined(NAMEDNODENAME) - prmsg(1,"NAMEDOpenServer: Protocol is not supported by a NAMED connection\n"); - return -1; -#else if ( port && *port ) { if( *port == '/' ) { /* A full pathname */ (void) snprintf(server_path, sizeof(server_path), "%s", port); @@ -315,8 +307,6 @@ TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) } return fd; - -#endif /* !NAMEDNODENAME */ } static int @@ -401,16 +391,10 @@ static int TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *port) { -#ifdef NAMEDNODENAME char server_path[64]; -#endif prmsg(2,"NAMEDReopenServer(%s)\n", port); -#if !defined(NAMEDNODENAME) - prmsg(1,"NAMEDReopenServer: Protocol is not supported by a NAMED connection\n"); - return 0; -#else if ( port && *port ) { if( *port == '/' ) { /* A full pathname */ snprintf(server_path, sizeof(server_path),"%s", port); @@ -430,8 +414,6 @@ TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *por } return 1; - -#endif /* !NAMEDNODENAME */ } #endif /* LOCAL_TRANS_NAMED */ From 8b3ab3586caf8dfe87d5654da4216548c923fcb5 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 17:08:31 +0200 Subject: [PATCH 20/23] os: xtrans: drop GetReopenInfo() Not used anywhere, so no need to keep it around anymore. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 22 ---------------------- os/Xtrans.h | 7 ------- 2 files changed, 29 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index dce2f953d..847b7f630 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -556,28 +556,6 @@ TRANS(ReopenCOTSServer) (int trans_id, int fd, const char *port) return TRANS(Reopen) (XTRANS_OPEN_COTS_SERVER, trans_id, fd, port); } -int -TRANS(GetReopenInfo) (XtransConnInfo ciptr, - int *trans_id, int *fd, char **port) - -{ - for (unsigned int i = 0; i < NUMTRANS; i++) - { - if (Xtransports[i].transport == ciptr->transptr) - { - *trans_id = Xtransports[i].transport_id; - *fd = ciptr->fd; - - if ((*port = strdup (ciptr->port)) == NULL) - return 0; - else - return 1; - } - } - - return 0; -} - int TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) diff --git a/os/Xtrans.h b/os/Xtrans.h index 83dd2b4d0..0ac69ef86 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -190,13 +190,6 @@ XtransConnInfo TRANS(ReopenCOTSServer)( const char * /* port */ ); -int TRANS(GetReopenInfo)( - XtransConnInfo, /* ciptr */ - int *, /* trans_id */ - int *, /* fd */ - char ** /* port */ -); - int TRANS(SetOption)( XtransConnInfo, /* ciptr */ int, /* option */ From 5d0b9f4508f2f358442ccc721f81b202da854653 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Thu, 26 Jun 2025 19:09:07 +0200 Subject: [PATCH 21/23] os: xtrans: expand TRANS() macro to _XSERVTrans Since TRANS() now will always expand the same, it's better for maintenance, having the function names written explicitly. Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 176 ++++++++++---------------- os/Xtrans.h | 60 +++++---- os/Xtransint.h | 8 +- os/Xtranslcl.c | 308 +++++++++++++++++++-------------------------- os/Xtranssock.c | 329 +++++++++++++++++++++--------------------------- os/Xtransutil.c | 12 +- os/connection.c | 2 +- 7 files changed, 380 insertions(+), 515 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index 847b7f630..2063793df 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -90,25 +90,25 @@ from The Open Group. static Xtransport_table Xtransports[] = { #if defined(TCPCONN) - { &TRANS(SocketTCPFuncs), TRANS_SOCKET_TCP_INDEX }, + { &_XSERVTransSocketTCPFuncs, TRANS_SOCKET_TCP_INDEX }, #if defined(IPv6) - { &TRANS(SocketINET6Funcs), TRANS_SOCKET_INET6_INDEX }, + { &_XSERVTransSocketINET6Funcs, TRANS_SOCKET_INET6_INDEX }, #endif /* IPv6 */ - { &TRANS(SocketINETFuncs), TRANS_SOCKET_INET_INDEX }, + { &_XSERVTransSocketINETFuncs, TRANS_SOCKET_INET_INDEX }, #endif /* TCPCONN */ #if defined(UNIXCONN) #if !defined(LOCALCONN) - { &TRANS(SocketLocalFuncs), TRANS_SOCKET_LOCAL_INDEX }, + { &_XSERVTransSocketLocalFuncs, TRANS_SOCKET_LOCAL_INDEX }, #endif /* !LOCALCONN */ - { &TRANS(SocketUNIXFuncs), TRANS_SOCKET_UNIX_INDEX }, + { &_XSERVTransSocketUNIXFuncs, TRANS_SOCKET_UNIX_INDEX }, #endif /* UNIXCONN */ #if defined(LOCALCONN) - { &TRANS(LocalFuncs), TRANS_LOCAL_LOCAL_INDEX }, + { &_XSERVTransLocalFuncs, TRANS_LOCAL_LOCAL_INDEX }, #if defined(SVR4) || defined(__SVR4) - { &TRANS(NAMEDFuncs), TRANS_LOCAL_NAMED_INDEX }, + { &_XSERVTransNAMEDFuncs, TRANS_LOCAL_NAMED_INDEX }, #endif #ifdef __sun - { &TRANS(PIPEFuncs), TRANS_LOCAL_PIPE_INDEX }, + { &_XSERVTransPIPEFuncs, TRANS_LOCAL_PIPE_INDEX }, #endif /* __sun */ #endif /* LOCALCONN */ }; @@ -125,9 +125,7 @@ Xtransport_table Xtransports[] = { /* * These are a few utility function used by the public interface functions. */ - -void -TRANS(FreeConnInfo) (XtransConnInfo ciptr) +void _XSERVTransFreeConnInfo (XtransConnInfo ciptr) { prmsg (3,"FreeConnInfo(%p)\n", (void *) ciptr); @@ -148,7 +146,7 @@ TRANS(FreeConnInfo) (XtransConnInfo ciptr) #define PROTOBUFSIZE 20 static Xtransport * -TRANS(SelectTransport) (const char *protocol) +_XSERVTransSelectTransport (const char *protocol) { #ifndef HAVE_STRCASECMP @@ -187,7 +185,7 @@ TRANS(SelectTransport) (const char *protocol) } static int -TRANS(ParseAddress) (const char *address, +_XSERVTransParseAddress (const char *address, char **protocol, char **host, char **port) { @@ -314,7 +312,7 @@ TRANS(ParseAddress) (const char *address, _host_len = strlen(_host); if (_host_len == 0) { - TRANS(GetHostname) (hostnamebuf, sizeof (hostnamebuf)); + _XSERVTransGetHostname (hostnamebuf, sizeof (hostnamebuf)); _host = hostnamebuf; } #ifdef IPv6 @@ -389,13 +387,13 @@ done_parsing: /* - * TRANS(Open) does all of the real work opening a connection. The only + * _XSERVTransOpen does all of the real work opening a connection. The only * funny part about this is the type parameter which is used to decide which * type of open to perform. */ static XtransConnInfo -TRANS(Open) (int type, const char *address) +_XSERVTransOpen (int type, const char *address) { char *protocol = NULL, *host = NULL, *port = NULL; @@ -405,7 +403,7 @@ TRANS(Open) (int type, const char *address) prmsg (2,"Open(%d,%s)\n", type, address); #if defined(WIN32) && defined(TCPCONN) - if (TRANS(WSAStartup)()) + if (_XSERVTransWSAStartup()) { prmsg (1,"Open: WSAStartup failed\n"); return NULL; @@ -414,7 +412,7 @@ TRANS(Open) (int type, const char *address) /* Parse the Address */ - if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0) + if (_XSERVTransParseAddress (address, &protocol, &host, &port) == 0) { prmsg (1,"Open: Unable to Parse address %s\n", address); return NULL; @@ -422,7 +420,7 @@ TRANS(Open) (int type, const char *address) /* Determine the transport type */ - if ((thistrans = TRANS(SelectTransport) (protocol)) == NULL) + if ((thistrans = _XSERVTransSelectTransport (protocol)) == NULL) { prmsg (1,"Open: Unable to find transport for %s\n", protocol); @@ -460,7 +458,7 @@ TRANS(Open) (int type, const char *address) } ciptr->transptr = thistrans; - ciptr->port = port; /* We need this for TRANS(Reopen) */ + ciptr->port = port; /* We need this for _XSERVTransReopen */ free (protocol); free (host); @@ -475,7 +473,7 @@ TRANS(Open) (int type, const char *address) */ static XtransConnInfo -TRANS(Reopen) (int type, int trans_id, int fd, const char *port) +_XSERVTransReopen (int type, int trans_id, int fd, const char *port) { XtransConnInfo ciptr = NULL; @@ -541,23 +539,22 @@ TRANS(Reopen) (int type, int trans_id, int fd, const char *port) */ XtransConnInfo -TRANS(OpenCOTSServer) (const char *address) +_XSERVTransOpenCOTSServer (const char *address) { prmsg (2,"OpenCOTSServer(%s)\n", address); - return TRANS(Open) (XTRANS_OPEN_COTS_SERVER, address); + return _XSERVTransOpen (XTRANS_OPEN_COTS_SERVER, address); } XtransConnInfo -TRANS(ReopenCOTSServer) (int trans_id, int fd, const char *port) +_XSERVTransReopenCOTSServer (int trans_id, int fd, const char *port) { prmsg (2,"ReopenCOTSServer(%d, %d, %s)\n", trans_id, fd, port); - return TRANS(Reopen) (XTRANS_OPEN_COTS_SERVER, trans_id, fd, port); + return _XSERVTransReopen (XTRANS_OPEN_COTS_SERVER, trans_id, fd, port); } -int -TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) +int _XSERVTransSetOption (XtransConnInfo ciptr, int option, int arg) { int fd = ciptr->fd; @@ -605,7 +602,7 @@ TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) int arg; #endif arg = 1; -/* IBM TCP/IP understands this option too well: it causes TRANS(Read) to fail +/* IBM TCP/IP understands this option too well: it causes _XSERVTransRead to fail * eventually with EWOULDBLOCK */ ret = ioctl (fd, FIONBIO, &arg); } @@ -639,21 +636,19 @@ TRANS(SetOption) (XtransConnInfo ciptr, int option, int arg) return ret; } -int -TRANS(CreateListener) (XtransConnInfo ciptr, const char *port, unsigned int flags) +int _XSERVTransCreateListener (XtransConnInfo ciptr, const char *port, unsigned int flags) { return ciptr->transptr->CreateListener (ciptr, port, flags); } -int -TRANS(Received) (const char * protocol) +int _XSERVTransReceived (const char * protocol) { Xtransport *trans; int i = 0, ret = 0; prmsg (5, "Received(%s)\n", protocol); - if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + if ((trans = _XSERVTransSelectTransport(protocol)) == NULL) { prmsg (1,"Received: unable to find transport: %s\n", protocol); @@ -663,7 +658,7 @@ TRANS(Received) (const char * protocol) if (trans->flags & TRANS_ALIAS) { if (trans->nolisten) while (trans->nolisten[i]) { - ret |= TRANS(Received)(trans->nolisten[i]); + ret |= _XSERVTransReceived(trans->nolisten[i]); i++; } } @@ -672,13 +667,12 @@ TRANS(Received) (const char * protocol) return ret; } -int -TRANS(NoListen) (const char * protocol) +int _XSERVTransNoListen (const char * protocol) { Xtransport *trans; int i = 0, ret = 0; - if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + if ((trans = _XSERVTransSelectTransport(protocol)) == NULL) { prmsg (1,"TransNoListen: unable to find transport: %s\n", protocol); @@ -688,7 +682,7 @@ TRANS(NoListen) (const char * protocol) if (trans->flags & TRANS_ALIAS) { if (trans->nolisten) while (trans->nolisten[i]) { - ret |= TRANS(NoListen)(trans->nolisten[i]); + ret |= _XSERVTransNoListen(trans->nolisten[i]); i++; } } @@ -697,13 +691,12 @@ TRANS(NoListen) (const char * protocol) return ret; } -int -TRANS(Listen) (const char * protocol) +int _XSERVTransListen (const char * protocol) { Xtransport *trans; int i = 0, ret = 0; - if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + if ((trans = _XSERVTransSelectTransport(protocol)) == NULL) { prmsg (1,"TransListen: unable to find transport: %s\n", protocol); @@ -713,7 +706,7 @@ TRANS(Listen) (const char * protocol) if (trans->flags & TRANS_ALIAS) { if (trans->nolisten) while (trans->nolisten[i]) { - ret |= TRANS(Listen)(trans->nolisten[i]); + ret |= _XSERVTransListen(trans->nolisten[i]); i++; } } @@ -722,12 +715,11 @@ TRANS(Listen) (const char * protocol) return ret; } -int -TRANS(IsListening) (const char * protocol) +int _XSERVTransIsListening (const char * protocol) { Xtransport *trans; - if ((trans = TRANS(SelectTransport)(protocol)) == NULL) + if ((trans = _XSERVTransSelectTransport(protocol)) == NULL) { prmsg (1,"TransIsListening: unable to find transport: %s\n", protocol); @@ -738,8 +730,7 @@ TRANS(IsListening) (const char * protocol) return !(trans->flags & TRANS_NOLISTEN); } -int -TRANS(ResetListener) (XtransConnInfo ciptr) +int _XSERVTransResetListener (XtransConnInfo ciptr) { if (ciptr->transptr->ResetListener) return ciptr->transptr->ResetListener (ciptr); @@ -747,8 +738,7 @@ TRANS(ResetListener) (XtransConnInfo ciptr) return TRANS_RESET_NOOP; } -XtransConnInfo -TRANS(Accept) (XtransConnInfo ciptr, int *status) +XtransConnInfo _XSERVTransAccept (XtransConnInfo ciptr, int *status) { XtransConnInfo newciptr; @@ -762,65 +752,49 @@ TRANS(Accept) (XtransConnInfo ciptr, int *status) return newciptr; } -int -TRANS(BytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) - +int _XSERVTransBytesReadable (XtransConnInfo ciptr, BytesReadable_t *pend) { return ciptr->transptr->BytesReadable (ciptr, pend); } -int -TRANS(Read) (XtransConnInfo ciptr, char *buf, int size) - +int _XSERVTransRead (XtransConnInfo ciptr, char *buf, int size) { return ciptr->transptr->Read (ciptr, buf, size); } -int -TRANS(Write) (XtransConnInfo ciptr, const char *buf, int size) - +int _XSERVTransWrite (XtransConnInfo ciptr, const char *buf, int size) { return ciptr->transptr->Write (ciptr, buf, size); } -int -TRANS(Readv) (XtransConnInfo ciptr, struct iovec *buf, int size) - +int _XSERVTransReadv (XtransConnInfo ciptr, struct iovec *buf, int size) { return ciptr->transptr->Readv (ciptr, buf, size); } -int -TRANS(Writev) (XtransConnInfo ciptr, struct iovec *buf, int size) - +int _XSERVTransWritev (XtransConnInfo ciptr, struct iovec *buf, int size) { return ciptr->transptr->Writev (ciptr, buf, size); } #if XTRANS_SEND_FDS -int -TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close) +int _XSERVTransSendFd (XtransConnInfo ciptr, int fd, int do_close) { return ciptr->transptr->SendFd(ciptr, fd, do_close); } -int -TRANS(RecvFd) (XtransConnInfo ciptr) +int _XSERVTransRecvFd (XtransConnInfo ciptr) { return ciptr->transptr->RecvFd(ciptr); } #endif -int -TRANS(Disconnect) (XtransConnInfo ciptr) - +int _XSERVTransDisconnect (XtransConnInfo ciptr) { return ciptr->transptr->Disconnect (ciptr); } -int -TRANS(Close) (XtransConnInfo ciptr) - +int _XSERVTransClose (XtransConnInfo ciptr) { int ret; @@ -828,14 +802,12 @@ TRANS(Close) (XtransConnInfo ciptr) ret = ciptr->transptr->Close (ciptr); - TRANS(FreeConnInfo) (ciptr); + _XSERVTransFreeConnInfo (ciptr); return ret; } -int -TRANS(CloseForCloning) (XtransConnInfo ciptr) - +int _XSERVTransCloseForCloning (XtransConnInfo ciptr) { int ret; @@ -843,22 +815,18 @@ TRANS(CloseForCloning) (XtransConnInfo ciptr) ret = ciptr->transptr->CloseForCloning (ciptr); - TRANS(FreeConnInfo) (ciptr); + _XSERVTransFreeConnInfo (ciptr); return ret; } -int -TRANS(IsLocal) (XtransConnInfo ciptr) - +int _XSERVTransIsLocal (XtransConnInfo ciptr) { return (ciptr->family == AF_UNIX); } -int -TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp, +int _XSERVTransGetPeerAddr (XtransConnInfo ciptr, int *familyp, int *addrlenp, Xtransaddr **addrp) - { prmsg (2,"GetPeerAddr(%d)\n", ciptr->fd); @@ -875,10 +843,7 @@ TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp, return 0; } - -int -TRANS(GetConnectionNumber) (XtransConnInfo ciptr) - +int _XSERVTransGetConnectionNumber (XtransConnInfo ciptr) { return ciptr->fd; } @@ -971,7 +936,7 @@ receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs, return -1; } - ciptr = TRANS(ReopenCOTSServer)(ti, i + SD_LISTEN_FDS_START, port); + ciptr = _XSERVTransReopenCOTSServer(ti, i + SD_LISTEN_FDS_START, port); if (!ciptr) { prmsg (1, "receive_listening_fds:" @@ -982,7 +947,7 @@ receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs, prmsg (5, "receive_listening_fds: received listener for %s, %d\n", tn, ciptr->fd); temp_ciptrs[(*count_ret)++] = ciptr; - TRANS(Received)(tn); + _XSERVTransReceived(tn); } #endif /* HAVE_SYSTEMD_DAEMON */ return 0; @@ -992,10 +957,8 @@ receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs, extern int xquartz_launchd_fd; #endif -int -TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, +int _XSERVTransMakeAllCOTSServerListeners (const char *port, int *partial, int *count_ret, XtransConnInfo **ciptrs_ret) - { char buffer[256]; /* ??? What size ?? */ XtransConnInfo ciptr, temp_ciptrs[NUMTRANS] = { NULL }; @@ -1012,7 +975,7 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, #ifdef XQUARTZ_EXPORTS_LAUNCHD_FD fprintf(stderr, "Launchd socket fd: %d\n", xquartz_launchd_fd); if(xquartz_launchd_fd != -1) { - if((ciptr = TRANS(ReopenCOTSServer(TRANS_SOCKET_LOCAL_INDEX, + if((ciptr = _XSERVTransReopenCOTSServer(TRANS_SOCKET_LOCAL_INDEX, xquartz_launchd_fd, getenv("DISPLAY"))))==NULL) fprintf(stderr,"Got NULL while trying to Reopen launchd port\n"); else @@ -1038,7 +1001,7 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, prmsg (5,"MakeAllCOTSServerListeners: opening %s\n", buffer); - if ((ciptr = TRANS(OpenCOTSServer(buffer))) == NULL) + if ((ciptr = _XSERVTransOpenCOTSServer(buffer)) == NULL) { if (trans->flags & TRANS_DISABLED) continue; @@ -1054,7 +1017,7 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, flags |= ADDR_IN_USE_ALLOWED; #endif - if ((status = TRANS(CreateListener (ciptr, port, flags))) < 0) + if ((status = _XSERVTransCreateListener (ciptr, port, flags)) < 0) { if (*partial != 0) continue; @@ -1072,7 +1035,7 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, for (j = 0; j < *count_ret; j++) if (temp_ciptrs[j] != NULL) - TRANS(Close) (temp_ciptrs[j]); + _XSERVTransClose (temp_ciptrs[j]); *count_ret = 0; *ciptrs_ret = NULL; @@ -1138,9 +1101,7 @@ TRANS(MakeAllCOTSServerListeners) (const char *port, int *partial, /* * emulate readv */ - -static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) - +static int _XSERVTransReadV (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) { int i, len, total; char *base; @@ -1151,7 +1112,7 @@ static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) base = iov->iov_base; while (len > 0) { register int nbytes; - nbytes = TRANS(Read) (ciptr, base, len); + nbytes = _XSERVTransRead (ciptr, base, len); if (nbytes < 0 && total == 0) return -1; if (nbytes <= 0) return total; ESET(0); @@ -1167,9 +1128,7 @@ static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) /* * emulate writev */ - -static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) - +static int _XSERVTransWriteV (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) { int i, len, total; char *base; @@ -1180,7 +1139,7 @@ static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) base = iov->iov_base; while (len > 0) { register int nbytes; - nbytes = TRANS(Write) (ciptr, base, len); + nbytes = _XSERVTransWrite (ciptr, base, len); if (nbytes < 0 && total == 0) return -1; if (nbytes <= 0) return total; ESET(0); @@ -1196,10 +1155,9 @@ static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt) /* - * TRANS(GetHostname) - similar to gethostname but allows special processing. + * _XSERVTransGetHostname - similar to gethostname but allows special processing. */ - -int TRANS(GetHostname) (char *buf, int maxlen) +int _XSERVTransGetHostname (char *buf, int maxlen) { struct utsname name; uname (&name); diff --git a/os/Xtrans.h b/os/Xtrans.h index 0ac69ef86..fa40550e4 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -68,7 +68,6 @@ from The Open Group. * Set the functions names according to where this code is being compiled. */ -#define TRANS(func) _XSERVTrans##func #ifdef XTRANSDEBUG static const char *__xtransname = "_XSERVTrans"; #endif @@ -112,7 +111,7 @@ typedef long BytesReadable_t; #if defined(WIN32) /* - * TRANS(Readv) and TRANS(Writev) use struct iovec, normally found + * _XSERVTransReadv and _XSERVTransWritev use struct iovec, normally found * in Berkeley systems in . See the readv(2) and writev(2) * manual pages for details. */ @@ -176,118 +175,118 @@ typedef struct _XtransConnInfo *XtransConnInfo; * Function prototypes for the exposed interface */ -void TRANS(FreeConnInfo) ( +void _XSERVTransFreeConnInfo ( XtransConnInfo /* ciptr */ ); -XtransConnInfo TRANS(OpenCOTSServer)( +XtransConnInfo _XSERVTransOpenCOTSServer( const char * /* address */ ); -XtransConnInfo TRANS(ReopenCOTSServer)( +XtransConnInfo _XSERVTransReopenCOTSServer( int, /* trans_id */ int, /* fd */ const char * /* port */ ); -int TRANS(SetOption)( +int _XSERVTransSetOption( XtransConnInfo, /* ciptr */ int, /* option */ int /* arg */ ); -int TRANS(CreateListener)( +int _XSERVTransCreateListener( XtransConnInfo, /* ciptr */ const char *, /* port */ unsigned int /* flags */ ); -int TRANS(Received) ( +int _XSERVTransReceived ( const char* /* protocol*/ ); -int TRANS(NoListen) ( +int _XSERVTransNoListen ( const char* /* protocol*/ ); -int TRANS(Listen) ( +int _XSERVTransListen ( const char* /* protocol*/ ); -int TRANS(IsListening) ( +int _XSERVTransIsListening ( const char* /* protocol*/ ); -int TRANS(ResetListener)( +int _XSERVTransResetListener ( XtransConnInfo /* ciptr */ ); -XtransConnInfo TRANS(Accept)( +XtransConnInfo _XSERVTransAccept ( XtransConnInfo, /* ciptr */ int * /* status */ ); -int TRANS(BytesReadable)( +int _XSERVTransBytesReadable ( XtransConnInfo, /* ciptr */ BytesReadable_t * /* pend */ ); -int TRANS(Read)( +int _XSERVTransRead ( XtransConnInfo, /* ciptr */ char *, /* buf */ int /* size */ ); -int TRANS(Write)( +int _XSERVTransWrite ( XtransConnInfo, /* ciptr */ const char *, /* buf */ int /* size */ ); -int TRANS(Readv)( +int _XSERVTransReadv ( XtransConnInfo, /* ciptr */ struct iovec *, /* buf */ int /* size */ ); -int TRANS(Writev)( +int _XSERVTransWritev ( XtransConnInfo, /* ciptr */ struct iovec *, /* buf */ int /* size */ ); -int TRANS(SendFd) (XtransConnInfo ciptr, int fd, int do_close); +int _XSERVTransSendFd (XtransConnInfo ciptr, int fd, int do_close); -int TRANS(RecvFd) (XtransConnInfo ciptr); +int _XSERVTransRecvFd (XtransConnInfo ciptr); -int TRANS(Disconnect)( +int _XSERVTransDisconnect ( XtransConnInfo /* ciptr */ ); -int TRANS(Close)( +int _XSERVTransClose ( XtransConnInfo /* ciptr */ ); -int TRANS(CloseForCloning)( +int _XSERVTransCloseForCloning ( XtransConnInfo /* ciptr */ ); -int TRANS(IsLocal)( +int _XSERVTransIsLocal ( XtransConnInfo /* ciptr */ ); -int TRANS(GetPeerAddr)( +int _XSERVTransGetPeerAddr ( XtransConnInfo, /* ciptr */ int *, /* familyp */ int *, /* addrlenp */ Xtransaddr ** /* addrp */ ); -int TRANS(GetConnectionNumber)( +int _XSERVTransGetConnectionNumber ( XtransConnInfo /* ciptr */ ); -int TRANS(MakeAllCOTSServerListeners)( +int _XSERVTransMakeAllCOTSServerListeners ( const char *, /* port */ int *, /* partial */ int *, /* count_ret */ @@ -298,20 +297,19 @@ int TRANS(MakeAllCOTSServerListeners)( * Function Prototypes for Utility Functions. */ -int TRANS(ConvertAddress)( +int _XSERVTransConvertAddress ( int *, /* familyp */ int *, /* addrlenp */ Xtransaddr ** /* addrp */ ); -int -TRANS(GetHostname) ( +int _XSERVTransGetHostname ( char * /* buf */, int /* maxlen */ ); #if defined(WIN32) && defined(TCPCONN) -int TRANS(WSAStartup)(); +int _XSERVTransWSAStartup(); #endif #endif /* _XTRANS_H_ */ diff --git a/os/Xtransint.h b/os/Xtransint.h index f02bfbec7..16778b2e4 100644 --- a/os/Xtransint.h +++ b/os/Xtransint.h @@ -266,9 +266,9 @@ typedef struct _Xtransport_table { #ifdef WIN32 -#define READV(ciptr, iov, iovcnt) TRANS(ReadV)(ciptr, iov, iovcnt) +#define READV(ciptr, iov, iovcnt) _XSERVTransReadV(ciptr, iov, iovcnt) -static int TRANS(ReadV)( +static int _XSERVTransReadV( XtransConnInfo, /* ciptr */ struct iovec *, /* iov */ int /* iovcnt */ @@ -283,9 +283,9 @@ static int TRANS(ReadV)( #ifdef WIN32 -#define WRITEV(ciptr, iov, iovcnt) TRANS(WriteV)(ciptr, iov, iovcnt) +#define WRITEV(ciptr, iov, iovcnt) _XSERVTransWriteV(ciptr, iov, iovcnt) -static int TRANS(WriteV)( +static int _XSERVTransWriteV( XtransConnInfo, /* ciptr */ struct iovec *, /* iov */ int /* iovcnt */ diff --git a/os/Xtranslcl.c b/os/Xtranslcl.c index 4bd345806..6ddd7f7d0 100644 --- a/os/Xtranslcl.c +++ b/os/Xtranslcl.c @@ -101,7 +101,7 @@ from The Open Group. # define LOCAL_TRANS_NAMED #endif -static int TRANS(LocalClose)(XtransConnInfo ciptr); +static int _XSERVTransLocalClose(XtransConnInfo ciptr); /* * These functions actually implement the local connection mechanisms. @@ -109,42 +109,34 @@ static int TRANS(LocalClose)(XtransConnInfo ciptr); /* Type Not Supported */ -static int -TRANS(OpenFail)(XtransConnInfo ciptr _X_UNUSED, const char *port _X_UNUSED) - +static int _XSERVTransOpenFail(XtransConnInfo ciptr _X_UNUSED, const char *port _X_UNUSED) { return -1; } -static int -TRANS(ReopenFail)(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED, +static int ReopenFail(XtransConnInfo ciptr _X_UNUSED, int fd _X_UNUSED, const char *port _X_UNUSED) - { return 0; } #if XTRANS_SEND_FDS -static int -TRANS(LocalRecvFdInvalid)(XtransConnInfo ciptr) +static int _XSERVTransLocalRecvFdInvalid(XtransConnInfo ciptr) { errno = EINVAL; return -1; } -static int -TRANS(LocalSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close) +static int LocalSendFdInvalid(XtransConnInfo ciptr, int fd, int do_close) { errno = EINVAL; return -1; } #endif - -static int -TRANS(FillAddrInfo)(XtransConnInfo ciptr, - const char *sun_path, const char *peer_sun_path) +static int _XSERVTransFillAddrInfo(XtransConnInfo ciptr, + const char *sun_path, const char *peer_sun_path) { struct sockaddr_un *sunaddr; struct sockaddr_un *p_sunaddr; @@ -210,8 +202,7 @@ TRANS(FillAddrInfo)(XtransConnInfo ciptr, /* NAMED */ -static int -TRANS(NAMEDOpenPipe)(const char *server_path) +static int _XSERVTransNAMEDOpenPipe(const char *server_path) { int fd, pipefd[2]; struct stat sbuf; @@ -270,8 +261,7 @@ TRANS(NAMEDOpenPipe)(const char *server_path) return(pipefd[1]); } -static int -TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) +static int NAMEDOpenServer(XtransConnInfo ciptr, const char *port) { int fd; char server_path[64]; @@ -290,7 +280,7 @@ TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) NAMEDNODENAME, (long)getpid()); } - fd = TRANS(NAMEDOpenPipe)(server_path); + fd = _XSERVTransNAMEDOpenPipe(server_path); if (fd < 0) { return -1; } @@ -299,18 +289,17 @@ TRANS(NAMEDOpenServer)(XtransConnInfo ciptr, const char *port) * Everything looks good: fill in the XtransConnInfo structure. */ - if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) + if (_XSERVTransFillAddrInfo (ciptr, server_path, server_path) == 0) { prmsg(1,"NAMEDOpenServer: failed to fill in addr info\n"); - TRANS(LocalClose)(ciptr); + _XSERVTransLocalClose(ciptr); return -1; } return fd; } -static int -TRANS(NAMEDResetListener) (XtransConnInfo ciptr) +static int NAMEDResetListener (XtransConnInfo ciptr) { struct sockaddr_un *sockname=(struct sockaddr_un *) ciptr->addr; @@ -326,8 +315,8 @@ TRANS(NAMEDResetListener) (XtransConnInfo ciptr) if (stat (sockname->sun_path, &statb) == -1 || (statb.st_mode & S_IFMT) != S_IFIFO) { prmsg(3, "Pipe %s trashed, recreating\n", sockname->sun_path); - TRANS(LocalClose)(ciptr); - ciptr->fd = TRANS(NAMEDOpenPipe)(sockname->sun_path); + _XSERVTransLocalClose(ciptr); + ciptr->fd = _XSERVTransNAMEDOpenPipe(sockname->sun_path); if (ciptr->fd >= 0) return TRANS_RESET_NEW_FD; else @@ -337,9 +326,8 @@ TRANS(NAMEDResetListener) (XtransConnInfo ciptr) return TRANS_RESET_NOOP; } -static int -TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) - +static int _XSERVTransNAMEDAccept( + XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) { struct strrecvfd str; @@ -387,9 +375,8 @@ TRANS(NAMEDAccept)(XtransConnInfo ciptr, XtransConnInfo newciptr, int *status) #ifdef LOCAL_TRANS_NAMED -static int -TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *port) - +static int _XSERVTransNAMEDReopenServer( + XtransConnInfo ciptr, int fd _X_UNUSED, const char *port) { char server_path[64]; @@ -407,7 +394,7 @@ TRANS(NAMEDReopenServer)(XtransConnInfo ciptr, int fd _X_UNUSED, const char *por NAMEDNODENAME, (long)getpid()); } - if (TRANS(FillAddrInfo) (ciptr, server_path, server_path) == 0) + if (_XSERVTransFillAddrInfo) (ciptr, server_path, server_path) == 0) { prmsg(1,"NAMEDReopenServer: failed to fill in addr info\n"); return 0; @@ -455,41 +442,42 @@ typedef struct _LOCALtrans2dev { } LOCALtrans2dev; static LOCALtrans2dev LOCALtrans2devtab[] = { -{"", - TRANS(NAMEDOpenServer), - TRANS(OpenFail), - TRANS(NAMEDReopenServer), - TRANS(ReopenFail), - TRANS(NAMEDResetListener), - TRANS(NAMEDAccept) +{ + "", + _XSERVTransNAMEDOpenServer, + _XSERVTransOpenFail, + _XSERVTransNAMEDReopenServer, + _XSERVTransReopenFail, + _XSERVTransNAMEDResetListener, + _XSERVTransNAMEDAccept }, - -{"local", - TRANS(NAMEDOpenServer), - TRANS(OpenFail), - TRANS(NAMEDReopenServer), - TRANS(ReopenFail), - TRANS(NAMEDResetListener), - TRANS(NAMEDAccept) +{ + "local", + _XSERVTransNAMEDOpenServer, + _XSERVTransOpenFail, + _XSERVTransNAMEDReopenServer, + _XSERVTransReopenFail, + _XSERVTrans_NAMEDResetListener, + _XSERVTransNAMEDAccept }, - #ifdef LOCAL_TRANS_NAMED -{"named", - TRANS(NAMEDOpenServer), - TRANS(OpenFail), - TRANS(NAMEDReopenServer), - TRANS(ReopenFail), - TRANS(NAMEDResetListener), - TRANS(NAMEDAccept) +{ + "named", + _XSERVTransNAMEDOpenServer, + _XSERVTransOpenFail, + _XSERVTransNAMEDReopenServer, + _XSERVTransReopenFail, + _XSERVTransNAMEDResetListener, + _XSERVTransNAMEDAccept }, - -{"pipe", - TRANS(NAMEDOpenServer), - TRANS(OpenFail), - TRANS(NAMEDReopenServer), - TRANS(ReopenFail), - TRANS(NAMEDResetListener), - TRANS(NAMEDAccept) +{ + "pipe", + _XSERVTransNAMEDOpenServer, + _XSERVTransOpenFail, + _XSERVTransNAMEDReopenServer, + _XSERVTransReopenFail, + _XSERVTransNAMEDResetListener, + _XSERVTransNAMEDAccept }, #endif /* LOCAL_TRANS_NAMED */ @@ -504,9 +492,7 @@ static char *freeXLOCAL=NULL; #define DEF_XLOCAL "UNIX:NAMED" -static void -TRANS(LocalInitTransports)(const char *protocol) - +static void _XSERVTransLocalInitTransports(const char *protocol) { prmsg(3,"LocalInitTransports(%s)\n", protocol); @@ -522,9 +508,7 @@ TRANS(LocalInitTransports)(const char *protocol) } } -static void -TRANS(LocalEndTransports)(void) - +static void _XSERVTransLocalEndTransports(void) { prmsg(3,"LocalEndTransports()\n"); free(freeXLOCAL); @@ -533,10 +517,9 @@ TRANS(LocalEndTransports)(void) #define TYPEBUFSIZE 32 -static XtransConnInfo -TRANS(LocalOpenServer)(int type, const char *protocol, - const char *host _X_UNUSED, const char *port) - +static XtransConnInfo _XSERVTransLocalOpenServer( + int type, const char *protocol, + const char *host _X_UNUSED, const char *port) { XtransConnInfo ciptr; @@ -585,9 +568,8 @@ TRANS(LocalOpenServer)(int type, const char *protocol, return NULL; } -static XtransConnInfo -TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) - +static XtransConnInfo _XSERVTransLocalReopenServer(int type, int index, + int fd, const char *port) { XtransConnInfo ciptr; int stat = 0; @@ -628,10 +610,9 @@ TRANS(LocalReopenServer)(int type, int index, int fd, const char *port) * This is the Local implementation of the X Transport service layer */ -static XtransConnInfo -TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, - const char *host, const char *port) - +static XtransConnInfo _XSERVTransLocalOpenCOTSServer( + Xtransport *thistrans, const char *protocol, + const char *host, const char *port) { char *typetocheck = NULL; int found = 0; @@ -639,7 +620,7 @@ TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, prmsg(2,"LocalOpenCOTSServer(%s,%s,%s)\n",protocol,host,port); /* Check if this local type is in the XLOCAL list */ - TRANS(LocalInitTransports)("local"); + _XSERVTransLocalInitTransports("local"); typetocheck = workingXLOCAL; while (typetocheck && !found) { #ifndef HAVE_STRCASECMP @@ -662,7 +643,7 @@ TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, found = 1; typetocheck = workingXLOCAL; } - TRANS(LocalEndTransports)(); + _XSERVTransLocalEndTransports(); if (!found) { prmsg(3,"LocalOpenCOTSServer: disabling %s\n",thistrans->TransName); @@ -670,12 +651,11 @@ TRANS(LocalOpenCOTSServer)(Xtransport *thistrans, const char *protocol, return NULL; } - return TRANS(LocalOpenServer)(XTRANS_OPEN_COTS_SERVER, protocol, host, port); + return _XSERVTransLocalOpenServer(XTRANS_OPEN_COTS_SERVER, protocol, host, port); } -static XtransConnInfo -TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port) - +static XtransConnInfo _XSERVTransLocalReopenCOTSServer( + Xtransport *thistrans, int fd, const char *port) { unsigned int index; @@ -693,32 +673,26 @@ TRANS(LocalReopenCOTSServer)(Xtransport *thistrans, int fd, const char *port) return (NULL); } - return TRANS(LocalReopenServer)(XTRANS_OPEN_COTS_SERVER, + return _XSERVTransLocalReopenServer(XTRANS_OPEN_COTS_SERVER, index, fd, port); } -static int -TRANS(LocalSetOption)(XtransConnInfo ciptr, int option, int arg) - +static int _XSERVTransLocalSetOption(XtransConnInfo ciptr, int option, int arg) { prmsg(2,"LocalSetOption(%d,%d,%d)\n",ciptr->fd,option,arg); return -1; } -static int -TRANS(LocalCreateListener)(XtransConnInfo ciptr, const char *port, - unsigned int flags _X_UNUSED) - +static int _XSERVTransLocalCreateListener( + XtransConnInfo ciptr, const char *port, unsigned int flags _X_UNUSED) { prmsg(2,"LocalCreateListener(%p->%d,%s)\n", (void *) ciptr, ciptr->fd, port); return 0; } -static int -TRANS(LocalResetListener)(XtransConnInfo ciptr) - +static int _XSERVTransLocalResetListener(XtransConnInfo ciptr) { LOCALtrans2dev *transptr; @@ -732,9 +706,7 @@ TRANS(LocalResetListener)(XtransConnInfo ciptr) } -static XtransConnInfo -TRANS(LocalAccept)(XtransConnInfo ciptr, int *status) - +static XtransConnInfo _XSERVTransLocalAccept(XtransConnInfo ciptr, int *status) { XtransConnInfo newciptr; LOCALtrans2dev *transptr; @@ -767,9 +739,7 @@ TRANS(LocalAccept)(XtransConnInfo ciptr, int *status) return newciptr; } -static int -TRANS(LocalBytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend ) - +static int _XSERVTransLocalBytesReadable(XtransConnInfo ciptr, BytesReadable_t *pend ) { prmsg(2,"LocalBytesReadable(%p->%d,%p)\n", (void *) ciptr, ciptr->fd, (void *) pend); @@ -777,54 +747,42 @@ TRANS(LocalBytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend ) return ioctl(ciptr->fd, FIONREAD, (char *)pend); } -static int -TRANS(LocalRead)(XtransConnInfo ciptr, char *buf, int size) - +static int _XSERVTransLocalRead(XtransConnInfo ciptr, char *buf, int size) { prmsg(2,"LocalRead(%d,%p,%d)\n", ciptr->fd, (void *) buf, size ); return read(ciptr->fd,buf,size); } -static int -TRANS(LocalWrite)(XtransConnInfo ciptr, const char *buf, int size) - +static int _XSERVTransLocalWrite(XtransConnInfo ciptr, const char *buf, int size) { prmsg(2,"LocalWrite(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size ); return write(ciptr->fd,buf,size); } -static int -TRANS(LocalReadv)(XtransConnInfo ciptr, struct iovec *buf, int size) - +static int _XSERVTransLocalReadv(XtransConnInfo ciptr, struct iovec *buf, int size) { prmsg(2,"LocalReadv(%d,%p,%d)\n", ciptr->fd, (void *) buf, size ); return READV(ciptr,buf,size); } -static int -TRANS(LocalWritev)(XtransConnInfo ciptr, struct iovec *buf, int size) - +static int _XSERVTransLocalWritev(XtransConnInfo ciptr, struct iovec *buf, int size) { prmsg(2,"LocalWritev(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size ); return WRITEV(ciptr,buf,size); } -static int -TRANS(LocalDisconnect)(XtransConnInfo ciptr) - +static int _XSERVTransLocalDisconnect(XtransConnInfo ciptr) { prmsg(2,"LocalDisconnect(%p->%d)\n", (void *) ciptr, ciptr->fd); return 0; } -static int -TRANS(LocalClose)(XtransConnInfo ciptr) - +static int _XSERVTransLocalClose(XtransConnInfo ciptr) { struct sockaddr_un *sockname=(struct sockaddr_un *) ciptr->addr; int ret; @@ -845,9 +803,7 @@ TRANS(LocalClose)(XtransConnInfo ciptr) return ret; } -static int -TRANS(LocalCloseForCloning)(XtransConnInfo ciptr) - +static int _XSERVTransLocalCloseForCloning(XtransConnInfo ciptr) { int ret; @@ -875,81 +831,81 @@ static const char * local_aliases[] = { "pipe", /* compatibility with Solaris Xlib */ NULL }; -static Xtransport TRANS(LocalFuncs) = { +static Xtransport _XSERVTransLocalFuncs = { /* Local Interface */ "local", TRANS_ALIAS | TRANS_LOCAL, local_aliases, - TRANS(LocalOpenCOTSServer), - TRANS(LocalReopenCOTSServer), - TRANS(LocalSetOption), - TRANS(LocalCreateListener), - TRANS(LocalResetListener), - TRANS(LocalAccept), - TRANS(LocalBytesReadable), - TRANS(LocalRead), - TRANS(LocalWrite), - TRANS(LocalReadv), - TRANS(LocalWritev), + _XSERVTransLocalOpenCOTSServer, + _XSERVTransLocalReopenCOTSServer, + _XSERVTransLocalSetOption, + _XSERVTransLocalCreateListener, + _XSERVTransLocalResetListener, + _XSERVTransLocalAccept, + _XSERVTransLocalBytesReadable, + _XSERVTransLocalRead, + _XSERVTransLocalWrite, + _XSERVTransLocalReadv, + _XSERVTransLocalWritev, #if XTRANS_SEND_FDS - TRANS(LocalSendFdInvalid), - TRANS(LocalRecvFdInvalid), + _XSERVTransLocalSendFdInvalid, + _XSERVTransLocalRecvFdInvalid, #endif - TRANS(LocalDisconnect), - TRANS(LocalClose), - TRANS(LocalCloseForCloning), + _XSERVTransLocalDisconnect, + _XSERVTransLocalClose, + _XSERVTransLocalCloseForCloning, }; #ifdef LOCAL_TRANS_NAMED -static Xtransport TRANS(NAMEDFuncs) = { +static Xtransport _XSERVTransNAMEDFuncs = { /* Local Interface */ "named", TRANS_LOCAL, NULL, - TRANS(LocalOpenCOTSServer), - TRANS(LocalReopenCOTSServer), - TRANS(LocalSetOption), - TRANS(LocalCreateListener), - TRANS(LocalResetListener), - TRANS(LocalAccept), - TRANS(LocalBytesReadable), - TRANS(LocalRead), - TRANS(LocalWrite), - TRANS(LocalReadv), - TRANS(LocalWritev), + _XSERVTransLocalOpenCOTSServer, + _XSERVTransLocalReopenCOTSServer, + _XSERVTransLocalSetOption, + _XSERVTransLocalCreateListener, + _XSERVTransLocalResetListener, + _XSERVTransLocalAccept, + _XSERVTransLocalBytesReadable, + _XSERVTransLocalRead, + _XSERVTransLocalWrite, + _XSERVTransLocalReadv, + _XSERVTransLocalWritev, #if XTRANS_SEND_FDS - TRANS(LocalSendFdInvalid), - TRANS(LocalRecvFdInvalid), + _XSERVTransLocalSendFdInvalid, + _XSERVTransLocalRecvFdInvalid, #endif - TRANS(LocalDisconnect), - TRANS(LocalClose), - TRANS(LocalCloseForCloning), + _XSERVTransLocalDisconnect, + _XSERVTransLocalClose, + _XSERVTransLocalCloseForCloning, }; -static Xtransport TRANS(PIPEFuncs) = { +static Xtransport _XSERVTransPIPEFuncs = { /* Local Interface */ "pipe", TRANS_ALIAS | TRANS_LOCAL, NULL, - TRANS(LocalOpenCOTSServer), - TRANS(LocalReopenCOTSServer), - TRANS(LocalSetOption), - TRANS(LocalCreateListener), - TRANS(LocalResetListener), - TRANS(LocalAccept), - TRANS(LocalBytesReadable), - TRANS(LocalRead), - TRANS(LocalWrite), - TRANS(LocalReadv), - TRANS(LocalWritev), + _XSERVTransLocalOpenCOTSServer, + _XSERVTransLocalReopenCOTSServer, + _XSERVTransLocalSetOption, + _XSERVTransLocalCreateListener, + _XSERVTransLocalResetListener, + _XSERVTransLocalAccept, + _XSERVTransLocalBytesReadable, + _XSERVTransLocalRead, + _XSERVTransLocalWrite, + _XSERVTransLocalReadv, + _XSERVTransLocalWritev, #if XTRANS_SEND_FDS - TRANS(LocalSendFdInvalid), - TRANS(LocalRecvFdInvalid), + _XSERVTransLocalSendFdInvalid, + _XSERVTransLocalRecvFdInvalid, #endif - TRANS(LocalDisconnect), - TRANS(LocalClose), - TRANS(LocalCloseForCloning), + _XSERVTransLocalDisconnect, + _XSERVTransLocalClose, + _XSERVTransLocalCloseForCloning, }; #endif /* LOCAL_TRANS_NAMED */ diff --git a/os/Xtranssock.c b/os/Xtranssock.c index 1b1581656..88b09ddf1 100644 --- a/os/Xtranssock.c +++ b/os/Xtranssock.c @@ -208,7 +208,7 @@ static Sockettrans2dev Sockettrans2devtab[] = { #define NUMSOCKETFAMILIES (sizeof(Sockettrans2devtab)/sizeof(Sockettrans2dev)) #ifdef TCPCONN -static int TRANS(SocketINETClose) (XtransConnInfo ciptr); +static int _XSERVTransSocketINETClose (XtransConnInfo ciptr); #endif static int @@ -249,9 +249,7 @@ is_numeric (const char *str) * These are some utility function used by the real interface function below. */ -static int -TRANS(SocketSelectFamily) (int first, const char *family) - +static int _XSERVTransSocketSelectFamily (int first, const char *family) { int i; @@ -272,9 +270,7 @@ TRANS(SocketSelectFamily) (int first, const char *family) * XtransConnInfo structure for the connection. */ -static int -TRANS(SocketINETGetAddr) (XtransConnInfo ciptr) - +static int _XSERVTransSocketINETGetAddr (XtransConnInfo ciptr) { #ifdef HAVE_STRUCT_SOCKADDR_STORAGE struct sockaddr_storage sockname; @@ -323,9 +319,7 @@ TRANS(SocketINETGetAddr) (XtransConnInfo ciptr) * XtransConnInfo structure for the connection. */ -static int -TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr) - +static int _XSERVTransSocketINETGetPeerAddr (XtransConnInfo ciptr) { #ifdef HAVE_STRUCT_SOCKADDR_STORAGE struct sockaddr_storage sockname; @@ -368,9 +362,7 @@ TRANS(SocketINETGetPeerAddr) (XtransConnInfo ciptr) } -static XtransConnInfo -TRANS(SocketOpen) (int i, int type) - +static XtransConnInfo _XSERVTransSocketOpen (int i, int type) { XtransConnInfo ciptr; @@ -449,9 +441,8 @@ TRANS(SocketOpen) (int i, int type) return ciptr; } -static XtransConnInfo -TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) - +static XtransConnInfo _XSERVTransSocketReopen ( + int i _X_UNUSED, int type, int fd, const char *port) { XtransConnInfo ciptr; int portlen; @@ -533,10 +524,8 @@ TRANS(SocketReopen) (int i _X_UNUSED, int type, int fd, const char *port) * These functions are the interface supplied in the Xtransport structure */ -static XtransConnInfo -TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, - const char *host, const char *port) - +static XtransConnInfo _XSERVTransSocketOpenCOTSServer ( + Xtransport *thistrans, const char *protocol, const char *host, const char *port) { XtransConnInfo ciptr = NULL; int i = -1; @@ -545,8 +534,8 @@ TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, SocketInitOnce(); - while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) { - if ((ciptr = TRANS(SocketOpen) ( + while ((i = _XSERVTransSocketSelectFamily (i, thistrans->TransName)) >= 0) { + if ((ciptr = _XSERVTransSocketOpen ( i, Sockettrans2devtab[i].devcotsname)) != NULL) break; } @@ -602,9 +591,8 @@ TRANS(SocketOpenCOTSServer) (Xtransport *thistrans, const char *protocol, return ciptr; } -static XtransConnInfo -TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) - +static XtransConnInfo _XSERVTransSocketReopenCOTSServer ( + Xtransport *thistrans, int fd, const char *port) { XtransConnInfo ciptr; int i = -1; @@ -614,8 +602,8 @@ TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) SocketInitOnce(); - while ((i = TRANS(SocketSelectFamily) (i, thistrans->TransName)) >= 0) { - if ((ciptr = TRANS(SocketReopen) ( + while ((i = _XSERVTransSocketSelectFamily (i, thistrans->TransName)) >= 0) { + if ((ciptr = _XSERVTransSocketReopen ( i, Sockettrans2devtab[i].devcotsname, fd, port)) != NULL) break; } @@ -636,12 +624,9 @@ TRANS(SocketReopenCOTSServer) (Xtransport *thistrans, int fd, const char *port) return ciptr; } -static int -TRANS(SocketSetOption) (XtransConnInfo ciptr, int option, int arg) - +static int _XSERVTransSocketSetOption (XtransConnInfo ciptr, int option, int arg) { prmsg (2,"SocketSetOption(%d,%d,%d)\n", ciptr->fd, option, arg); - return -1; } @@ -673,11 +658,9 @@ set_sun_path(const char *port, const char *upath, char *path, int abstract) } #endif -static int -TRANS(SocketCreateListener) (XtransConnInfo ciptr, +static int _XSERVTransSocketCreateListener (XtransConnInfo ciptr, struct sockaddr *sockname, int socknamelen, unsigned int flags) - { SOCKLEN_T namelen = socknamelen; int fd = ciptr->fd; @@ -748,10 +731,8 @@ TRANS(SocketCreateListener) (XtransConnInfo ciptr, } #ifdef TCPCONN -static int -TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, - unsigned int flags) - +static int _XSERVTransSocketINETCreateListener ( + XtransConnInfo ciptr, const char *port, unsigned int flags) { #ifdef HAVE_STRUCT_SOCKADDR_STORAGE struct sockaddr_storage sockname; @@ -848,7 +829,7 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, #endif } - if ((status = TRANS(SocketCreateListener) (ciptr, + if ((status = _XSERVTransSocketCreateListener (ciptr, (struct sockaddr *) &sockname, namelen, flags)) < 0) { prmsg (1, @@ -856,7 +837,7 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, return status; } - if (TRANS(SocketINETGetAddr) (ciptr) < 0) + if (_XSERVTransSocketINETGetAddr (ciptr) < 0) { prmsg (1, "SocketINETCreateListener: ...SocketINETGetAddr() failed\n"); @@ -871,10 +852,8 @@ TRANS(SocketINETCreateListener) (XtransConnInfo ciptr, const char *port, #ifdef UNIXCONN -static int -TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port, - unsigned int flags) - +static int _XSERVTransSocketUNIXCreateListener ( + XtransConnInfo ciptr, const char *port, unsigned int flags) { struct sockaddr_un sockname; int namelen; @@ -938,7 +917,7 @@ TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port, else unlink (sockname.sun_path); - if ((status = TRANS(SocketCreateListener) (ciptr, + if ((status = _XSERVTransSocketCreateListener (ciptr, (struct sockaddr *) &sockname, namelen, flags)) < 0) { prmsg (1, @@ -951,7 +930,7 @@ TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port, * Now that the listener is esablished, create the addr info for * this connection. getpeername() doesn't work for UNIX Domain Sockets * on some systems (hpux at least), so we will just do it manually, instead - * of calling something like TRANS(SocketUNIXGetAddr). + * of calling something like _XSERVTransSocketUNIXGetAddr. */ namelen = sizeof (sockname); /* this will always make it the same size */ @@ -977,9 +956,7 @@ TRANS(SocketUNIXCreateListener) (XtransConnInfo ciptr, const char *port, } -static int -TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr) - +static int _XSERVTransSocketUNIXResetListener (XtransConnInfo ciptr) { /* * See if the unix domain socket has disappeared. If it has, recreate it. @@ -1027,7 +1004,7 @@ TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr) if ((ciptr->fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0) { - TRANS(FreeConnInfo) (ciptr); + _XSERVTransFreeConnInfo (ciptr); (void) umask (oldUmask); return TRANS_RESET_FAILURE; } @@ -1035,14 +1012,14 @@ TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr) if (bind (ciptr->fd, (struct sockaddr *) unsock, ciptr->addrlen) < 0) { close (ciptr->fd); - TRANS(FreeConnInfo) (ciptr); + _XSERVTransFreeConnInfo (ciptr); return TRANS_RESET_FAILURE; } if (listen (ciptr->fd, BACKLOG) < 0) { close (ciptr->fd); - TRANS(FreeConnInfo) (ciptr); + _XSERVTransFreeConnInfo (ciptr); (void) umask (oldUmask); return TRANS_RESET_FAILURE; } @@ -1060,9 +1037,8 @@ TRANS(SocketUNIXResetListener) (XtransConnInfo ciptr) #ifdef TCPCONN -static XtransConnInfo -TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status) - +static XtransConnInfo _XSERVTransSocketINETAccept ( + XtransConnInfo ciptr, int *status) { XtransConnInfo newciptr; struct sockaddr_in sockname; @@ -1106,7 +1082,7 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status) * specific address now that a connection is established. */ - if (TRANS(SocketINETGetAddr) (newciptr) < 0) + if (_XSERVTransSocketINETGetAddr (newciptr) < 0) { prmsg (1, "SocketINETAccept: ...SocketINETGetAddr() failed:\n"); @@ -1116,7 +1092,7 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status) return NULL; } - if (TRANS(SocketINETGetPeerAddr) (newciptr) < 0) + if (_XSERVTransSocketINETGetPeerAddr (newciptr) < 0) { prmsg (1, "SocketINETAccept: ...SocketINETGetPeerAddr() failed:\n"); @@ -1136,9 +1112,8 @@ TRANS(SocketINETAccept) (XtransConnInfo ciptr, int *status) #ifdef UNIXCONN -static XtransConnInfo -TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) - +static XtransConnInfo _XSERVTransSocketUNIXAccept ( + XtransConnInfo ciptr, int *status) { XtransConnInfo newciptr; struct sockaddr_un sockname; @@ -1209,9 +1184,8 @@ TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) #endif /* UNIXCONN */ -static int -TRANS(SocketBytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend) - +static int _XSERVTransSocketBytesReadable ( + XtransConnInfo ciptr, BytesReadable_t *pend) { prmsg (2,"SocketBytesReadable(%p,%d,%p)\n", (void *) ciptr, ciptr->fd, (void *) pend); @@ -1296,29 +1270,27 @@ nFd(struct _XtransConnFd **prev) return n; } -static int -TRANS(SocketRecvFd) (XtransConnInfo ciptr) +static int _XSERVTransSocketRecvFd (XtransConnInfo ciptr) { prmsg (2, "SocketRecvFd(%d)\n", ciptr->fd); return removeFd(&ciptr->recv_fds); } -static int -TRANS(SocketSendFd) (XtransConnInfo ciptr, int fd, int do_close) +static int _XSERVTransSocketSendFd ( + XtransConnInfo ciptr, int fd, int do_close) { appendFd(&ciptr->send_fds, fd, do_close); return 0; } -static int -TRANS(SocketRecvFdInvalid)(XtransConnInfo ciptr) +static int _XSERVTransSocketRecvFdInvalid(XtransConnInfo ciptr) { errno = EINVAL; return -1; } -static int -TRANS(SocketSendFdInvalid)(XtransConnInfo ciptr, int fd, int do_close) +static int _XSERVTransSocketSendFdInvalid( + XtransConnInfo ciptr, int fd, int do_close) { errno = EINVAL; return -1; @@ -1333,9 +1305,8 @@ union fd_pass { #endif /* XTRANS_SEND_FDS */ -static int -TRANS(SocketRead) (XtransConnInfo ciptr, char *buf, int size) - +static int _XSERVTransSocketRead ( + XtransConnInfo ciptr, char *buf, int size) { prmsg (2,"SocketRead(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); @@ -1387,9 +1358,8 @@ TRANS(SocketRead) (XtransConnInfo ciptr, char *buf, int size) #endif /* WIN32 */ } -static int -TRANS(SocketReadv) (XtransConnInfo ciptr, struct iovec *buf, int size) - +static int _XSERVTransSocketReadv ( + XtransConnInfo ciptr, struct iovec *buf, int size) { prmsg (2,"SocketReadv(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); @@ -1427,10 +1397,8 @@ TRANS(SocketReadv) (XtransConnInfo ciptr, struct iovec *buf, int size) #endif } - -static int -TRANS(SocketWritev) (XtransConnInfo ciptr, struct iovec *buf, int size) - +static int _XSERVTransSocketWritev ( + XtransConnInfo ciptr, struct iovec *buf, int size) { prmsg (2,"SocketWritev(%d,%p,%d)\n", ciptr->fd, (void *) buf, size); @@ -1472,10 +1440,8 @@ TRANS(SocketWritev) (XtransConnInfo ciptr, struct iovec *buf, int size) return WRITEV (ciptr, buf, size); } - -static int -TRANS(SocketWrite) (XtransConnInfo ciptr, const char *buf, int size) - +static int _XSERVTransSocketWrite ( + XtransConnInfo ciptr, const char *buf, int size) { prmsg (2,"SocketWrite(%d,%p,%d)\n", ciptr->fd, (const void *) buf, size); @@ -1495,16 +1461,14 @@ TRANS(SocketWrite) (XtransConnInfo ciptr, const char *buf, int size) iov.iov_base = (void *) buf; iov.iov_len = size; - return TRANS(SocketWritev)(ciptr, &iov, 1); + return _XSERVTransSocketWritev(ciptr, &iov, 1); } #endif /* XTRANS_SEND_FDS */ return write (ciptr->fd, buf, size); #endif /* WIN32 */ } -static int -TRANS(SocketDisconnect) (XtransConnInfo ciptr) - +static int _XSERVTransSocketDisconnect (XtransConnInfo ciptr) { prmsg (2,"SocketDisconnect(%p,%d)\n", (void *) ciptr, ciptr->fd); @@ -1519,11 +1483,8 @@ TRANS(SocketDisconnect) (XtransConnInfo ciptr) #endif } - #ifdef TCPCONN -static int -TRANS(SocketINETClose) (XtransConnInfo ciptr) - +static int _XSERVTransSocketINETClose (XtransConnInfo ciptr) { prmsg (2,"SocketINETClose(%p,%d)\n", (void *) ciptr, ciptr->fd); @@ -1540,10 +1501,8 @@ TRANS(SocketINETClose) (XtransConnInfo ciptr) #endif /* TCPCONN */ - #ifdef UNIXCONN -static int -TRANS(SocketUNIXClose) (XtransConnInfo ciptr) +static int _XSERVTransSocketUNIXClose (XtransConnInfo ciptr) { /* * If this is the server side, then once the socket is closed, @@ -1573,9 +1532,7 @@ TRANS(SocketUNIXClose) (XtransConnInfo ciptr) return ret; } -static int -TRANS(SocketUNIXCloseForCloning) (XtransConnInfo ciptr) - +static int _XSERVTransSocketUNIXCloseForCloning (XtransConnInfo ciptr) { /* * Don't unlink path. @@ -1606,87 +1563,87 @@ static const char* tcp_nolisten[] = { NULL }; -static Xtransport TRANS(SocketTCPFuncs) = { +static Xtransport _XSERVTransSocketTCPFuncs = { /* Socket Interface */ "tcp", TRANS_ALIAS, tcp_nolisten, - TRANS(SocketOpenCOTSServer), - TRANS(SocketReopenCOTSServer), - TRANS(SocketSetOption), - TRANS(SocketINETCreateListener), + _XSERVTransSocketOpenCOTSServer, + _XSERVTransSocketReopenCOTSServer, + _XSERVTransSocketSetOption, + _XSERVTransSocketINETCreateListener, NULL, /* ResetListener */ - TRANS(SocketINETAccept), - TRANS(SocketBytesReadable), - TRANS(SocketRead), - TRANS(SocketWrite), - TRANS(SocketReadv), - TRANS(SocketWritev), + _XSERVTransSocketINETAccept, + _XSERVTransSocketBytesReadable, + _XSERVTransSocketRead, + _XSERVTransSocketWrite, + _XSERVTransSocketReadv, + _XSERVTransSocketWritev, #if XTRANS_SEND_FDS - TRANS(SocketSendFdInvalid), - TRANS(SocketRecvFdInvalid), + _XSERVTransSocketSendFdInvalid, + _XSERVTransSocketRecvFdInvalid, #endif - TRANS(SocketDisconnect), - TRANS(SocketINETClose), - TRANS(SocketINETClose), - }; + _XSERVTransSocketDisconnect, + _XSERVTransSocketINETClose, + _XSERVTransSocketINETClose, +}; -static Xtransport TRANS(SocketINETFuncs) = { +static Xtransport _XSERVTransSocketINETFuncs = { /* Socket Interface */ "inet", 0, NULL, - TRANS(SocketOpenCOTSServer), - TRANS(SocketReopenCOTSServer), - TRANS(SocketSetOption), - TRANS(SocketINETCreateListener), + _XSERVTransSocketOpenCOTSServer, + _XSERVTransSocketReopenCOTSServer, + _XSERVTransSocketSetOption, + _XSERVTransSocketINETCreateListener, NULL, /* ResetListener */ - TRANS(SocketINETAccept), - TRANS(SocketBytesReadable), - TRANS(SocketRead), - TRANS(SocketWrite), - TRANS(SocketReadv), - TRANS(SocketWritev), + _XSERVTransSocketINETAccept, + _XSERVTransSocketBytesReadable, + _XSERVTransSocketRead, + _XSERVTransSocketWrite, + _XSERVTransSocketReadv, + _XSERVTransSocketWritev, #if XTRANS_SEND_FDS - TRANS(SocketSendFdInvalid), - TRANS(SocketRecvFdInvalid), + _XSERVTransSocketSendFdInvalid, + _XSERVTransSocketRecvFdInvalid, #endif - TRANS(SocketDisconnect), - TRANS(SocketINETClose), - TRANS(SocketINETClose), - }; + _XSERVTransSocketDisconnect, + _XSERVTransSocketINETClose, + _XSERVTransSocketINETClose, +}; #ifdef IPv6 -static Xtransport TRANS(SocketINET6Funcs) = { +static Xtransport _XSERVTransSocketINET6Funcs = { /* Socket Interface */ "inet6", 0, NULL, - TRANS(SocketOpenCOTSServer), - TRANS(SocketReopenCOTSServer), - TRANS(SocketSetOption), - TRANS(SocketINETCreateListener), + _XSERVTransSocketOpenCOTSServer, + _XSERVTransSocketReopenCOTSServer, + _XSERVTransSocketSetOption, + _XSERVTransSocketINETCreateListener, NULL, /* ResetListener */ - TRANS(SocketINETAccept), - TRANS(SocketBytesReadable), - TRANS(SocketRead), - TRANS(SocketWrite), - TRANS(SocketReadv), - TRANS(SocketWritev), + _XSERVTransSocketINETAccept, + _XSERVTransSocketBytesReadable, + _XSERVTransSocketRead, + _XSERVTransSocketWrite, + _XSERVTransSocketReadv, + _XSERVTransSocketWritev, #if XTRANS_SEND_FDS - TRANS(SocketSendFdInvalid), - TRANS(SocketRecvFdInvalid), + _XSERVTransSocketSendFdInvalid, + _XSERVTransSocketRecvFdInvalid, #endif - TRANS(SocketDisconnect), - TRANS(SocketINETClose), - TRANS(SocketINETClose), - }; + _XSERVTransSocketDisconnect, + _XSERVTransSocketINETClose, + _XSERVTransSocketINETClose, +}; #endif /* IPv6 */ #endif /* TCPCONN */ #ifdef UNIXCONN #if !defined(LOCALCONN) -static Xtransport TRANS(SocketLocalFuncs) = { +static Xtransport _XSERVTransSocketLocalFuncs = { /* Socket Interface */ "local", #ifdef HAVE_ABSTRACT_SOCKETS @@ -1695,31 +1652,31 @@ static Xtransport TRANS(SocketLocalFuncs) = { 0, #endif NULL, - TRANS(SocketOpenCOTSServer), - TRANS(SocketReopenCOTSServer), - TRANS(SocketSetOption), - TRANS(SocketUNIXCreateListener), - TRANS(SocketUNIXResetListener), - TRANS(SocketUNIXAccept), - TRANS(SocketBytesReadable), - TRANS(SocketRead), - TRANS(SocketWrite), - TRANS(SocketReadv), - TRANS(SocketWritev), + _XSERVTransSocketOpenCOTSServer, + _XSERVTransSocketReopenCOTSServer, + _XSERVTransSocketSetOption, + _XSERVTransSocketUNIXCreateListener, + _XSERVTransSocketUNIXResetListener, + _XSERVTransSocketUNIXAccept, + _XSERVTransSocketBytesReadable, + _XSERVTransSocketRead, + _XSERVTransSocketWrite, + _XSERVTransSocketReadv, + _XSERVTransSocketWritev, #if XTRANS_SEND_FDS - TRANS(SocketSendFd), - TRANS(SocketRecvFd), + _XSERVTransSocketSendFd, + _XSERVTransSocketRecvFd, #endif - TRANS(SocketDisconnect), - TRANS(SocketUNIXClose), - TRANS(SocketUNIXCloseForCloning), - }; + _XSERVTransSocketDisconnect, + _XSERVTransSocketUNIXClose, + _XSERVTransSocketUNIXCloseForCloning, +}; #endif /* !LOCALCONN */ # if !defined(LOCALCONN) static const char* unix_nolisten[] = { "local" , NULL }; # endif -static Xtransport TRANS(SocketUNIXFuncs) = { +static Xtransport _XSERVTransSocketUNIXFuncs = { /* Socket Interface */ "unix", #if !defined(LOCALCONN) && !defined(HAVE_ABSTRACT_SOCKETS) @@ -1732,24 +1689,24 @@ static Xtransport TRANS(SocketUNIXFuncs) = { #else NULL, #endif - TRANS(SocketOpenCOTSServer), - TRANS(SocketReopenCOTSServer), - TRANS(SocketSetOption), - TRANS(SocketUNIXCreateListener), - TRANS(SocketUNIXResetListener), - TRANS(SocketUNIXAccept), - TRANS(SocketBytesReadable), - TRANS(SocketRead), - TRANS(SocketWrite), - TRANS(SocketReadv), - TRANS(SocketWritev), + _XSERVTransSocketOpenCOTSServer, + _XSERVTransSocketReopenCOTSServer, + _XSERVTransSocketSetOption, + _XSERVTransSocketUNIXCreateListener, + _XSERVTransSocketUNIXResetListener, + _XSERVTransSocketUNIXAccept, + _XSERVTransSocketBytesReadable, + _XSERVTransSocketRead, + _XSERVTransSocketWrite, + _XSERVTransSocketReadv, + _XSERVTransSocketWritev, #if XTRANS_SEND_FDS - TRANS(SocketSendFd), - TRANS(SocketRecvFd), + _XSERVTransSocketSendFd, + _XSERVTransSocketRecvFd, #endif - TRANS(SocketDisconnect), - TRANS(SocketUNIXClose), - TRANS(SocketUNIXCloseForCloning), - }; + _XSERVTransSocketDisconnect, + _XSERVTransSocketUNIXClose, + _XSERVTransSocketUNIXCloseForCloning, +}; #endif /* UNIXCONN */ diff --git a/os/Xtransutil.c b/os/Xtransutil.c index 43cc728c9..8d7849f60 100644 --- a/os/Xtransutil.c +++ b/os/Xtransutil.c @@ -89,16 +89,13 @@ from The Open Group. #define FamilyWild 65535 /* - * TRANS(ConvertAddress) converts a sockaddr based address to an + * _XSERVTransConvertAddress converts a sockaddr based address to an * X authorization based address. Some of this is defined as part of * the ChangeHost protocol. The rest is just done in a consistent manner. */ -int -TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) - +int _XSERVTransConvertAddress(int *familyp, int *addrlenp, Xtransaddr **addrp) { - prmsg(2,"ConvertAddress(%d,%d,%p)\n",*familyp,*addrlenp,*addrp); switch( *familyp ) @@ -193,7 +190,7 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) */ char hostnamebuf[256]; - int len = TRANS(GetHostname) (hostnamebuf, sizeof hostnamebuf); + int len = _XSERVTransGetHostname (hostnamebuf, sizeof hostnamebuf); if (len > 0) { if (*addrp && *addrlenp < (len + 1)) @@ -223,8 +220,7 @@ TRANS(ConvertAddress)(int *familyp, int *addrlenp, Xtransaddr **addrp) } #if defined(WIN32) && defined(TCPCONN) -int -TRANS(WSAStartup) (void) +int _XSERVTransWSAStartup (void) { static WSADATA wsadata; diff --git a/os/connection.c b/os/connection.c index 482a83e7b..20e37fa14 100644 --- a/os/connection.c +++ b/os/connection.c @@ -1058,7 +1058,7 @@ ListenOnOpenFD(int fd, int noxauth) ListenTransCount++; } -/* based on TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) */ +/* based on _XSERVTransSocketUNIXAccept (XtransConnInfo ciptr, int *status) */ Bool AddClientOnOpenFD(int fd) { From cc39bf774525b77275dd5c7fe82f5afb1c7c4447 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Mon, 30 Jun 2025 10:10:32 +0200 Subject: [PATCH 22/23] os: log: vpnprintf(): ignore reverse justification modifier The only caller is libinput, and we don't really need it, just silencing bug message. Signed-off-by: Enrico Weigelt, metux IT consult --- os/log.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/os/log.c b/os/log.c index 60837b10d..c0ff0ee93 100644 --- a/os/log.c +++ b/os/log.c @@ -410,6 +410,10 @@ vpnprintf(char *string, int size_in, const char *f, va_list args) f_idx++; + /* silently ignore reverse justification */ + if (f[f_idx] == '-') + f_idx++; + /* silently swallow minimum field width */ if (f[f_idx] == '*') { f_idx++; From 9ddc54918a247c8ce5b265a4b3ff53d0d350b2c8 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Mon, 30 Jun 2025 13:20:36 +0200 Subject: [PATCH 23/23] os: xtrans: fix calloc overflow warning MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The size of `int` is machine specific and may be 64 bits wide, which could overflow the calloc'able size. Practically cannot happen here, since the ListenTransCount can't go above MAX_CONNECTIONS, but compiler can't know that and so spitting out a warning. Using uint32_t really is sufficient here. > ../os/connection.c: In function ‘CreateWellKnownSockets’: > ../os/connection.c:274:22: warning: argument 1 range [18446744071562067968, 18446744073709551615] exceeds maximum object size 9223372036854775807 [-Walloc-size-larger-than=] > 274 | ListenTransFds = calloc(ListenTransCount, sizeof(int)); > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Signed-off-by: Enrico Weigelt, metux IT consult --- os/Xtrans.c | 4 ++-- os/Xtrans.h | 4 +++- os/connection.c | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/os/Xtrans.c b/os/Xtrans.c index 2063793df..0433d08a4 100644 --- a/os/Xtrans.c +++ b/os/Xtrans.c @@ -881,7 +881,7 @@ complete_network_count (void) static int receive_listening_fds(const char* port, XtransConnInfo* temp_ciptrs, - int* count_ret) + uint32_t* count_ret) { #ifdef HAVE_SYSTEMD_DAEMON @@ -958,7 +958,7 @@ extern int xquartz_launchd_fd; #endif int _XSERVTransMakeAllCOTSServerListeners (const char *port, int *partial, - int *count_ret, XtransConnInfo **ciptrs_ret) + uint32_t *count_ret, XtransConnInfo **ciptrs_ret) { char buffer[256]; /* ??? What size ?? */ XtransConnInfo ciptr, temp_ciptrs[NUMTRANS] = { NULL }; diff --git a/os/Xtrans.h b/os/Xtrans.h index fa40550e4..fb7ceaadd 100644 --- a/os/Xtrans.h +++ b/os/Xtrans.h @@ -50,6 +50,8 @@ from The Open Group. #ifndef _XTRANS_H_ #define _XTRANS_H_ +#include + #include #include #include @@ -289,7 +291,7 @@ int _XSERVTransGetConnectionNumber ( int _XSERVTransMakeAllCOTSServerListeners ( const char *, /* port */ int *, /* partial */ - int *, /* count_ret */ + uint32_t *, /* count_ret */ XtransConnInfo ** /* ciptrs_ret */ ); diff --git a/os/connection.c b/os/connection.c index 20e37fa14..dec7a340b 100644 --- a/os/connection.c +++ b/os/connection.c @@ -144,7 +144,7 @@ set_poll_clients(void); static XtransConnInfo *ListenTransConns = NULL; static int *ListenTransFds = NULL; -static int ListenTransCount; +static uint32_t ListenTransCount = 0; static void ErrorConnMax(XtransConnInfo /* trans_conn */ );