#ifdef XP_UNIX
#include "RxPlugin.h"
#endif
#include "RxI.h"
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include <stdlib.h>
#include <stdio.h>
#include <X11/Xfuncs.h>
#include <X11/Xmd.h>
#include <X11/ICE/ICElib.h>
#include <X11/ICE/ICEmsg.h>
#include <X11/ICE/ICEproto.h>
#include <X11/PM/PM.h>
#include <X11/PM/PMproto.h>
#define DEFAULT_PROXY_MANAGER ":6500"
#define PAD64(_bytes) ((8 - ((unsigned int) (_bytes) % 8)) % 8)
#define PADDED_BYTES64(_bytes) (_bytes + PAD64 (_bytes))
#define WORD64COUNT(_bytes) (((unsigned int) ((_bytes) + 7)) >> 3)
#define STRING_BYTES(_str) (2 + strlen(_str) + PAD64(2 + strlen(_str)))
#define SKIP_STRING(_pBuf, _swap) \
{ \
CARD16 _len; \
EXTRACT_CARD16 (_pBuf, _swap, _len); \
_pBuf += _len; \
if (PAD64 (2 + _len)) \
_pBuf += PAD64 (2 + _len); \
}
#define STORE_CARD16(_pBuf, _val) \
{ \
*((CARD16 *) _pBuf) = _val; \
_pBuf += 2; \
}
#define STORE_STRING(_pBuf, _string) \
{ \
int _len = strlen(_string); \
STORE_CARD16 (_pBuf, _len); \
if (_len) { \
memcpy (_pBuf, _string, _len); \
_pBuf += _len; \
} \
if (PAD64 (2 + _len)) \
_pBuf += PAD64 (2 + _len); \
}
#define EXTRACT_CARD16(_pBuf, _swap, _val) \
{ \
_val = *((CARD16 *) _pBuf); \
_pBuf += 2; \
if (_swap) \
_val = lswaps (_val); \
}
#define EXTRACT_STRING(_pBuf, _swap, _string) \
{ \
CARD16 _len; \
EXTRACT_CARD16 (_pBuf, _swap, _len); \
_string = (char *) malloc (_len + 1); \
memcpy (_string, _pBuf, _len); \
_string[_len] = '\0'; \
_pBuf += _len; \
if (PAD64 (2 + _len)) \
_pBuf += PAD64 (2 + _len); \
}
#define lswapl(_val) ((((_val) & 0xff) << 24) |\
(((_val) & 0xff00) << 8) |\
(((_val) & 0xff0000) >> 8) |\
(((_val) >> 24) & 0xff))
#define lswaps(_val) ((((_val) & 0xff) << 8) | (((_val) >> 8) & 0xff))
#define CHECK_AT_LEAST_SIZE(_iceConn, _majorOp, _minorOp, _expected_len, _actual_len, _severity) \
if ((((_actual_len) - SIZEOF (iceMsg)) >> 3) > _expected_len) \
{ \
_IceErrorBadLength (_iceConn, _majorOp, _minorOp, _severity); \
return; \
}
#define CHECK_COMPLETE_SIZE(_iceConn, _majorOp, _minorOp, _expected_len, _actual_len, _pStart, _severity) \
if (((PADDED_BYTES64((_actual_len)) - SIZEOF (iceMsg)) >> 3) \
!= _expected_len) \
{ \
_IceErrorBadLength (_iceConn, _majorOp, _minorOp, _severity); \
IceDisposeCompleteMessage (iceConn, _pStart); \
return; \
}
static void PMprocessMessages ();
#ifdef XP_UNIX
#define PMOPCODE RxGlobal.pm_opcode
#define ICECONN RxGlobal.ice_conn
#else
static int pm_opcode;
#define PMOPCODE pm_opcode
#define ICECONN ice_conn
#endif
static int PMversionCount = 1;
static IcePoVersionRec PMversions[] =
{{PM_MAJOR_VERSION, PM_MINOR_VERSION, PMprocessMessages}};
typedef struct {
int status;
char *addr;
char *error;
} GetProxyAddrReply;
#if 0
#else
static int findproxy (proxyname, manager, server, name)
char* proxyname;
char* manager;
char* server;
char* name;
{
#ifndef XP_UNIX
IceConn ice_conn;
#endif
IceProtocolSetupStatus setupstat;
char *vendor = NULL;
char *release = NULL;
pmGetProxyAddrMsg *pMsg;
char *pData;
int len;
IceReplyWaitInfo replyWait;
GetProxyAddrReply reply;
int majorVersion, minorVersion;
Bool gotReply, ioErrorOccured;
char errorString[255];
if (PMOPCODE == 0) {
if ((PMOPCODE = IceRegisterForProtocolSetup (
PM_PROTOCOL_NAME,
"XC", "1.0",
PMversionCount, PMversions,
0,
NULL,
NULL,
NULL )) < 0) {
fprintf (stderr,
"Could not register PROXY_MANAGEMENT protocol with ICE\n");
return 0;
}
if ((ICECONN = IceOpenConnection (
manager, NULL, 0, 0, 256, errorString)) == NULL) {
fprintf (stderr,
"Could not open ICE connection to proxy manager\n (%s)\n",
errorString);
return 0;
}
setupstat = IceProtocolSetup (ICECONN, PMOPCODE, NULL,
False ,
&majorVersion, &minorVersion,
&vendor, &release, 256, errorString);
if (setupstat != IceProtocolSetupSuccess) {
IceCloseConnection (ICECONN);
fprintf (stderr,
"Could not initialize proxy management protocol\n (%s)\n",
errorString);
fprintf (stderr, "%d\n", setupstat);
return 0;
}
}
len = STRING_BYTES (name) + STRING_BYTES (server) +
STRING_BYTES ("") + STRING_BYTES ("");
IceGetHeaderExtra (ICECONN, PMOPCODE, PM_GetProxyAddr,
SIZEOF (pmGetProxyAddrMsg), WORD64COUNT (len),
pmGetProxyAddrMsg, pMsg, pData);
pMsg->authLen = 0;
STORE_STRING (pData, name);
STORE_STRING (pData, server);
STORE_STRING (pData, "");
STORE_STRING (pData, "");
IceFlush (ICECONN);
replyWait.sequence_of_request = IceLastSentSequenceNumber (ICECONN);
replyWait.major_opcode_of_request = PMOPCODE;
replyWait.minor_opcode_of_request = PM_GetProxyAddr;
replyWait.reply = (IcePointer) &reply;
gotReply = False;
ioErrorOccured = False;
while (!gotReply && !ioErrorOccured) {
ioErrorOccured = (IceProcessMessages (
ICECONN, &replyWait, &gotReply) == IceProcessMessagesIOError);
if (ioErrorOccured) {
fprintf (stderr, "IO error occured\n");
IceCloseConnection (ICECONN);
return 0;
} else if (gotReply) {
if (reply.status == PM_Success) {
strcpy (proxyname, reply.addr);
} else {
fprintf (stderr, "Error from proxy manager: %s\n",
reply.error);
return 0;
}
}
}
return 1;
}
#endif
static void
PMprocessMessages (iceConn, clientData, opcode,
length, swap, replyWait, replyReadyRet)
IceConn iceConn;
IcePointer clientData;
int opcode;
unsigned long length;
Bool swap;
IceReplyWaitInfo *replyWait;
Bool *replyReadyRet;
{
if (replyWait)
*replyReadyRet = False;
switch (opcode) {
case PM_GetProxyAddrReply:
if (!replyWait ||
replyWait->minor_opcode_of_request != PM_GetProxyAddr) {
_IceReadSkip (iceConn, length << 3);
_IceErrorBadState (iceConn, PMOPCODE,
PM_GetProxyAddrReply, IceFatalToProtocol);
} else {
pmGetProxyAddrReplyMsg *pMsg;
char *pData, *pStart;
GetProxyAddrReply *reply =
(GetProxyAddrReply *) (replyWait->reply);
#if 0
CHECK_AT_LEAST_SIZE (iceConn, PMOPCODE, opcode,
length, SIZEOF (pmGetProxyAddrReplyMsg), IceFatalToProtocol);
#endif
IceReadCompleteMessage (iceConn, SIZEOF (pmGetProxyAddrReplyMsg),
pmGetProxyAddrReplyMsg, pMsg, pStart);
if (!IceValidIO (iceConn)) {
IceDisposeCompleteMessage (iceConn, pStart);
return;
}
pData = pStart;
SKIP_STRING (pData, swap);
SKIP_STRING (pData, swap);
CHECK_COMPLETE_SIZE (iceConn, PMOPCODE, opcode,
length, pData - pStart + SIZEOF (pmGetProxyAddrReplyMsg),
pStart, IceFatalToProtocol);
pData = pStart;
EXTRACT_STRING (pData, swap, reply->addr);
EXTRACT_STRING (pData, swap, reply->error);
reply->status = pMsg->status;
*replyReadyRet = True;
IceDisposeCompleteMessage (iceConn, pStart);
}
break;
default:
_IceErrorBadMinor (iceConn, PMOPCODE, opcode, IceCanContinue);
_IceReadSkip (iceConn, length << 3);
break;
}
}
char *
GetXPrintDisplayName(char **printer_return)
{
char *display_name, *pdpy_name;
char *ptr, *printer_name;
display_name = getenv("XPRINTER");
if (display_name != NULL) {
if (strncmp(display_name, "xprint:", 7) == 0)
pdpy_name = display_name + 7;
else
pdpy_name = display_name;
ptr = strchr(pdpy_name, '@');
if (ptr != NULL) {
printer_name = (char *)Malloc(ptr - pdpy_name + 1);
if (printer_name != NULL) {
strncpy(printer_name, pdpy_name, ptr - pdpy_name);
printer_name[ptr - pdpy_name] = '\0';
}
ptr++;
pdpy_name = (char *)Malloc(strlen(ptr) + 1);
if (pdpy_name != NULL)
strcpy(pdpy_name, ptr);
} else {
printer_name = (char *)Malloc(strlen(pdpy_name) + 1);
if (printer_name != NULL)
strcpy(printer_name, pdpy_name);
pdpy_name = NULL;
}
} else {
pdpy_name = NULL;
printer_name = getenv("PDPRINTER");
if (printer_name == NULL) {
printer_name = getenv("LPDEST");
if (printer_name == NULL)
printer_name = getenv("PRINTER");
}
if (printer_name != NULL) {
ptr = printer_name;
printer_name = (char *)Malloc(strlen(ptr) + 1);
if (printer_name != NULL)
strcpy(printer_name, ptr);
}
}
if (pdpy_name == NULL) {
char *servers_list = getenv("XPSERVERLIST");
if (servers_list != NULL && servers_list[0] != '\0') {
ptr = strchr(servers_list, ' ');
if (ptr != NULL) {
pdpy_name = (char *) Malloc(ptr - servers_list + 1);
if (pdpy_name != NULL) {
strncpy(pdpy_name, servers_list, ptr - servers_list);
pdpy_name[ptr - servers_list] = '\0';
}
} else {
pdpy_name = (char *) Malloc(strlen(servers_list) + 1);
if (pdpy_name != NULL)
strcpy(pdpy_name, servers_list);
}
}
}
*printer_return = printer_name;
return pdpy_name;
}
#define MAXLEN 256
char *
GetXFwpDisplayName(char *dpy_name)
{
#if 0
char *fwp_dpy_name, *ptr, *limit;
FILE *in;
int c, status;
#else
char *fwp_dpy_name;
#endif
char buf[MAXLEN];
char *proxy_mngr;
proxy_mngr = getenv("PROXY_MANAGER");
if (proxy_mngr == NULL)
proxy_mngr = DEFAULT_PROXY_MANAGER;
#if 0
sprintf(buf,
"xfindproxy -manager %s -server %s -name xfwp 2>/dev/null",
proxy_mngr, dpy_name);
in = popen(buf, "r");
if (in != NULL) {
ptr = buf;
limit = buf + MAXLEN - 1;
while ((c = fgetc(in)) != EOF && c != '\n' && ptr < limit)
*ptr++ = c;
status = pclose(in);
(void) fprintf (stderr, "buf: %s\n", buf);
(void) fprintf (stderr, "status: %d\n", status);
(void) fprintf (stderr, "ptr: %p, buf: %p\n", ptr, buf);
if (status == -1 || ptr == buf) {
perror ("too bad");
fwp_dpy_name = NULL;
} else {
*ptr = '\0';
fwp_dpy_name = (char *) Malloc(ptr - buf + 1);
if (fwp_dpy_name != NULL)
strcpy(fwp_dpy_name, buf);
}
} else {
fwp_dpy_name = NULL;
}
#else
fwp_dpy_name = NULL;
if (findproxy (buf, proxy_mngr, dpy_name, "xfwp")) {
fwp_dpy_name = (char *) Malloc (strlen (buf) + 1);
if (fwp_dpy_name != NULL)
strcpy (fwp_dpy_name, buf);
}
#endif
return fwp_dpy_name;
}