X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fxcb_util.c;h=06b5bcaf1b16d8f7b8502a187c931fd891fef193;hb=162c7593adf1577ca8aecfcd53fd5644b6182609;hp=b25a2d84b83a188f0f1ffb77b93b6cc4cfc3cdbd;hpb=47ceed78612d48dcda62cc2686fc527d61abe38b;p=free-sw%2Fxcb%2Flibxcb diff --git a/src/xcb_util.c b/src/xcb_util.c index b25a2d8..06b5bca 100644 --- a/src/xcb_util.c +++ b/src/xcb_util.c @@ -26,11 +26,13 @@ /* Utility functions implementable using only public APIs. */ #include -#include +#include #include -#include #include -#include +#ifdef DNETCONN +#include +#include +#endif #include #include #include @@ -40,6 +42,7 @@ #include "xcb.h" #include "xcbext.h" +#include "xcbint.h" int XCBPopcount(CARD32 mask) { @@ -90,15 +93,36 @@ int XCBParseDisplay(const char *name, char **host, int *displayp, int *screenp) return 1; } -int XCBOpen(const char *host, const int display) +static int _xcb_open_tcp(const char *host, const unsigned short port); +static int _xcb_open_unix(const char *file); +#ifdef DNETCONN +static int _xcb_open_decnet(const char *host, const unsigned short port); +#endif + +static int _xcb_open(const char *host, const int display) { int fd; if(*host) { - /* display specifies TCP */ - unsigned short port = X_TCP_PORT + display; - fd = XCBOpenTCP(host, port); +#ifdef DNETCONN + if (strchr(host, ':')) + { + /* DECnet displays have two colons, so the parser will have left + one at the end */ + char *dnethost = strdup(host); + + dnethost[strlen(dnethost)-1] = '\0'; + fd = _xcb_open_decnet(dnethost, display); + free(dnethost); + } + else +#endif + { + /* display specifies TCP */ + unsigned short port = X_TCP_PORT + display; + fd = _xcb_open_tcp(host, port); + } } else { @@ -106,13 +130,47 @@ int XCBOpen(const char *host, const int display) static const char base[] = "/tmp/.X11-unix/X"; char file[sizeof(base) + 20]; snprintf(file, sizeof(file), "%s%d", base, display); - fd = XCBOpenUnix(file); + fd = _xcb_open_unix(file); } return fd; } -int XCBOpenTCP(const char *host, const unsigned short port) +#ifdef DNETCONN +static int _xcb_open_decnet(const char *host, const unsigned short port) +{ + int fd; + struct sockaddr_dn addr; + struct accessdata_dn accessdata; + struct nodeent *nodeaddr = getnodebyname(host); + + if(!nodeaddr) + return -1; + addr.sdn_family = AF_DECnet; + + addr.sdn_add.a_len = nodeaddr->n_length; + memcpy(addr.sdn_add.a_addr, nodeaddr->n_addr, addr.sdn_add.a_len); + + sprintf((char *)addr.sdn_objname, "X$X%d", port); + addr.sdn_objnamel = strlen((char *)addr.sdn_objname); + addr.sdn_objnum = 0; + + fd = socket(PF_DECnet, SOCK_STREAM, 0); + if(fd == -1) + return -1; + + memset(&accessdata, 0, sizeof(accessdata)); + sprintf((char*)accessdata.acc_acc, "%d", getuid()); + accessdata.acc_accl = strlen((char *)accessdata.acc_acc); + setsockopt(fd, DNPROTO_NSP, SO_CONACCESS, &accessdata, sizeof(accessdata)); + + if(connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) + return -1; + return fd; +} +#endif + +static int _xcb_open_tcp(const char *host, const unsigned short port) { int fd; struct sockaddr_in addr; @@ -131,7 +189,7 @@ int XCBOpenTCP(const char *host, const unsigned short port) return fd; } -int XCBOpenUnix(const char *file) +static int _xcb_open_unix(const char *file) { int fd; struct sockaddr_un addr = { AF_UNIX }; @@ -154,12 +212,12 @@ XCBConnection *XCBConnect(const char *displayname, int *screenp) if(!XCBParseDisplay(displayname, &host, &display, screenp)) return 0; - fd = XCBOpen(host, display); + fd = _xcb_open(host, display); free(host); if(fd == -1) return 0; - XCBGetAuthInfo(fd, &auth); + _xcb_get_auth_info(fd, &auth); c = XCBConnectToFD(fd, &auth); free(auth.name); free(auth.data); @@ -173,7 +231,7 @@ XCBConnection *XCBConnectToDisplayWithAuthInfo(const char *displayname, XCBAuthI if(!XCBParseDisplay(displayname, &host, &display, screenp)) return 0; - fd = XCBOpen(host, display); + fd = _xcb_open(host, display); free(host); if(fd == -1) return 0; @@ -181,7 +239,17 @@ XCBConnection *XCBConnectToDisplayWithAuthInfo(const char *displayname, XCBAuthI return XCBConnectToFD(fd, auth); } -/* backwards compatible interface: remove before 1.0 release */ +int XCBSync(XCBConnection *c, XCBGenericError **e) +{ + XCBGetInputFocusRep *reply = XCBGetInputFocusReply(c, XCBGetInputFocus(c), e); + free(reply); + return reply != 0; +} + + + + +/* backwards compatible interfaces: remove before 1.0 release */ XCBConnection *XCBConnectBasic() { XCBConnection *c = XCBConnect(0, 0); @@ -191,89 +259,162 @@ XCBConnection *XCBConnectBasic() abort(); } -int XCBSync(XCBConnection *c, XCBGenericError **e) +int XCBOpen(const char *host, const int display) { - XCBGetInputFocusRep *reply = XCBGetInputFocusReply(c, XCBGetInputFocus(c), e); - free(reply); - return reply != 0; + return _xcb_open(host, display); } -/* The functions beyond this point still use only public interfaces, - * but are not themselves part of the public interface. So their - * prototypes are in xcbint.h. */ +int XCBOpenTCP(const char *host, const unsigned short port) +{ + return _xcb_open_tcp(host, port); +} -#include "xcbint.h" +int XCBOpenUnix(const char *file) +{ + return _xcb_open_unix(file); +} -int _xcb_set_fd_flags(const int fd) +int XCBGetAuthInfo(int fd, XCBAuthInfo *info) { - long flags = fcntl(fd, F_GETFL, 0); - if(flags == -1) - return 0; - flags |= O_NONBLOCK; - if(fcntl(fd, F_SETFL, flags) == -1) - return 0; - if(fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) - return 0; - return 1; + return _xcb_get_auth_info(fd, info); } -int _xcb_readn(const int fd, void *buf, const int buflen, int *count) +char *XCBConnSetupReqAuthorizationProtocolName(XCBSetupReq *R) { - int n = read(fd, ((char *) buf) + *count, buflen - *count); - if(n > 0) - *count += n; - return n; + return XCBSetupReqAuthorizationProtocolName(R); } -int _xcb_read_block(const int fd, void *buf, const size_t len) +int XCBConnSetupReqAuthorizationProtocolNameLength(XCBSetupReq *R) { - int done = 0; - while(done < len) - { - int ret = _xcb_readn(fd, buf, len, &done); - if(ret < 0 && errno == EAGAIN) - { - fd_set fds; - FD_ZERO(&fds); - FD_SET(fd, &fds); - ret = select(fd + 1, &fds, 0, 0, 0); - } - if(ret <= 0) - return ret; - } - return len; + return XCBSetupReqAuthorizationProtocolNameLength(R); } -int _xcb_write(const int fd, char (*buf)[], int *count) +XCBGenericIter XCBConnSetupReqAuthorizationProtocolNameEnd(XCBSetupReq *R) { - int n = write(fd, *buf, *count); - if(n > 0) - { - *count -= n; - if(*count) - memmove(*buf, *buf + n, *count); - } - return n; + return XCBSetupReqAuthorizationProtocolNameEnd(R); } -int _xcb_writev(const int fd, struct iovec *vec, int count) +char *XCBConnSetupReqAuthorizationProtocolData(XCBSetupReq *R) { - int n = writev(fd, vec, count); - if(n > 0) - { - int rem = n; - for(; count; --count, ++vec) - { - int cur = vec->iov_len; - if(cur > rem) - cur = rem; - vec->iov_len -= cur; - vec->iov_base = (char *) vec->iov_base + cur; - rem -= cur; - if(vec->iov_len) - break; - } - assert(rem == 0); - } - return n; + return XCBSetupReqAuthorizationProtocolData(R); +} + +int XCBConnSetupReqAuthorizationProtocolDataLength(XCBSetupReq *R) +{ + return XCBSetupReqAuthorizationProtocolDataLength(R); +} + +XCBGenericIter XCBConnSetupReqAuthorizationProtocolDataEnd(XCBSetupReq *R) +{ + return XCBSetupReqAuthorizationProtocolDataEnd(R); +} + +void XCBConnSetupReqNext(XCBSetupReqIter *i) +{ + XCBSetupReqNext(i); +} + +XCBGenericIter XCBConnSetupReqEnd(XCBSetupReqIter i) +{ + return XCBSetupReqEnd(i); +} + +char *XCBConnSetupFailedRepReason(XCBSetupFailed *R) +{ + return XCBSetupFailedReason(R); +} + +int XCBConnSetupFailedRepReasonLength(XCBSetupFailed *R) +{ + return XCBSetupFailedReasonLength(R); +} + +XCBGenericIter XCBConnSetupFailedRepReasonEnd(XCBSetupFailed *R) +{ + return XCBSetupFailedReasonEnd(R); +} + +void XCBConnSetupFailedRepNext(XCBSetupFailedIter *i) +{ + XCBSetupFailedNext(i); +} + +XCBGenericIter XCBConnSetupFailedRepEnd(XCBSetupFailedIter i) +{ + return XCBSetupFailedEnd(i); +} + +char *XCBConnSetupAuthenticateRepReason(XCBSetupAuthenticate *R) +{ + return XCBSetupAuthenticateReason(R); +} + +int XCBConnSetupAuthenticateRepReasonLength(XCBSetupAuthenticate *R) +{ + return XCBSetupAuthenticateReasonLength(R); +} + +XCBGenericIter XCBConnSetupAuthenticateRepReasonEnd(XCBSetupAuthenticate *R) +{ + return XCBSetupAuthenticateReasonEnd(R); +} + +void XCBConnSetupAuthenticateRepNext(XCBSetupAuthenticateIter *i) +{ + XCBSetupAuthenticateNext(i); +} + +XCBGenericIter XCBConnSetupAuthenticateRepEnd(XCBSetupAuthenticateIter i) +{ + return XCBSetupAuthenticateEnd(i); +} + +char *XCBConnSetupSuccessRepVendor(XCBSetup *R) +{ + return XCBSetupVendor(R); +} + +int XCBConnSetupSuccessRepVendorLength(XCBSetup *R) +{ + return XCBSetupVendorLength(R); +} + +XCBGenericIter XCBConnSetupSuccessRepVendorEnd(XCBSetup *R) +{ + return XCBSetupVendorEnd(R); +} + +XCBFORMAT *XCBConnSetupSuccessRepPixmapFormats(XCBSetup *R) +{ + return XCBSetupPixmapFormats(R); +} + +int XCBConnSetupSuccessRepPixmapFormatsLength(XCBSetup *R) +{ + return XCBSetupPixmapFormatsLength(R); +} + +XCBFORMATIter XCBConnSetupSuccessRepPixmapFormatsIter(XCBSetup *R) +{ + return XCBSetupPixmapFormatsIter(R); +} + +int XCBConnSetupSuccessRepRootsLength(XCBSetup *R) +{ + return XCBSetupRootsLength(R); +} + +XCBSCREENIter XCBConnSetupSuccessRepRootsIter(XCBSetup *R) +{ + return XCBSetupRootsIter(R); +} + +void XCBConnSetupSuccessRepNext(XCBSetupIter *i) +{ + XCBSetupNext(i); +} + +XCBGenericIter XCBConnSetupSuccessRepEnd(XCBSetupIter i) +{ + return XCBSetupEnd(i); }