static char udip2soc_c[]="@(#)udip2soc.c 2.11 Daniel Mann";
static char udip2soc_c_AMD[]="@(#)udip2soc.c 2.8, AMD";
#ifndef __GO32__
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/file.h>
#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 int udr_errno;
extern char* getenv();
#define version_c 0x121
#define TRUE -1
#define FALSE 0
#define PORT_NUM 7000
#define MAX_SESSIONS 5
#define SOC_BUF_SIZE 4* 1024
#define SBUF_SIZE 500
#define ERRMSG_SIZE 500
typedef struct connection_str
{
int in_use;
char connect_id[20];
char domain_string[20];
char tip_string[30];
char tip_exe[80];
int dfe_sd;
int tip_pid;
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;
UDISessionId tip_id;
} session_t;
UDIError dfe_errno;
char dfe_errmsg[ERRMSG_SIZE];
LOCAL connection_t soc_con[MAX_SESSIONS];
LOCAL session_t session[MAX_SESSIONS];
LOCAL UDR udr;
LOCAL UDR* udrs = &udr;
LOCAL int current;
LOCAL char sbuf[SBUF_SIZE];
LOCAL char config_file[80];
UDIError
UDIConnect(Config, Session)
char *Config;
UDISessionId *Session;
{
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
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;
}
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, ' '))
{
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,
¶ms_pos);
tip_main_string = Config + params_pos;
}
else
{
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 ",
strerror(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;
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;
}
}
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;
}
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;
goto tip_connect;
}
}
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 ",
strerror (errno));
dfe_errno = UDIErrorUnknownError;
goto tip_failure;
}
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)))
{
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)
{
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",
strerror (errno));
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
}
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 ",
strerror (errno));
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
if (cnt == 0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE);
tip_connect:
current = cnt;
session[*Session].in_use = TRUE;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
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;
return dfe_errno;
}
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;
udr_UDIInt32(udrs, &service_id);
udr_UDISessionId(udrs, &session[Session].tip_id);
udr_UDIBool(udrs, &Terminate);
udr_sendnow(udrs);
session[Session].in_use = FALSE;
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)
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;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
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;
udr_UDIInt32(udrs, &service_id);
udr_UDISessionId(udrs, &session[Session].tip_id);
udr_UDIInt32(udrs, &Signal);
udr_sendnow(udrs);
session[Session].in_use = FALSE;
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)
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;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDISetCurrentConnection(Session)
UDISessionId Session;
{
UDIInt32 service_id = UDISetCurrentConnection_c;
if(Session < 0 || Session > MAX_SESSIONS)
return UDIErrorNoSuchConfiguration;
if(!session[Session].in_use)
return UDIErrorNoSuchConnection;
current = Session;
udrs->sd = session[Session].soc_con_p->dfe_sd;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDICapabilities(TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId,
TIPIPCId, TIPString)
UDIUInt32 *TIPId;
UDIUInt32 *TargetId;
UDIUInt32 DFEId;
UDIUInt32 DFE;
UDIUInt32 *TIP;
UDIUInt32 *DFEIPCId;
UDIUInt32 *TIPIPCId;
char *TIPString;
{
UDIInt32 service_id = UDICapabilities_c;
int size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
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);
size = strlen(sbuf);
if(size +1 > 80) return -1;
strcpy(TIPString, sbuf);
return dfe_errno;
}
UDIError UDIEnumerateTIPs(UDIETCallback)
int (*UDIETCallback)();
{
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;
}
UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone)
UDIError error_code;
UDISizeT msg_len;
char* msg;
UDISizeT *CountDone;
{
UDIInt32 service_id = UDIGetErrorMsg_c;
int size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_string(udrs, sbuf);
udr_UDISizeT(udrs, CountDone);
udr_UDIError(udrs, &dfe_errno);
size = strlen(sbuf);
if(size +1 > msg_len) return -1;
strcpy(msg, sbuf);
return dfe_errno;
}
UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions,
NumberOfChips)
UDIMemoryRange KnownMemory[];
UDIInt *NumberOfRanges;
UDIUInt32 ChipVersions[];
UDIInt *NumberOfChips;
{
UDIInt32 service_id = UDIGetTargetConfig_c;
int cnt;
int MaxOfRanges = *NumberOfRanges;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
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);
return dfe_errno;
}
UDIError UDICreateProcess(pid)
UDIPId *pid;
{
UDIInt32 service_id = UDICreateProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIPId(udrs, pid);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDISetCurrentProcess (pid)
UDIPId pid;
{
UDIInt32 service_id = UDISetCurrentProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIPId(udrs, &pid);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIInitializeProcess( ProcessMemory, NumberOfRanges, EntryPoint,
StackSizes, NumberOfStacks, ArgString)
UDIMemoryRange ProcessMemory[];
UDIInt NumberOfRanges;
UDIResource EntryPoint;
CPUSizeT *StackSizes;
UDIInt NumberOfStacks;
char *ArgString;
{
UDIInt32 service_id = UDIInitializeProcess_c;
int cnt;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIDestroyProcess(pid)
UDIPId pid;
{
UDIInt32 service_id = UDIDestroyProcess_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIPId(udrs, &pid);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIRead (from, to, count, size, count_done, host_endian)
UDIResource from;
UDIHostMemPtr to;
UDICount count;
UDISizeT size;
UDICount *count_done;
UDIBool host_endian;
{
UDIInt32 service_id = UDIRead_c;
int byte_count;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
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);
return dfe_errno;
}
UDIError UDIWrite( from, to, count, size, count_done, host_endian )
UDIHostMemPtr from;
UDIResource to;
UDICount count;
UDISizeT size;
UDICount *count_done;
UDIBool host_endian;
{
UDIInt32 service_id = UDIWrite_c;
int byte_count = count * size;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDICount(udrs, count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDICopy(from, to, count, size, count_done, direction )
UDIResource from;
UDIResource to;
UDICount count;
UDISizeT size;
UDICount *count_done;
UDIBool direction;
{
UDIInt32 service_id = UDICopy_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDICount(udrs, count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIExecute()
{
UDIInt32 service_id = UDIExecute_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIStep(steps, steptype, range)
UDIUInt32 steps;
UDIStepType steptype;
UDIRange range;
{
UDIInt32 service_id = UDIStep_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
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);
return;
}
UDIError UDIWait(maxtime, pid, stop_reason)
UDIInt32 maxtime;
UDIPId *pid;
UDIUInt32 *stop_reason;
{
UDIInt32 service_id = UDIWait_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIInt32(udrs, &maxtime);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIPId(udrs, pid);
udr_UDIUInt32(udrs, stop_reason);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDISetBreakpoint (addr, passcount, type, break_id)
UDIResource addr;
UDIInt32 passcount;
UDIBreakType type;
UDIBreakId *break_id;
{
UDIInt32 service_id = UDISetBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDIBreakId(udrs, break_id);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count)
UDIBreakId break_id;
UDIResource *addr;
UDIInt32 *passcount;
UDIBreakType *type;
UDIInt32 *current_count;
{
UDIInt32 service_id = UDIQueryBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIBreakId(udrs, &break_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIResource(udrs, addr);
udr_UDIInt32(udrs, passcount);
udr_UDIBreakType(udrs, type);
udr_UDIInt32(udrs, current_count);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIClearBreakpoint (break_id)
UDIBreakId break_id;
{
UDIInt32 service_id = UDIClearBreakpoint_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIBreakId(udrs, &break_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIGetStdout(buf, bufsize, count_done)
UDIHostMemPtr buf;
UDISizeT bufsize;
UDISizeT *count_done;
{
UDIInt32 service_id = UDIGetStdout_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIGetStderr(buf, bufsize, count_done)
UDIHostMemPtr buf;
UDISizeT bufsize;
UDISizeT *count_done;
{
UDIInt32 service_id = UDIGetStderr_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIPutStdin (buf, count, count_done)
UDIHostMemPtr buf;
UDISizeT count;
UDISizeT *count_done;
{
UDIInt32 service_id = UDIPutStdin_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDISizeT(udrs, count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIStdinMode(mode)
UDIMode *mode;
{
UDIInt32 service_id = UDIStdinMode_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIMode(udrs, mode);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIPutTrans (buf, count, count_done)
UDIHostMemPtr buf;
UDISizeT count;
UDISizeT *count_done;
{
UDIInt32 service_id = UDIPutTrans_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
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;
udr_UDISizeT(udrs, count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDIGetTrans (buf, bufsize, count_done)
UDIHostMemPtr buf;
UDISizeT bufsize;
UDISizeT *count_done;
{
UDIInt32 service_id = UDIGetTrans_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDISizeT(udrs, &bufsize);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDISizeT(udrs, count_done);
udr_bytes(udrs, buf, *count_done);
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
UDIError UDITransMode(mode)
UDIMode *mode;
{
UDIInt32 service_id = UDITransMode_c;
udr_errno = 0;
udrs->udr_op = UDR_ENCODE;
udr_UDIInt32(udrs, &service_id);
udr_UDIMode(udrs, mode);
udr_sendnow(udrs);
if(udr_errno) return udr_errno;
udrs->udr_op = UDR_DECODE;
udr_UDIError(udrs, &dfe_errno);
return dfe_errno;
}
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;
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;
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