Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
81cda3082a
NetBSD/gnu/dist/gdb/29k-share/udi/udip2soc.c
gwr fb5baea630 stock gdb-4.16
1997-09-24 16:57:14 +00:00

1252 lines
39 KiB
C
Raw Blame History

/* Copyright 1993 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
static char udip2soc_c[]="@(#)udip2soc.c 2.11 Daniel Mann";
static char udip2soc_c_AMD[]="@(#)udip2soc.c 2.8, AMD";
/*
* This module converts UDI Procedural calls into
* UDI socket messages for UNIX.
* It is used by DFE client processes
********************************************************************** HISTORY
*/
/* This is all unneeded on DOS machines. */
#ifndef __GO32__
#include <stdio.h>
#include <string.h>
/* Before sys/file.h for Unixware. */
#include <sys/types.h>
#include <sys/file.h>
/* This used to say sys/fcntl.h, but the only systems I know of that
require that are old (pre-4.3, at least) BSD systems, which we
probably don't need to worry about. */
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <signal.h>
#include <sys/errno.h>
#include "udiproc.h"
#include "udisoc.h"
extern int errno;
extern int sys_nerr;
extern char* sys_errlist[];
extern int udr_errno;
extern char* getenv();
/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE
*/
#define version_c 0x121 /* DFE-IPC version id */
#define TRUE -1
#define FALSE 0
#define PORT_NUM 7000
#define MAX_SESSIONS 5 /* maximum DFE-TIP connections */
#define SOC_BUF_SIZE 4* 1024 /* size of socket comms buffer */
#define SBUF_SIZE 500 /* size of string buffer */
#define ERRMSG_SIZE 500 /* size of error message buffer */
typedef struct connection_str /* record of connect session */
{
int in_use;
char connect_id[20]; /* connection identifier */
char domain_string[20]; /* dommaing for conection */
char tip_string[30]; /* TIP host name for AF_INET */
char tip_exe[80]; /* TIP exe name */
int dfe_sd; /* associated DFE socket */
int tip_pid; /* pid of TIP process */
struct sockaddr_in dfe_sockaddr;
struct sockaddr_in tip_sockaddr_in;
struct sockaddr tip_sockaddr;
} connection_t;
typedef struct session_str
{
int in_use;
connection_t* soc_con_p; /* associated connection */
UDISessionId tip_id; /* associated TIP session ID */
} session_t;
/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS
*/
UDIError dfe_errno;
char dfe_errmsg[ERRMSG_SIZE];/* error string */
/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS
*/
LOCAL connection_t soc_con[MAX_SESSIONS];
LOCAL session_t session[MAX_SESSIONS];
LOCAL UDR udr;
LOCAL UDR* udrs = &udr; /* UDR for current session */
LOCAL int current; /* int-id for current session */
LOCAL char sbuf[SBUF_SIZE]; /* String handler buffer */
LOCAL char config_file[80]; /* path/name for config file */
/***************************************************************** UDI_CONNECT
* Establish a new FDE to TIP conection. The file "./udi_soc" or
* "/etc/udi_soc" may be examined to obtain the conection information
* if the "Config" parameter is not a completd "line entry".
*
* NOTE: the Session string must not start whith white-space characters.
* Format of string is:
* <session> <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect>
* soc2cayman AF_INET cayman 7000 <not supported>
* soc2tip AF_UNIX astring tip.exe ...
*/
UDIError
UDIConnect(Config, Session)
char *Config; /* in -- identification string */
UDISessionId *Session; /* out -- session ID */
{
UDIInt32 service_id = UDIConnect_c;
int domain;
int cnt=0;
int rcnt, pos, params_pos=0;
char *tip_main_string;
char *env_p;
struct hostent *tip_info_p;
FILE *fd;
#if 0
FILE *f_p;
#endif
UDIUInt32 TIPIPCId;
UDIUInt32 DFEIPCId;
#if 0 /* This is crap. It assumes that udi_soc is executable! */
sprintf(sbuf, "which udi_soc");
f_p = popen(sbuf, "r");
if(f_p)
{ while( (sbuf[cnt++]=getc(f_p)) != EOF);
sbuf[cnt-2]=0;
}
pclose(f_p);
#endif
for (rcnt=0;
rcnt < MAX_SESSIONS && session[rcnt].in_use;
rcnt++);
if (rcnt >= MAX_SESSIONS)
{
sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many sessions already open");
return UDIErrorIPCLimitation;
}
/* One connection can be multiplexed between several sessions. */
for (cnt=0;
cnt < MAX_SESSIONS && soc_con[cnt].in_use;
cnt++);
if (cnt >= MAX_SESSIONS)
{
sprintf(dfe_errmsg,
"DFE-ipc ERROR: Too many connections already open");
return UDIErrorIPCLimitation;
}
*Session = rcnt;
session[rcnt].soc_con_p = &soc_con[cnt];
if (strchr(Config, ' ')) /* test if file entry given */
{
soc_con[cnt].in_use = TRUE;
sscanf(Config, "%s %s %s %s %n",
soc_con[cnt].connect_id,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
soc_con[cnt].tip_exe,
&params_pos);
tip_main_string = Config + params_pos;
}
else /* here if need to read udi_soc file */
{
strcpy(config_file, "udi_soc");
env_p = getenv("UDICONF");
if (env_p)
strcpy(config_file, env_p);
fd = fopen(config_file, "r");
if (!fd)
{
sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ",
sys_errlist[errno]);
dfe_errno = UDIErrorCantOpenConfigFile;
goto tip_failure;
}
while (1)
{
if (fscanf(fd, "%s %s %s %s %[^\n]\n",
soc_con[cnt].connect_id,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
soc_con[cnt].tip_exe,
sbuf) == EOF)
break;
if (strcmp(Config, soc_con[cnt].connect_id) != 0)
continue;
soc_con[cnt].in_use = TRUE; /* here if entry found */
tip_main_string = sbuf;
break;
}
fclose(fd);
if (!soc_con[cnt].in_use)
{
sprintf(dfe_errmsg,
"UDIConnect, can't find `%s' entry in udi_soc file",
Config);
dfe_errno = UDIErrorNoSuchConfiguration;
goto tip_failure;
}
}
/*----------------------------------------------------------- SELECT DOMAIN */
if (strcmp(soc_con[cnt].domain_string, "AF_UNIX") == 0)
domain = AF_UNIX;
else if (strcmp(soc_con[cnt].domain_string, "AF_INET") == 0)
domain = AF_INET;
else
{
sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known");
dfe_errno = UDIErrorBadConfigFileEntry;
goto tip_failure;
}
/*---------------------------------------------------- MULTIPLEXED SOCKET ? */
/* If the requested session requires communication with
a TIP which already has a socket connection established,
then we do not create a new socket but multiplex the
existing one. A TIP is said to use the same socket if
socket-name/host-name and the domain are the same.
*/
for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++)
{
if (soc_con[rcnt].in_use
&& rcnt != cnt
&& strcmp(soc_con[cnt].domain_string,
soc_con[rcnt].domain_string) == 0
&& strcmp(soc_con[cnt].tip_string,
soc_con[rcnt].tip_string) == 0)
{
session[*Session].soc_con_p = &soc_con[rcnt];
soc_con[cnt].in_use = FALSE; /* don't need new connect */
goto tip_connect;
}
}
/*------------------------------------------------------------------ SOCKET */
soc_con[cnt].dfe_sd = socket(domain, SOCK_STREAM, 0);
if (soc_con[cnt].dfe_sd == -1)
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ",
sys_errlist[errno]);
dfe_errno = UDIErrorUnknownError;
goto tip_failure;
}
/*--------------------------------------------------------- AF_UNIX CONNECT */
if (domain == AF_UNIX)
{
if (strcmp(soc_con[cnt].tip_string, "*") == 0)
{
for (pos = 0; pos < 20; pos++)
{
int f;
sprintf(soc_con[cnt].tip_string,"/tmp/U%d", getpid() + pos);
f = open(soc_con[cnt].tip_string, O_CREAT);
if (f == -1)
continue;
close(f);
unlink(soc_con[cnt].tip_string);
break;
}
if (pos >= 20)
{
sprintf(dfe_errmsg,
"DFE-ipc ERROR, can't create random socket name");
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
soc_con[cnt].tip_sockaddr.sa_family = domain;
memcpy(soc_con[cnt].tip_sockaddr.sa_data,
soc_con[cnt].tip_string,
sizeof(soc_con[cnt].tip_sockaddr.sa_data));
if (connect(soc_con[cnt].dfe_sd,
&soc_con[cnt].tip_sockaddr,
sizeof(soc_con[cnt].tip_sockaddr)))
{ /* if connect() fails assume TIP not yet started */
/*------------------------------------------------------------ AF_UNIX EXEC */
int pid;
int statusp;
char *arg0;
arg0 = strrchr(soc_con[cnt].tip_exe,'/');
if (arg0)
arg0++;
else
arg0 = soc_con[cnt].tip_exe;
pid = vfork();
if (pid == 0) /* Child */
{
execlp(soc_con[cnt].tip_exe,
arg0,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
NULL);
_exit(1);
}
if (waitpid(pid, &statusp, WNOHANG))
{
sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP");
dfe_errno = UDIErrorCantStartTIP;
goto tip_failure;
}
pos = 3;
for (pos = 3; pos > 0; pos--)
{
if (!connect(soc_con[cnt].dfe_sd,
&soc_con[cnt].tip_sockaddr,
sizeof(soc_con[cnt].tip_sockaddr)))
break;
sleep(1);
}
if (pos == 0)
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s",
sys_errlist[errno]);
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
}
/*--------------------------------------------------------- AF_INET CONNECT */
else if (domain == AF_INET)
{
fprintf(stderr,
"DFE-ipc WARNING, need to have first started remote TIP");
soc_con[cnt].tip_sockaddr_in.sin_family = domain;
soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr =
inet_addr(soc_con[cnt].tip_string);
if (soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr == -1)
{
tip_info_p = gethostbyname(soc_con[cnt].tip_string);
if (tip_info_p == NULL)
{
sprintf(dfe_errmsg,"DFE-ipc ERROR, No such host %s",
soc_con[cnt].tip_string);
dfe_errno = UDIErrorNoSuchConnection;
goto tip_failure;
}
memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
tip_info_p->h_addr,
tip_info_p->h_length);
}
soc_con[cnt].tip_sockaddr_in.sin_port
= htons(atoi(soc_con[cnt].tip_exe));
if (connect(soc_con[cnt].dfe_sd,
(struct sockaddr *) &soc_con[cnt].tip_sockaddr_in,
sizeof(soc_con[cnt].tip_sockaddr_in)))
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ",
sys_errlist[errno]);
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
/*------------------------------------------------------------- TIP CONNECT */
if (cnt == 0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE);
tip_connect:
current = cnt;
session[*Session].in_use = TRUE; /* session id is now in use */
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
udr_UDIUInt32(udrs, &DFEIPCId);
udr_string(udrs, tip_main_string);
udr_sendnow(udrs);
udrs->udr_op = UDR_DECODE; /* recv all "out" parameters */
udr_UDIUInt32(udrs, &TIPIPCId);
if ((TIPIPCId & 0xfff) < version_c)
sprintf(dfe_errmsg, "DFE-ipc: Obsolete TIP Specified");
udr_UDIInt32(udrs, &soc_con[cnt].tip_pid);
udr_UDISessionId(udrs, &session[*Session].tip_id);
udr_UDIError(udrs, &dfe_errno);
if (dfe_errno > 0) UDIKill(*Session, 0);
return dfe_errno;
tip_failure:
soc_con[cnt].in_use = FALSE;
session[*Session].in_use = FALSE;
/* XXX - Should also close dfe_sd, but not sure what to do if muxed */
return dfe_errno;
}
/************************************************************** UDI_Disconnect
* UDIDisconnect() should be called before exiting the
* DFE to ensure proper shut down of the TIP.
*/
UDIError UDIDisconnect(Session, Terminate)
UDISessionId Session;
UDIBool Terminate;
{
int cnt;
UDIInt32 service_id = UDIDisconnect_c;
if(Session < 0 || Session > MAX_SESSIONS)
{
sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
return UDIErrorNoSuchConfiguration;
}
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISessionId(udrs, &session[Session].tip_id);
udr_UDIBool(udrs, &Terminate);
udr_sendnow(udrs);
session[Session].in_use = FALSE; /* session id is now free */
for (cnt=0; cnt < MAX_SESSIONS; cnt++)
if(session[cnt].in_use
&& session[cnt].soc_con_p == session[Session].soc_con_p
) break;
if(cnt >= MAX_SESSIONS) /* test if socket not multiplexed */
if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
{
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
return UDIErrorIPCInternal;
}
else
session[Session].soc_con_p->in_use = 0;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************************** UDI_KILL
* UDIKill() is used to send a signal to the TIP.
* This is a private IPC call.
*/
UDIError UDIKill(Session, Signal)
UDISessionId Session;
UDIInt32 Signal;
{
int cnt;
UDIInt32 service_id = UDIKill_c;
if(Session < 0 || Session > MAX_SESSIONS)
{
sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
return UDIErrorNoSuchConfiguration;
}
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISessionId(udrs, &session[Session].tip_id);
udr_UDIInt32(udrs, &Signal);
udr_sendnow(udrs);
session[Session].in_use = FALSE; /* session id is now free */
for (cnt=0; cnt < MAX_SESSIONS; cnt++)
if(session[cnt].in_use
&& session[cnt].soc_con_p == session[Session].soc_con_p
) break;
if(cnt < MAX_SESSIONS) /* test if socket not multiplexed */
if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
{
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
return UDIErrorIPCInternal;
}
else
session[Session].soc_con_p->in_use = 0;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************** UDI_Set_Current_Connection
* If you are connected to multiple TIPs, you can change
* TIPs using UDISetCurrentConnection().
*/
UDIError UDISetCurrentConnection(Session)
UDISessionId Session;
{
UDIInt32 service_id = UDISetCurrentConnection_c;
if(Session < 0 || Session > MAX_SESSIONS)
return UDIErrorNoSuchConfiguration;
if(!session[Session].in_use) /* test if not in use yet */
return UDIErrorNoSuchConnection;
current = Session;
/* change socket or multiplex the same socket */
udrs->sd = session[Session].soc_con_p->dfe_sd;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISessionId(udrs, &session[Session].tip_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************************ UDI_Capabilities
* The DFE uses UDICapabilities() to both inform the TIP
* of what services the DFE offers and to inquire of the
* TIP what services the TIP offers.
*/
UDIError UDICapabilities(TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId,
TIPIPCId, TIPString)
UDIUInt32 *TIPId; /* out */
UDIUInt32 *TargetId; /* out */
UDIUInt32 DFEId; /* in */
UDIUInt32 DFE; /* in */
UDIUInt32 *TIP; /* out */
UDIUInt32 *DFEIPCId; /* out */
UDIUInt32 *TIPIPCId; /* out */
char *TIPString; /* out */
{
UDIInt32 service_id = UDICapabilities_c;
int size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIInt32(udrs, &DFEId);
udr_UDIInt32(udrs, &DFE);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
udr_UDIInt32(udrs, TIPId);
udr_UDIInt32(udrs, TargetId);
udr_UDIInt32(udrs, TIP);
udr_UDIInt32(udrs, DFEIPCId);
*DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
udr_UDIInt32(udrs, TIPIPCId);
udr_string(udrs, sbuf);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
size = strlen(sbuf);
if(size +1 > 80) return -1; /* test if sufficient space */
strcpy(TIPString, sbuf);
return dfe_errno;
}
/********************************************************** UDI_Enumerate_TIPs
* Used by the DFE to enquire about available TIP
* connections.
*/
UDIError UDIEnumerateTIPs(UDIETCallback)
int (*UDIETCallback)(); /* In -- function to callback */
{
FILE *fp;
fp = fopen(config_file, "r");
if(fp == NULL)
return UDIErrorCantOpenConfigFile;
while(fgets( sbuf, SBUF_SIZE, fp))
if(UDIETCallback( sbuf) == UDITerminateEnumeration)
break;
fclose( fp);
return UDINoError; /* return success */
}
/*********************************************************** UDI_GET_ERROR_MSG
* Some errors are target specific. They are indicated
* by a negative error return value. The DFE uses
* UDIGetErrorMsg() to get the descriptive text for
* the error message which can then be displayed to
* the user.
*/
UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone)
UDIError error_code; /* In */
UDISizeT msg_len; /* In -- allowed message space */
char* msg; /* Out -- length of message*/
UDISizeT *CountDone; /* Out -- number of characters */
{
UDIInt32 service_id = UDIGetErrorMsg_c;
int size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIError(udrs, &error_code);
udr_UDISizeT(udrs, &msg_len);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_string(udrs, sbuf);
udr_UDISizeT(udrs, CountDone);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
size = strlen(sbuf);
if(size +1 > msg_len) return -1; /* test if sufficient space */
strcpy(msg, sbuf);
return dfe_errno;
}
/******************************************************* UDI_GET_TARGET_CONFIG
* UDIGetTargetConfig() gets information about the target.
*/
UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions,
NumberOfChips)
UDIMemoryRange KnownMemory[]; /* Out */
UDIInt *NumberOfRanges; /* In and Out */
UDIUInt32 ChipVersions[]; /* Out */
UDIInt *NumberOfChips; /* In and Out */
{
UDIInt32 service_id = UDIGetTargetConfig_c;
int cnt;
int MaxOfRanges = *NumberOfRanges;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIInt(udrs, NumberOfRanges);
udr_UDIInt(udrs, NumberOfChips);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
for(cnt=1; cnt <= MaxOfRanges; cnt++)
udr_UDIMemoryRange(udrs, &KnownMemory[cnt-1]);
udr_UDIInt(udrs, NumberOfRanges);
udr_UDIInt(udrs, NumberOfChips);
for(cnt=1; cnt <= *NumberOfChips; cnt++)
udr_UDIUInt32(udrs, &ChipVersions[cnt -1]);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/********************************************************** UDI_CREATE_PRCOESS
* UDICreateProcess() tells the target OS that a
* process is to be created and gets a PID back unless
* there is some error.
*/
UDIError UDICreateProcess(pid)
UDIPId *pid; /* out */
{
UDIInt32 service_id = UDICreateProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIPId(udrs, pid);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/***************************************************** UDI_Set_Current_Process
* UDISetCurrentProcess uses a pid supplied by
* UDICreateProcess and sets it as the default for all
* udi calls until a new one is set. A user of a
*/
UDIError UDISetCurrentProcess (pid)
UDIPId pid; /* In */
{
UDIInt32 service_id = UDISetCurrentProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIPId(udrs, &pid);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/****************************************************** UDI_INITIALISE_PROCESS
* UDIInitializeProcess() prepare process for
* execution. (Reset processor if process os processor).
*/
UDIError UDIInitializeProcess( ProcessMemory, NumberOfRanges, EntryPoint,
StackSizes, NumberOfStacks, ArgString)
UDIMemoryRange ProcessMemory[]; /* In */
UDIInt NumberOfRanges; /* In */
UDIResource EntryPoint; /* In */
CPUSizeT *StackSizes; /* In */
UDIInt NumberOfStacks; /* In */
char *ArgString; /* In */
{
UDIInt32 service_id = UDIInitializeProcess_c;
int cnt;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIInt(udrs, &NumberOfRanges);
for(cnt = 0; cnt < NumberOfRanges; cnt++)
udr_UDIMemoryRange(udrs, &ProcessMemory[cnt] );
udr_UDIResource(udrs, &EntryPoint);
udr_UDIInt(udrs, &NumberOfStacks);
for(cnt = 0; cnt < NumberOfStacks; cnt++)
udr_CPUSizeT(udrs, &StackSizes[cnt]);
udr_string(udrs, ArgString);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/********************************************************* UDI_DESTROY_PROCESS
* UDIDestroyProcess() frees a process resource
* previously created by UDICreateProcess().
*/
UDIError UDIDestroyProcess(pid)
UDIPId pid; /* in */
{
UDIInt32 service_id = UDIDestroyProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIPId(udrs, &pid);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/****************************************************************** UDI_READ
* UDIRead() reads a block of objects from a target
* address space to host space.
*/
UDIError UDIRead (from, to, count, size, count_done, host_endian)
UDIResource from; /* in - source address on target */
UDIHostMemPtr to; /* out - destination address on host */
UDICount count; /* in -- count of objects to be transferred */
UDISizeT size; /* in -- size of each object */
UDICount *count_done; /* out - count actually transferred */
UDIBool host_endian; /* in -- flag for endian information */
{
UDIInt32 service_id = UDIRead_c;
int byte_count;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIResource(udrs, &from);
udr_UDICount(udrs, &count);
udr_UDISizeT(udrs, &size);
udr_UDIBool(udrs, &host_endian);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
udr_UDICount(udrs, count_done);
byte_count = (*count_done) * size;
if(*count_done > 0 && *count_done <= count)
udr_bytes(udrs, to, byte_count);
if(udr_errno) return udr_errno;
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/****************************************************************** UDI_WRITE
* UDIWrite() writes a block of objects from host
* space to a target address+space.
*/
UDIError UDIWrite( from, to, count, size, count_done, host_endian )
UDIHostMemPtr from; /* in -- source address on host */
UDIResource to; /* in -- destination address on target */
UDICount count; /* in -- count of objects to be transferred */
UDISizeT size; /* in -- size of each object */
UDICount *count_done; /* out - count actually transferred */
UDIBool host_endian; /* in -- flag for endian information */
{
UDIInt32 service_id = UDIWrite_c;
int byte_count = count * size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIResource(udrs, &to);
udr_UDICount(udrs, &count);
udr_UDISizeT(udrs, &size);
udr_UDIBool(udrs, &host_endian);
udr_bytes(udrs, from, byte_count);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
udr_UDICount(udrs, count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************************** UDI_COPY
* UDICopy() copies a block of objects from one target
* get address/space to another target address/space.
*/
UDIError UDICopy(from, to, count, size, count_done, direction )
UDIResource from; /* in -- destination address on target */
UDIResource to; /* in -- source address on target */
UDICount count; /* in -- count of objects to be transferred */
UDISizeT size; /* in -- size of each object */
UDICount *count_done; /* out - count actually transferred */
UDIBool direction; /* in -- high-to-low or reverse */
{
UDIInt32 service_id = UDICopy_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIResource(udrs, &from);
udr_UDIResource(udrs, &to);
udr_UDICount(udrs, &count);
udr_UDISizeT(udrs, &size);
udr_UDIBool(udrs, &direction);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDICount(udrs, count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/***************************************************************** UDI_EXECUTE
* UDIExecute() continues execution of the default
* process from the current PC.
*/
UDIError UDIExecute()
{
UDIInt32 service_id = UDIExecute_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************************** UDI_STEP
* UDIStep() specifies a number of "instruction"
* steps to make.
*/
UDIError UDIStep(steps, steptype, range)
UDIUInt32 steps; /* in -- number of steps */
UDIStepType steptype; /* in -- type of stepping to be done */
UDIRange range; /* in -- range if StepInRange is TRUE */
{
UDIInt32 service_id = UDIStep_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIInt32(udrs, &steps);
udr_UDIStepType(udrs, &steptype);
udr_UDIRange(udrs, &range);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************************** UDI_STOP
* UDIStop() stops the default process
*/
UDIVoid UDIStop()
{
if (strcmp(session[current].soc_con_p->domain_string, "AF_UNIX") == 0)
kill(session[current].soc_con_p->tip_pid, SIGINT);
else
udr_signal(udrs);
/* XXX - should clean up session[] and soc_con[] structs here as well... */
return;
}
/******************************************************************** UDI_WAIT
* UDIWait() returns the state of the target procesor.
*/
UDIError UDIWait(maxtime, pid, stop_reason)
UDIInt32 maxtime; /* in -- maximum time to wait for completion */
UDIPId *pid; /* out -- pid of process which stopped if any */
UDIUInt32 *stop_reason; /* out -- PC where process stopped */
{
UDIInt32 service_id = UDIWait_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIInt32(udrs, &maxtime);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIPId(udrs, pid);
udr_UDIUInt32(udrs, stop_reason);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/********************************************************** UDI_SET_BREAKPOINT
* UDISetBreakpoint() sets a breakpoint at an adress
* and uses the passcount to state how many
* times that instruction should be hit before the
* break occurs.
*/
UDIError UDISetBreakpoint (addr, passcount, type, break_id)
UDIResource addr; /* in -- where breakpoint gets set */
UDIInt32 passcount; /* in -- passcount for breakpoint */
UDIBreakType type; /* in -- breakpoint type */
UDIBreakId *break_id; /* out - assigned break id */
{
UDIInt32 service_id = UDISetBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIResource(udrs, &addr);
udr_UDIInt32(udrs, &passcount);
udr_UDIBreakType(udrs, &type);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIBreakId(udrs, break_id);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************** UDI_QUERY_BREAKPOINT
*/
UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count)
UDIBreakId break_id; /* in -- assigned break id */
UDIResource *addr; /* out - where breakpoint was set */
UDIInt32 *passcount; /* out - trigger passcount for breakpoint */
UDIBreakType *type; /* out - breakpoint type */
UDIInt32 *current_count; /* out - current count for breakpoint */
{
UDIInt32 service_id = UDIQueryBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIBreakId(udrs, &break_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIResource(udrs, addr);
udr_UDIInt32(udrs, passcount);
udr_UDIBreakType(udrs, type);
udr_UDIInt32(udrs, current_count);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/******************************************************** UDI_CLEAR_BREAKPOINT
* UDIClearBreakpoint() is used to clear a breakpoint.
*/
UDIError UDIClearBreakpoint (break_id)
UDIBreakId break_id; /* in -- assigned break id */
{
UDIInt32 service_id = UDIClearBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIBreakId(udrs, &break_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************************** UDI_GET_STDOUT
* UDIGetStdout() is called when a call to
* UDIWait() indicates there is STD output data ready.
*/
UDIError UDIGetStdout(buf, bufsize, count_done)
UDIHostMemPtr buf; /* out -- buffer to be filled */
UDISizeT bufsize; /* in -- buffer size in bytes */
UDISizeT *count_done; /* out -- number of bytes written to buf */
{
UDIInt32 service_id = UDIGetStdout_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************************** UDI_GET_STDERR
* UDIGetStderr() is called when a call to
* UDIWait() indicates there is STDERR output data ready
*/
UDIError UDIGetStderr(buf, bufsize, count_done)
UDIHostMemPtr buf; /* out -- buffer to be filled */
UDISizeT bufsize; /* in -- buffer size in bytes */
UDISizeT *count_done; /* out -- number of bytes written to buf */
{
UDIInt32 service_id = UDIGetStderr_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/*************************************************************** UDI_PUT_STDIN
* UDIPutStdin() is called whenever the DFE wants to
* deliver an input character to the TIP.
*/
UDIError UDIPutStdin (buf, count, count_done)
UDIHostMemPtr buf; /* in -- buffer to be filled */
UDISizeT count; /* in -- buffer size in bytes */
UDISizeT *count_done; /* out - number of bytes written to buf */
{
UDIInt32 service_id = UDIPutStdin_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &count);
udr_bytes(udrs, buf, count);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDISizeT(udrs, count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************************** UDI_STDIN_MODE
* UDIStdinMode() is used to change the mode that chazcters
* are fetched from the user.
*/
UDIError UDIStdinMode(mode)
UDIMode *mode; /* out - */
{
UDIInt32 service_id = UDIStdinMode_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIMode(udrs, mode);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/*************************************************************** UDI_PUT_TRANS
* UDIPutTrans() is used to feed input to the passthru mode.
*/
UDIError UDIPutTrans (buf, count, count_done)
UDIHostMemPtr buf; /* in -- buffer address containing input data */
UDISizeT count; /* in -- number of bytes in buf */
UDISizeT *count_done; /* out-- number of bytes transfered */
{
UDIInt32 service_id = UDIPutTrans_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &count);
udr_bytes(udrs, buf, count);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDISizeT(udrs, count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/*************************************************************** UDI_GET_TRANS
* UDIGetTrans() is used to get output lines from the
* passthru mode.
*/
UDIError UDIGetTrans (buf, bufsize, count_done)
UDIHostMemPtr buf; /* out -- buffer to be filled */
UDISizeT bufsize; /* in -- size of buf */
UDISizeT *count_done; /* out -- number of bytes in buf */
{
UDIInt32 service_id = UDIGetTrans_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
return dfe_errno;
}
/************************************************************** UDI_Trans_Mode
* UDITransMode() is used to change the mode that the
* transparent routines operate in.
*/
UDIError UDITransMode(mode)
UDIMode *mode; /* out -- selected mode */
{
UDIInt32 service_id = UDITransMode_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
udr_UDIMode(udrs, mode);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
/******************************************************************** UDI_TEST
*/
UDIError UDITest( cnt, str_p, array)
UDISizeT cnt;
UDIHostMemPtr str_p;
UDIInt32 array[];
{
UDIInt32 service_id = UDITest_c;
UDIInt16 scnt = cnt;
UDISizeT r_cnt;
char buf[256];
udr_errno = 0;
udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
udr_UDIInt32(udrs, &service_id);
printf("send cnt=%d scnt=%d\n", cnt, scnt);
udr_UDISizeT(udrs, &cnt);
udr_UDIInt16(udrs, &scnt);
printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
array[0], array[1], array[2], array[3]);
udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
printf(" string=%s\n", str_p);
udr_string(udrs, str_p);
udr_sendnow(udrs);
if(udr_errno)
{ fprintf(stderr, " DFE-ipc Send ERROR\n");
return udr_errno;
}
udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
printf("recv ");
udr_UDISizeT(udrs, &r_cnt);
udr_UDIInt16(udrs, &scnt);
printf(" rcnt=%d scnt=%d\n", r_cnt, scnt);
udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
array[0], array[1], array[2], array[3]);
udr_string(udrs, str_p);
printf(" string=%s\n", str_p);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIUInt32 UDIGetDFEIPCId()
{
return ((company_c << 16) + (product_c << 12) + version_c);
}
#endif /* __GO32__ */
Reference in New Issue View Git Blame Copy Permalink