X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fxcb_util.c;h=06b5bcaf1b16d8f7b8502a187c931fd891fef193;hb=162c7593adf1577ca8aecfcd53fd5644b6182609;hp=352489910e165ddc1e060c95fa18c7d956ab843f;hpb=5cdc02e3441dc623e91ebc5d7f735565b83f8435;p=free-sw%2Fxcb%2Flibxcb diff --git a/src/xcb_util.c b/src/xcb_util.c index 3524899..06b5bca 100644 --- a/src/xcb_util.c +++ b/src/xcb_util.c @@ -27,10 +27,12 @@ #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,9 +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); +} + +int XCBOpenTCP(const char *host, const unsigned short port) +{ + return _xcb_open_tcp(host, port); +} + +int XCBOpenUnix(const char *file) +{ + return _xcb_open_unix(file); +} + +int XCBGetAuthInfo(int fd, XCBAuthInfo *info) +{ + return _xcb_get_auth_info(fd, info); +} + +char *XCBConnSetupReqAuthorizationProtocolName(XCBSetupReq *R) +{ + return XCBSetupReqAuthorizationProtocolName(R); +} + +int XCBConnSetupReqAuthorizationProtocolNameLength(XCBSetupReq *R) +{ + return XCBSetupReqAuthorizationProtocolNameLength(R); +} + +XCBGenericIter XCBConnSetupReqAuthorizationProtocolNameEnd(XCBSetupReq *R) +{ + return XCBSetupReqAuthorizationProtocolNameEnd(R); +} + +char *XCBConnSetupReqAuthorizationProtocolData(XCBSetupReq *R) +{ + 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); }