int
main(int argc, char *argv[])
{
static XtAppContext appContext;
IceConn iceConn;
IceProtocolSetupStatus setupstat;
char *vendor = NULL;
char *release = NULL;
pmGetProxyAddrMsg *pMsg;
char *pData;
int i;
size_t len;
IceReplyWaitInfo replyWait;
GetProxyAddrReply reply;
int majorVersion, minorVersion;
Bool gotReply, ioErrorOccured;
char errorString[255];
char *serviceName = NULL, *serverAddress = NULL;
char *hostAddress = NULL, *startOptions = NULL;
char *managerAddress = NULL;
Bool haveAuth = 0;
char authName[40];
char authData[128];
char *authDataBinary = NULL;
int authLen = 0;
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'a': /* -auth */
haveAuth = 1;
continue;
case 'm': /* -manager */
if (++i >= argc) goto usage;
managerAddress = (char *) XtNewString (argv[i]);
continue;
case 's': /* -server */
if (++i >= argc) goto usage;
serverAddress = (char *) XtNewString (argv[i]);
continue;
case 'n': /* -name */
if (++i >= argc) goto usage;
serviceName = XtNewString (argv[i]);
continue;
case 'h': /* -host */
if (++i >= argc) goto usage;
hostAddress = XtNewString (argv[i]);
continue;
case 'o': /* -options */
if (++i >= argc) goto usage;
startOptions = XtNewString (argv[i]);
continue;
case 'v':
puts(PACKAGE_STRING);
exit(0);
}
}
usage:
if (i >= argc)
fprintf (stderr, "%s: %s requires an argument\n",
argv[0], argv[i-1]);
else
fprintf (stderr, "%s: unrecognized argument '%s'\n",
argv[0], argv[i]);
usage();
}
if (serviceName == NULL) {
fprintf (stderr, "%s: -name serviceName must be specified\n", argv[0]);
usage();
}
if (serverAddress == NULL) {
fprintf (stderr, "%s: -server serverAddr must be specified\n", argv[0]);
usage();
}
if (managerAddress == NULL) {
managerAddress = getenv("PROXY_MANAGER");
if (managerAddress == NULL) {
fprintf (stderr, "Error: -manager option must be specified when PROXY_MANAGER is not in the environment\n");
exit (1);
}
}
/*
* Register support for PROXY_MANAGEMENT.
*/
if ((PMopcode = IceRegisterForProtocolSetup (
PM_PROTOCOL_NAME,
"XC", "1.0",
PMversionCount, PMversions,
0, /* authcount */
NULL, /* authnames */
NULL, /* authprocs */
NULL /* IceIOErrorProc */ )) < 0)
{
fprintf (stderr,
"Could not register PROXY_MANAGEMENT protocol with ICE");
exit (1);
}
appContext = XtCreateApplicationContext ();
InitWatchProcs (appContext);
if ((iceConn = IceOpenConnection (
managerAddress, NULL, 0, 0, 256, errorString)) == NULL)
{
fprintf (stderr,
"Could not open ICE connection to proxy manager: %s", errorString);
exit (1);
}
setupstat = IceProtocolSetup (iceConn, PMopcode, NULL,
False /* mustAuthenticate */,
&majorVersion, &minorVersion,
&vendor, &release, 256, errorString);
if (setupstat != IceProtocolSetupSuccess)
{
IceCloseConnection (iceConn);
fprintf (stderr,
"Could not initialize proxy management protocol: %s\n",
errorString);
exit (1);
}
/*
* If auth data is supplied, read it from stdin.
*/
if (haveAuth)
{
fgets (authName, sizeof (authName), stdin);
fgets (authData, sizeof (authData), stdin);
for (i = 0; i < strlen (authName); i++)
if (authName[i] == '\n')
{
authName[i] = '\0';
break;
}
for (i = 0; i < strlen (authData); i++)
if (authData[i] == '\n')
{
authData[i] = '\0';
break;
}
/*
* Convert the hex auth data to binary.
*/
authLen = cvthexkey (authData, &authDataBinary);
if (authLen == -1)
{
fprintf (stderr, "Could not convert hex auth data to binary\n");
exit (1);
}
}
/*
* Now send the GetProxyAddr request.
*/
len = STRING_BYTES (serviceName) +
STRING_BYTES (serverAddress) +
STRING_BYTES (hostAddress) +
STRING_BYTES (startOptions) +
(authLen > 0 ? (STRING_BYTES (authName) + authLen) : 0);
IceGetHeaderExtra (iceConn, PMopcode, PM_GetProxyAddr,
SIZEOF (pmGetProxyAddrMsg), WORD64COUNT (len),
pmGetProxyAddrMsg, pMsg, pData);
pMsg->authLen = (CARD16) authLen;
STORE_STRING (pData, serviceName);
STORE_STRING (pData, serverAddress);
STORE_STRING (pData, hostAddress);
STORE_STRING (pData, startOptions);
if (authLen > 0)
{
STORE_STRING (pData, authName);
memcpy (pData, authDataBinary, authLen);
}
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");
exit (1);
}
else if (gotReply)
{
if (reply.status == PM_Success)
{
fprintf (stdout, "%s\n", reply.addr);
exit (0);
}
else
{
fprintf (stderr, "Error from proxy manager: %s\n",
reply.error);
exit (1);
}
}
}
/*NOTREACHED*/
exit(0);
}
SmcConn
SmcOpenConnection(char *networkIdsList, SmPointer context,
int xsmpMajorRev, int xsmpMinorRev,
unsigned long mask, SmcCallbacks *callbacks,
char *previousId, char **clientIdRet,
int errorLength, char *errorStringRet)
{
SmcConn smcConn;
IceConn iceConn;
char *ids;
IceProtocolSetupStatus setupstat;
int majorVersion;
int minorVersion;
char *vendor = NULL;
char *release = NULL;
smRegisterClientMsg *pMsg;
char *pData;
int extra, len;
IceReplyWaitInfo replyWait;
_SmcRegisterClientReply reply;
Bool gotReply, ioErrorOccured;
const char *auth_names[] = {"MIT-MAGIC-COOKIE-1"};
IcePoAuthProc auth_procs[] = {_IcePoMagicCookie1Proc};
int auth_count = 1;
IcePoVersionRec versions[] = {
{SmProtoMajor, SmProtoMinor, _SmcProcessMessage}
};
int version_count = 1;
*clientIdRet = NULL;
if (errorStringRet && errorLength > 0)
*errorStringRet = '\0';
if (!_SmcOpcode)
{
/*
* For now, there is only one version of XSMP, so we don't
* have to check {xsmpMajorRev, xsmpMinorRev}. In the future,
* we will check against versions and generate the list
* of versions the application actually supports.
*/
if ((_SmcOpcode = IceRegisterForProtocolSetup ("XSMP",
SmVendorString, SmReleaseString, version_count, versions,
auth_count, auth_names, auth_procs, NULL)) < 0)
{
if (errorStringRet && errorLength > 0) {
strncpy (errorStringRet,
"Could not register XSMP protocol with ICE",
errorLength);
errorStringRet[errorLength - 1] = '\0';
}
return (NULL);
}
}
if (networkIdsList == NULL || *networkIdsList == '\0')
{
if ((ids = (char *) getenv ("SESSION_MANAGER")) == NULL)
{
if (errorStringRet && errorLength > 0) {
strncpy (errorStringRet,
"SESSION_MANAGER environment variable not defined",
errorLength);
errorStringRet[errorLength - 1] = '\0';
}
return (NULL);
}
}
else
{
ids = networkIdsList;
}
if ((iceConn = IceOpenConnection (
ids, context, 0, _SmcOpcode, errorLength, errorStringRet)) == NULL)
{
return (NULL);
}
if ((smcConn = (SmcConn) malloc (sizeof (struct _SmcConn))) == NULL)
{
if (errorStringRet && errorLength > 0) {
strncpy (errorStringRet, "Can't malloc", errorLength);
errorStringRet[errorLength - 1] = '\0';
}
IceCloseConnection (iceConn);
return (NULL);
}
setupstat = IceProtocolSetup (iceConn, _SmcOpcode,
(IcePointer) smcConn,
False /* mustAuthenticate */,
&majorVersion, &minorVersion,
&vendor, &release, errorLength, errorStringRet);
if (setupstat == IceProtocolSetupFailure ||
setupstat == IceProtocolSetupIOError)
{
IceCloseConnection (iceConn);
free ((char *) smcConn);
return (NULL);
}
else if (setupstat == IceProtocolAlreadyActive)
{
/*
* This case should never happen, because when we called
* IceOpenConnection, we required that the ICE connection
* may not already have XSMP active on it.
*/
free ((char *) smcConn);
if (errorStringRet && errorLength > 0) {
strncpy (errorStringRet, "Internal error in IceOpenConnection",
errorLength);
errorStringRet[errorLength - 1] = '\0';
}
return (NULL);
}
smcConn->iceConn = iceConn;
smcConn->proto_major_version = majorVersion;
smcConn->proto_minor_version = minorVersion;
smcConn->vendor = vendor;
smcConn->release = release;
smcConn->client_id = NULL;
bzero ((char *) &smcConn->callbacks, sizeof (SmcCallbacks));
set_callbacks (smcConn, mask, callbacks);
smcConn->interact_waits = NULL;
smcConn->phase2_wait = NULL;
smcConn->prop_reply_waits = NULL;
smcConn->save_yourself_in_progress = False;
smcConn->shutdown_in_progress = False;
/*
* Now register the client
*/
if (!previousId)
previousId = "";
len = strlen (previousId);
extra = ARRAY8_BYTES (len);
IceGetHeaderExtra (iceConn, _SmcOpcode, SM_RegisterClient,
SIZEOF (smRegisterClientMsg), WORD64COUNT (extra),
smRegisterClientMsg, pMsg, pData);
STORE_ARRAY8 (pData, len, previousId);
IceFlush (iceConn);
replyWait.sequence_of_request = IceLastSentSequenceNumber (iceConn);
replyWait.major_opcode_of_request = _SmcOpcode;
replyWait.minor_opcode_of_request = SM_RegisterClient;
replyWait.reply = (IcePointer) &reply;
gotReply = False;
ioErrorOccured = False;
while (!gotReply && !ioErrorOccured)
{
ioErrorOccured = (IceProcessMessages (
iceConn, &replyWait, &gotReply) == IceProcessMessagesIOError);
if (ioErrorOccured)
{
if (errorStringRet && errorLength > 0) {
strncpy (errorStringRet, "IO error occured opening connection",
errorLength);
errorStringRet[errorLength - 1] = '\0';
}
free (smcConn->vendor);
free (smcConn->release);
free ((char *) smcConn);
return (NULL);
}
else if (gotReply)
{
if (reply.status == 1)
{
/*
* The client successfully registered.
*/
*clientIdRet = reply.client_id;
smcConn->client_id = (char *) malloc (
strlen (*clientIdRet) + 1);
strcpy (smcConn->client_id, *clientIdRet);
}
else
{
/*
* Could not register the client because the previous ID
* was bad. So now we register the client with the
* previous ID set to NULL.
*/
extra = ARRAY8_BYTES (0);
IceGetHeaderExtra (iceConn, _SmcOpcode, SM_RegisterClient,
SIZEOF (smRegisterClientMsg), WORD64COUNT (extra),
smRegisterClientMsg, pMsg, pData);
STORE_ARRAY8 (pData, 0, "");
IceFlush (iceConn);
replyWait.sequence_of_request =
IceLastSentSequenceNumber (iceConn);
gotReply = False;
}
}
}
return (smcConn);
}
Bool
dcop_connect()
{
size_t bytesRead = 0;
IcePointer context = 0;
FILE * f = 0L;
char * newline = 0L;
char * homeDir = 0L;
char * display = 0L;
char * dcopServer = 0L;
char errBuf[BUFFER_SIZE];
char fileName[BUFFER_SIZE];
char hostName[BUFFER_SIZE];
char displayName[BUFFER_SIZE];
char * i;
homeDir = getenv("HOME");
if (NULL == homeDir)
return False;
display = getenv("DISPLAY");
if (NULL == display)
display = "NODISPLAY";
strncpy(displayName, display, sizeof(displayName));
displayName[sizeof(displayName) - 1] = 0;
if((i = strrchr(displayName, '.')) > strrchr(displayName, ':') && i)
*i = '\0';
while((i = strchr(displayName, ':')) != NULL)
*i = '_';
dcopServer = getenv("DCOPSERVER");
if (NULL == dcopServer) {
if (-1 == chdir(homeDir)) {
fprintf(stderr, "Cannot cd ~\n");
return False;
}
hostName[0] = '\0';
if (getenv("XAUTHLOCALHOSTNAME"))
strlcpy(hostName, getenv("XAUTHLOCALHOSTNAME"),sizeof(hostName)-1);
else if (gethostname(hostName, sizeof(hostName)))
strcpy(hostName, "localhost");
else
hostName[sizeof(hostName)-1] = '\0';
snprintf(fileName, sizeof(fileName), ".DCOPserver_%s_%s", hostName, displayName);
f = fopen(fileName, "r");
if (NULL == f) {
fprintf(stderr, "Cannot open ~/%s\n", fileName);
return False;
}
dcopServer = (char *)malloc(BUFFER_SIZE);
bytesRead = fread((void *)dcopServer, sizeof(char), BUFFER_SIZE, f);
dcopServer[BUFFER_SIZE - 1] = 0;
if (0 == bytesRead)
return False;
newline = strchr(dcopServer, '\n');
if (NULL == newline) {
fprintf(stderr, "dcop server file format invalid\n");
return False;
}
*newline = '\0';
}
dcop_ice_conn =
IceOpenConnection(
dcopServer,
context,
False,
dcop_major_opcode,
sizeof(errBuf),
errBuf
);
if (NULL != dcopServer)
free(dcopServer);
if (0 == dcop_ice_conn) {
fprintf(stderr, "dcop_ice_conn is 0 :(\n");
return False;
}
IceSetShutdownNegotiation(dcop_ice_conn, False);
return True;
}
