projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update/correct copyright notices.
[deliverable/binutils-gdb.git] / gdb / 29k-share / udi / udip2soc.c
CommitLineData
b6ba6518 1/* Copyright 1993, 1998 Free Software Foundation, Inc.
c906108c
SS		 2
3 This file is part of GDB.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
18
19static char udip2soc_c[]="@(#)udip2soc.c 2.11 Daniel Mann";
20static char udip2soc_c_AMD[]="@(#)udip2soc.c 2.8, AMD";
21/*
22* This module converts UDI Procedural calls into
23* UDI socket messages for UNIX.
24* It is used by DFE client processes
25********************************************************************** HISTORY
26*/
27/* This is all unneeded on DOS machines. */
28#ifndef __GO32__
29
30#include <stdio.h>
31#include <string.h>
32
33/* Before sys/file.h for Unixware. */
34#include <sys/types.h>
35
36#include <sys/file.h>
37
38/* This used to say sys/fcntl.h, but the only systems I know of that
39 require that are old (pre-4.3, at least) BSD systems, which we
40 probably don't need to worry about. */
41#include <fcntl.h>
42
43#include <sys/wait.h>
44#include <sys/time.h>
45#include <sys/resource.h>
46#include <sys/socket.h>
47#include <netinet/in.h>
48#include <netdb.h>
49#include <signal.h>
50#include <sys/errno.h>
51#include "udiproc.h"
52#include "udisoc.h"
53
54extern int errno;
55extern int sys_nerr;
56extern int udr_errno;
57extern char* getenv();
58
59/* local type decs. and macro defs. not in a .h file ************* MACRO/TYPE
60*/
61#define version_c 0x121 /* DFE-IPC version id */
62#define TRUE -1
63#define FALSE 0
64#define PORT_NUM 7000
65#define MAX_SESSIONS 5 /* maximum DFE-TIP connections */
66#define SOC_BUF_SIZE 4* 1024 /* size of socket comms buffer */
67#define SBUF_SIZE 500 /* size of string buffer */
68#define ERRMSG_SIZE 500 /* size of error message buffer */
69
70typedef struct connection_str /* record of connect session */
71{
72 int in_use;
73 char connect_id[20]; /* connection identifier */
74 char domain_string[20]; /* dommaing for conection */
75 char tip_string[30]; /* TIP host name for AF_INET */
76 char tip_exe[80]; /* TIP exe name */
77 int dfe_sd; /* associated DFE socket */
78 int tip_pid; /* pid of TIP process */
79 struct sockaddr_in dfe_sockaddr;
80 struct sockaddr_in tip_sockaddr_in;
81 struct sockaddr tip_sockaddr;
82} connection_t;
83
84typedef struct session_str
85{
86 int in_use;
87 connection_t* soc_con_p; /* associated connection */
88 UDISessionId tip_id; /* associated TIP session ID */
89} session_t;
90
91/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS
92*/
93UDIError dfe_errno;
94char dfe_errmsg[ERRMSG_SIZE];/* error string */
95
96/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS
97*/
98LOCAL connection_t soc_con[MAX_SESSIONS];
99LOCAL session_t session[MAX_SESSIONS];
100LOCAL UDR udr;
101LOCAL UDR* udrs = &udr; /* UDR for current session */
102LOCAL int current; /* int-id for current session */
103LOCAL char sbuf[SBUF_SIZE]; /* String handler buffer */
104LOCAL char config_file[80]; /* path/name for config file */
105
106/***************************************************************** UDI_CONNECT
107* Establish a new FDE to TIP conection. The file "./udi_soc" or
108* "/etc/udi_soc" may be examined to obtain the conection information
109* if the "Config" parameter is not a completd "line entry".
110*
111* NOTE: the Session string must not start whith white-space characters.
112* Format of string is:
113* <session> <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect>
114* soc2cayman AF_INET cayman 7000 <not supported>
115* soc2tip AF_UNIX astring tip.exe ...
116*/
117UDIError
118UDIConnect(Config, Session)
119 char *Config; /* in -- identification string */
120 UDISessionId *Session; /* out -- session ID */
121{
122 UDIInt32 service_id = UDIConnect_c;
123 int domain;
124 int cnt=0;
125 int rcnt, pos, params_pos=0;
126 char *tip_main_string;
127 char *env_p;
128 struct hostent *tip_info_p;
129 FILE *fd;
130#if 0
131 FILE *f_p;
132#endif
133 UDIUInt32 TIPIPCId;
134 UDIUInt32 DFEIPCId;
135
136#if 0 /* This is crap. It assumes that udi_soc is executable! */
137 sprintf(sbuf, "which udi_soc");
138 f_p = popen(sbuf, "r");
139 if(f_p)
140 { while( (sbuf[cnt++]=getc(f_p)) != EOF);
141 sbuf[cnt-2]=0;
142 }
143 pclose(f_p);
144#endif
145
146 for (rcnt=0;
147 rcnt < MAX_SESSIONS && session[rcnt].in_use;
148 rcnt++);
149
150 if (rcnt >= MAX_SESSIONS)
151 {
152 sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many sessions already open");
153 return UDIErrorIPCLimitation;
154 }
155
156 /* One connection can be multiplexed between several sessions. */
157
158 for (cnt=0;
159 cnt < MAX_SESSIONS && soc_con[cnt].in_use;
160 cnt++);
161
162 if (cnt >= MAX_SESSIONS)
163 {
164 sprintf(dfe_errmsg,
165 "DFE-ipc ERROR: Too many connections already open");
166 return UDIErrorIPCLimitation;
167 }
168
169 *Session = rcnt;
170 session[rcnt].soc_con_p = &soc_con[cnt];
171
172 if (strchr(Config, ' ')) /* test if file entry given */
173 {
174 soc_con[cnt].in_use = TRUE;
175 sscanf(Config, "%s %s %s %s %n",
176 soc_con[cnt].connect_id,
177 soc_con[cnt].domain_string,
178 soc_con[cnt].tip_string,
179 soc_con[cnt].tip_exe,
180 &params_pos);
181 tip_main_string = Config + params_pos;
182 }
183 else /* here if need to read udi_soc file */
184 {
185 strcpy(config_file, "udi_soc");
186 env_p = getenv("UDICONF");
187 if (env_p)
188 strcpy(config_file, env_p);
189
190 fd = fopen(config_file, "r");
191
192 if (!fd)
193 {
194 sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ",
195 strerror(errno));
196 dfe_errno = UDIErrorCantOpenConfigFile;
197 goto tip_failure;
198 }
199
200 while (1)
201 {
202 if (fscanf(fd, "%s %s %s %s %[^\n]\n",
203 soc_con[cnt].connect_id,
204 soc_con[cnt].domain_string,
205 soc_con[cnt].tip_string,
206 soc_con[cnt].tip_exe,
207 sbuf) == EOF)
208 break;
209
210 if (strcmp(Config, soc_con[cnt].connect_id) != 0)
211 continue;
212
213 soc_con[cnt].in_use = TRUE; /* here if entry found */
214
215 tip_main_string = sbuf;
216 break;
217 }
218
219 fclose(fd);
220 if (!soc_con[cnt].in_use)
221 {
222 sprintf(dfe_errmsg,
223 "UDIConnect, can't find `%s' entry in udi_soc file",
224 Config);
225 dfe_errno = UDIErrorNoSuchConfiguration;
226 goto tip_failure;
227 }
228 }
229/*----------------------------------------------------------- SELECT DOMAIN */
230 if (strcmp(soc_con[cnt].domain_string, "AF_UNIX") == 0)
231 domain = AF_UNIX;
232 else if (strcmp(soc_con[cnt].domain_string, "AF_INET") == 0)
233 domain = AF_INET;
234 else
235 {
236 sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known");
237 dfe_errno = UDIErrorBadConfigFileEntry;
238 goto tip_failure;
239 }
240
241/*---------------------------------------------------- MULTIPLEXED SOCKET ? */
242/* If the requested session requires communication with
243 a TIP which already has a socket connection established,
244 then we do not create a new socket but multiplex the
245 existing one. A TIP is said to use the same socket if
246 socket-name/host-name and the domain are the same.
247 */
248 for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++)
249 {
250 if (soc_con[rcnt].in_use
251 && rcnt != cnt
252 && strcmp(soc_con[cnt].domain_string,
253 soc_con[rcnt].domain_string) == 0
254 && strcmp(soc_con[cnt].tip_string,
255 soc_con[rcnt].tip_string) == 0)
256 {
257 session[*Session].soc_con_p = &soc_con[rcnt];
258 soc_con[cnt].in_use = FALSE; /* don't need new connect */
259 goto tip_connect;
260 }
261 }
262/*------------------------------------------------------------------ SOCKET */
263 soc_con[cnt].dfe_sd = socket(domain, SOCK_STREAM, 0);
264 if (soc_con[cnt].dfe_sd == -1)
265 {
266 sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ",
267 strerror (errno));
268 dfe_errno = UDIErrorUnknownError;
269 goto tip_failure;
270 }
271
272/*--------------------------------------------------------- AF_UNIX CONNECT */
273 if (domain == AF_UNIX)
274 {
275 if (strcmp(soc_con[cnt].tip_string, "*") == 0)
276 {
277 for (pos = 0; pos < 20; pos++)
278 {
279 int f;
280
281 sprintf(soc_con[cnt].tip_string,"/tmp/U%d", getpid() + pos);
282 f = open(soc_con[cnt].tip_string, O_CREAT);
283 if (f == -1)
284 continue;
285
286 close(f);
287 unlink(soc_con[cnt].tip_string);
288 break;
289 }
290
291 if (pos >= 20)
292 {
293 sprintf(dfe_errmsg,
294 "DFE-ipc ERROR, can't create random socket name");
295 dfe_errno = UDIErrorCantConnect;
296 goto tip_failure;
297 }
298 }
299
300 soc_con[cnt].tip_sockaddr.sa_family = domain;
301 memcpy(soc_con[cnt].tip_sockaddr.sa_data,
302 soc_con[cnt].tip_string,
303 sizeof(soc_con[cnt].tip_sockaddr.sa_data));
304 if (connect(soc_con[cnt].dfe_sd,
305 &soc_con[cnt].tip_sockaddr,
306 sizeof(soc_con[cnt].tip_sockaddr)))
307 { /* if connect() fails assume TIP not yet started */
308/*------------------------------------------------------------ AF_UNIX EXEC */
309 int pid;
310 int statusp;
311 char *arg0;
312
313 arg0 = strrchr(soc_con[cnt].tip_exe,'/');
314
315 if (arg0)
316 arg0++;
317 else
318 arg0 = soc_con[cnt].tip_exe;
319
320 pid = vfork();
321
322 if (pid == 0) /* Child */
323 {
324 execlp(soc_con[cnt].tip_exe,
325 arg0,
326 soc_con[cnt].domain_string,
327 soc_con[cnt].tip_string,
328 NULL);
329 _exit(1);
330 }
331
332 if (waitpid(pid, &statusp, WNOHANG))
333 {
334 sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP");
335 dfe_errno = UDIErrorCantStartTIP;
336 goto tip_failure;
337 }
338
339 pos = 3;
340 for (pos = 3; pos > 0; pos--)
341 {
342 if (!connect(soc_con[cnt].dfe_sd,
343 &soc_con[cnt].tip_sockaddr,
344 sizeof(soc_con[cnt].tip_sockaddr)))
345 break;
346 sleep(1);
347 }
348
349 if (pos == 0)
350 {
351 sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s",
352 strerror (errno));
353 dfe_errno = UDIErrorCantConnect;
354 goto tip_failure;
355 }
356 }
357 }
358/*--------------------------------------------------------- AF_INET CONNECT */
359 else if (domain == AF_INET)
360 {
361 fprintf(stderr,
362 "DFE-ipc WARNING, need to have first started remote TIP");
363
364 soc_con[cnt].tip_sockaddr_in.sin_family = domain;
365 soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr =
366 inet_addr(soc_con[cnt].tip_string);
367 if (soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr == -1)
368 {
369 tip_info_p = gethostbyname(soc_con[cnt].tip_string);
370 if (tip_info_p == NULL)
371 {
372 sprintf(dfe_errmsg,"DFE-ipc ERROR, No such host %s",
373 soc_con[cnt].tip_string);
374 dfe_errno = UDIErrorNoSuchConnection;
375 goto tip_failure;
376 }
377 memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
378 tip_info_p->h_addr,
379 tip_info_p->h_length);
380 }
381 soc_con[cnt].tip_sockaddr_in.sin_port
382 = htons(atoi(soc_con[cnt].tip_exe));
383
384 if (connect(soc_con[cnt].dfe_sd,
385 (struct sockaddr *) &soc_con[cnt].tip_sockaddr_in,
386 sizeof(soc_con[cnt].tip_sockaddr_in)))
387 {
388 sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ",
389 strerror (errno));
390 dfe_errno = UDIErrorCantConnect;
391 goto tip_failure;
392 }
393 }
394/*------------------------------------------------------------- TIP CONNECT */
395 if (cnt == 0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE);
396
397tip_connect:
398 current = cnt;
399 session[*Session].in_use = TRUE; /* session id is now in use */
400
401 udr_errno = 0;
402 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
403 udr_UDIInt32(udrs, &service_id);
404
405 DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
406 udr_UDIUInt32(udrs, &DFEIPCId);
407
408 udr_string(udrs, tip_main_string);
409
410 udr_sendnow(udrs);
411
412 udrs->udr_op = UDR_DECODE; /* recv all "out" parameters */
413 udr_UDIUInt32(udrs, &TIPIPCId);
414 if ((TIPIPCId & 0xfff) < version_c)
415 sprintf(dfe_errmsg, "DFE-ipc: Obsolete TIP Specified");
416
417 udr_UDIInt32(udrs, &soc_con[cnt].tip_pid);
418
419 udr_UDISessionId(udrs, &session[*Session].tip_id);
420
421 udr_UDIError(udrs, &dfe_errno);
422 if (dfe_errno > 0) UDIKill(*Session, 0);
423
424 return dfe_errno;
425
426tip_failure:
427
428 soc_con[cnt].in_use = FALSE;
429 session[*Session].in_use = FALSE;
430/* XXX - Should also close dfe_sd, but not sure what to do if muxed */
431 return dfe_errno;
432}
433
434/************************************************************** UDI_Disconnect
435* UDIDisconnect() should be called before exiting the
436* DFE to ensure proper shut down of the TIP.
437*/
438UDIError UDIDisconnect(Session, Terminate)
439UDISessionId Session;
440UDIBool Terminate;
441{
442 int cnt;
443 UDIInt32 service_id = UDIDisconnect_c;
444 if(Session < 0 || Session > MAX_SESSIONS)
445 {
446 sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
447 return UDIErrorNoSuchConfiguration;
448 }
449 udr_errno = 0;
450 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
451 udr_UDIInt32(udrs, &service_id);
452 udr_UDISessionId(udrs, &session[Session].tip_id);
453 udr_UDIBool(udrs, &Terminate);
454 udr_sendnow(udrs);
455
456 session[Session].in_use = FALSE; /* session id is now free */
457 for (cnt=0; cnt < MAX_SESSIONS; cnt++)
458 if(session[cnt].in_use
459 && session[cnt].soc_con_p == session[Session].soc_con_p
460 ) break;
461 if(cnt >= MAX_SESSIONS) /* test if socket not multiplexed */
462 if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
463 {
464 sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
465 return UDIErrorIPCInternal;
466 }
467 else
468 session[Session].soc_con_p->in_use = 0;
469
470 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
471 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
472 return dfe_errno;
473}
474
475/******************************************************************** UDI_KILL
476* UDIKill() is used to send a signal to the TIP.
477* This is a private IPC call.
478*/
479UDIError UDIKill(Session, Signal)
480UDISessionId Session;
481UDIInt32 Signal;
482{
483 int cnt;
484 UDIInt32 service_id = UDIKill_c;
485 if(Session < 0 || Session > MAX_SESSIONS)
486 {
487 sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
488 return UDIErrorNoSuchConfiguration;
489 }
490 udr_errno = 0;
491 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
492 udr_UDIInt32(udrs, &service_id);
493 udr_UDISessionId(udrs, &session[Session].tip_id);
494 udr_UDIInt32(udrs, &Signal);
495 udr_sendnow(udrs);
496
497 session[Session].in_use = FALSE; /* session id is now free */
498 for (cnt=0; cnt < MAX_SESSIONS; cnt++)
499 if(session[cnt].in_use
500 && session[cnt].soc_con_p == session[Session].soc_con_p
501 ) break;
502 if(cnt < MAX_SESSIONS) /* test if socket not multiplexed */
503 if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
504 {
505 sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
506 return UDIErrorIPCInternal;
507 }
508 else
509 session[Session].soc_con_p->in_use = 0;
510
511 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
512 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
513 return dfe_errno;
514}
515
516/************************************************** UDI_Set_Current_Connection
517* If you are connected to multiple TIPs, you can change
518* TIPs using UDISetCurrentConnection().
519*/
520UDIError UDISetCurrentConnection(Session)
521UDISessionId Session;
522{
523 UDIInt32 service_id = UDISetCurrentConnection_c;
524
525 if(Session < 0 || Session > MAX_SESSIONS)
526 return UDIErrorNoSuchConfiguration;
527 if(!session[Session].in_use) /* test if not in use yet */
528 return UDIErrorNoSuchConnection;
529
530 current = Session;
531 /* change socket or multiplex the same socket */
532 udrs->sd = session[Session].soc_con_p->dfe_sd;
533
534 udr_errno = 0;
535 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
536 udr_UDIInt32(udrs, &service_id);
537 udr_UDISessionId(udrs, &session[Session].tip_id);
538 udr_sendnow(udrs);
539 if(udr_errno) return udr_errno;
540
541 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
542 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
543 return dfe_errno;
544}
545
546/************************************************************ UDI_Capabilities
547* The DFE uses UDICapabilities() to both inform the TIP
548* of what services the DFE offers and to inquire of the
549* TIP what services the TIP offers.
550*/
551UDIError UDICapabilities(TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId,
552 TIPIPCId, TIPString)
553UDIUInt32 *TIPId; /* out */
554UDIUInt32 *TargetId; /* out */
555UDIUInt32 DFEId; /* in */
556UDIUInt32 DFE; /* in */
557UDIUInt32 *TIP; /* out */
558UDIUInt32 *DFEIPCId; /* out */
559UDIUInt32 *TIPIPCId; /* out */
560char *TIPString; /* out */
561{
562 UDIInt32 service_id = UDICapabilities_c;
563 int size;
564
565 udr_errno = 0;
566 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
567 udr_UDIInt32(udrs, &service_id);
568 udr_UDIInt32(udrs, &DFEId);
569 udr_UDIInt32(udrs, &DFE);
570 udr_sendnow(udrs);
571 if(udr_errno) return udr_errno;
572
573 udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
574 udr_UDIInt32(udrs, TIPId);
575 udr_UDIInt32(udrs, TargetId);
576 udr_UDIInt32(udrs, TIP);
577 udr_UDIInt32(udrs, DFEIPCId);
578 *DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
579 udr_UDIInt32(udrs, TIPIPCId);
580 udr_string(udrs, sbuf);
581 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
582 size = strlen(sbuf);
583 if(size +1 > 80) return -1; /* test if sufficient space */
584 strcpy(TIPString, sbuf);
585 return dfe_errno;
586}
587
588/********************************************************** UDI_Enumerate_TIPs
589* Used by the DFE to enquire about available TIP
590* connections.
591*/
592UDIError UDIEnumerateTIPs(UDIETCallback)
593 int (*UDIETCallback)(); /* In -- function to callback */
594{
595 FILE *fp;
596
597 fp = fopen(config_file, "r");
598 if(fp == NULL)
599 return UDIErrorCantOpenConfigFile;
600 while(fgets( sbuf, SBUF_SIZE, fp))
601 if(UDIETCallback( sbuf) == UDITerminateEnumeration)
602 break;
603 fclose( fp);
604 return UDINoError; /* return success */
605}
606
607/*********************************************************** UDI_GET_ERROR_MSG
608* Some errors are target specific. They are indicated
609* by a negative error return value. The DFE uses
610* UDIGetErrorMsg() to get the descriptive text for
611* the error message which can then be displayed to
612* the user.
613*/
614UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone)
615UDIError error_code; /* In */
616UDISizeT msg_len; /* In -- allowed message space */
617char* msg; /* Out -- length of message*/
618UDISizeT *CountDone; /* Out -- number of characters */
619{
620 UDIInt32 service_id = UDIGetErrorMsg_c;
621 int size;
622
623 udr_errno = 0;
624 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
625 udr_UDIInt32(udrs, &service_id);
626 udr_UDIError(udrs, &error_code);
627 udr_UDISizeT(udrs, &msg_len);
628 udr_sendnow(udrs);
629 if(udr_errno) return udr_errno;
630
631 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
632 udr_string(udrs, sbuf);
633 udr_UDISizeT(udrs, CountDone);
634 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
635 size = strlen(sbuf);
636 if(size +1 > msg_len) return -1; /* test if sufficient space */
637 strcpy(msg, sbuf);
638 return dfe_errno;
639}
640
641/******************************************************* UDI_GET_TARGET_CONFIG
642* UDIGetTargetConfig() gets information about the target.
643*/
644UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions,
645 NumberOfChips)
646UDIMemoryRange KnownMemory[]; /* Out */
647UDIInt *NumberOfRanges; /* In and Out */
648UDIUInt32 ChipVersions[]; /* Out */
649UDIInt *NumberOfChips; /* In and Out */
650{
651 UDIInt32 service_id = UDIGetTargetConfig_c;
652 int cnt;
653 int MaxOfRanges = *NumberOfRanges;
654
655 udr_errno = 0;
656 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
657 udr_UDIInt32(udrs, &service_id);
658 udr_UDIInt(udrs, NumberOfRanges);
659 udr_UDIInt(udrs, NumberOfChips);
660 udr_sendnow(udrs);
661 if(udr_errno) return udr_errno;
662
663 udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
664 for(cnt=1; cnt <= MaxOfRanges; cnt++)
665 udr_UDIMemoryRange(udrs, &KnownMemory[cnt-1]);
666 udr_UDIInt(udrs, NumberOfRanges);
667 udr_UDIInt(udrs, NumberOfChips);
668 for(cnt=1; cnt <= *NumberOfChips; cnt++)
669 udr_UDIUInt32(udrs, &ChipVersions[cnt -1]);
670 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
671 return dfe_errno;
672}
673
674/********************************************************** UDI_CREATE_PRCOESS
675* UDICreateProcess() tells the target OS that a
676* process is to be created and gets a PID back unless
677* there is some error.
678*/
679UDIError UDICreateProcess(pid)
680UDIPId *pid; /* out */
681{
682 UDIInt32 service_id = UDICreateProcess_c;
683
684 udr_errno = 0;
685 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
686 udr_UDIInt32(udrs, &service_id);
687 udr_sendnow(udrs);
688 if(udr_errno) return udr_errno;
689
690 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
691 udr_UDIPId(udrs, pid);
692 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
693 return dfe_errno;
694}
695
696/***************************************************** UDI_Set_Current_Process
697* UDISetCurrentProcess uses a pid supplied by
698* UDICreateProcess and sets it as the default for all
699* udi calls until a new one is set. A user of a
700*/
701UDIError UDISetCurrentProcess (pid)
702UDIPId pid; /* In */
703{
704 UDIInt32 service_id = UDISetCurrentProcess_c;
705
706 udr_errno = 0;
707 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
708 udr_UDIInt32(udrs, &service_id);
709 udr_UDIPId(udrs, &pid);
710 udr_sendnow(udrs);
711 if(udr_errno) return udr_errno;
712
713 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
714 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
715 return dfe_errno;
716}
717
718/****************************************************** UDI_INITIALISE_PROCESS
719* UDIInitializeProcess() prepare process for
720* execution. (Reset processor if process os processor).
721*/
722UDIError UDIInitializeProcess( ProcessMemory, NumberOfRanges, EntryPoint,
723 StackSizes, NumberOfStacks, ArgString)
724UDIMemoryRange ProcessMemory[]; /* In */
725UDIInt NumberOfRanges; /* In */
726UDIResource EntryPoint; /* In */
727CPUSizeT *StackSizes; /* In */
728UDIInt NumberOfStacks; /* In */
729char *ArgString; /* In */
730{
731 UDIInt32 service_id = UDIInitializeProcess_c;
732 int cnt;
733
734 udr_errno = 0;
735 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
736 udr_UDIInt32(udrs, &service_id);
737 udr_UDIInt(udrs, &NumberOfRanges);
738 for(cnt = 0; cnt < NumberOfRanges; cnt++)
739 udr_UDIMemoryRange(udrs, &ProcessMemory[cnt] );
740 udr_UDIResource(udrs, &EntryPoint);
741 udr_UDIInt(udrs, &NumberOfStacks);
742 for(cnt = 0; cnt < NumberOfStacks; cnt++)
743 udr_CPUSizeT(udrs, &StackSizes[cnt]);
744 udr_string(udrs, ArgString);
745 udr_sendnow(udrs);
746 if(udr_errno) return udr_errno;
747
748 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
749 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
750 return dfe_errno;
751}
752
753/********************************************************* UDI_DESTROY_PROCESS
754* UDIDestroyProcess() frees a process resource
755* previously created by UDICreateProcess().
756*/
757UDIError UDIDestroyProcess(pid)
758UDIPId pid; /* in */
759{
760 UDIInt32 service_id = UDIDestroyProcess_c;
761
762 udr_errno = 0;
763 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
764 udr_UDIInt32(udrs, &service_id);
765 udr_UDIPId(udrs, &pid);
766 udr_sendnow(udrs);
767 if(udr_errno) return udr_errno;
768
769 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
770 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
771 return dfe_errno;
772}
773
774/****************************************************************** UDI_READ
775* UDIRead() reads a block of objects from a target
776* address space to host space.
777*/
778
779UDIError UDIRead (from, to, count, size, count_done, host_endian)
780UDIResource from; /* in - source address on target */
781UDIHostMemPtr to; /* out - destination address on host */
782UDICount count; /* in -- count of objects to be transferred */
783UDISizeT size; /* in -- size of each object */
784UDICount *count_done; /* out - count actually transferred */
785UDIBool host_endian; /* in -- flag for endian information */
786{
787 UDIInt32 service_id = UDIRead_c;
788 int byte_count;
789
790 udr_errno = 0;
791 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
792 udr_UDIInt32(udrs, &service_id);
793 udr_UDIResource(udrs, &from);
794 udr_UDICount(udrs, &count);
795 udr_UDISizeT(udrs, &size);
796 udr_UDIBool(udrs, &host_endian);
797 udr_sendnow(udrs);
798 if(udr_errno) return udr_errno;
799
800 udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
801 udr_UDICount(udrs, count_done);
802 byte_count = (*count_done) * size;
803 if(*count_done > 0 && *count_done <= count)
804 udr_bytes(udrs, to, byte_count);
805 if(udr_errno) return udr_errno;
806 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
807 return dfe_errno;
808}
809
810/****************************************************************** UDI_WRITE
811* UDIWrite() writes a block of objects from host
812* space to a target address+space.
813*/
814UDIError UDIWrite( from, to, count, size, count_done, host_endian )
815UDIHostMemPtr from; /* in -- source address on host */
816UDIResource to; /* in -- destination address on target */
817UDICount count; /* in -- count of objects to be transferred */
818UDISizeT size; /* in -- size of each object */
819UDICount *count_done; /* out - count actually transferred */
820UDIBool host_endian; /* in -- flag for endian information */
821{
822 UDIInt32 service_id = UDIWrite_c;
823 int byte_count = count * size;
824
825 udr_errno = 0;
826 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
827 udr_UDIInt32(udrs, &service_id);
828 udr_UDIResource(udrs, &to);
829 udr_UDICount(udrs, &count);
830 udr_UDISizeT(udrs, &size);
831 udr_UDIBool(udrs, &host_endian);
832 udr_bytes(udrs, from, byte_count);
833 udr_sendnow(udrs);
834 if(udr_errno) return udr_errno;
835
836 udrs->udr_op = UDR_DECODE; /* receive all "out" paramters */
837 udr_UDICount(udrs, count_done);
838 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
839 return dfe_errno;
840}
841
842/******************************************************************** UDI_COPY
843* UDICopy() copies a block of objects from one target
844* get address/space to another target address/space.
845*/
846UDIError UDICopy(from, to, count, size, count_done, direction )
847UDIResource from; /* in -- destination address on target */
848UDIResource to; /* in -- source address on target */
849UDICount count; /* in -- count of objects to be transferred */
850UDISizeT size; /* in -- size of each object */
851UDICount *count_done; /* out - count actually transferred */
852UDIBool direction; /* in -- high-to-low or reverse */
853{
854 UDIInt32 service_id = UDICopy_c;
855
856 udr_errno = 0;
857 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
858 udr_UDIInt32(udrs, &service_id);
859 udr_UDIResource(udrs, &from);
860 udr_UDIResource(udrs, &to);
861 udr_UDICount(udrs, &count);
862 udr_UDISizeT(udrs, &size);
863 udr_UDIBool(udrs, &direction);
864 udr_sendnow(udrs);
865 if(udr_errno) return udr_errno;
866
867 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
868 udr_UDICount(udrs, count_done);
869 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
870 return dfe_errno;
871}
872
873/***************************************************************** UDI_EXECUTE
874* UDIExecute() continues execution of the default
875* process from the current PC.
876*/
877UDIError UDIExecute()
878{
879 UDIInt32 service_id = UDIExecute_c;
880
881 udr_errno = 0;
882 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
883 udr_UDIInt32(udrs, &service_id);
884 udr_sendnow(udrs);
885 if(udr_errno) return udr_errno;
886
887 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
888 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
889 return dfe_errno;
890}
891
892/******************************************************************** UDI_STEP
893* UDIStep() specifies a number of "instruction"
894* steps to make.
895*/
896UDIError UDIStep(steps, steptype, range)
897UDIUInt32 steps; /* in -- number of steps */
898UDIStepType steptype; /* in -- type of stepping to be done */
899UDIRange range; /* in -- range if StepInRange is TRUE */
900{
901 UDIInt32 service_id = UDIStep_c;
902
903 udr_errno = 0;
904 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
905 udr_UDIInt32(udrs, &service_id);
906 udr_UDIInt32(udrs, &steps);
907 udr_UDIStepType(udrs, &steptype);
908 udr_UDIRange(udrs, &range);
909 udr_sendnow(udrs);
910 if(udr_errno) return udr_errno;
911
912 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
913 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
914 return dfe_errno;
915}
916
917/******************************************************************** UDI_STOP
918* UDIStop() stops the default process
919*/
920UDIVoid UDIStop()
921{
922 if (strcmp(session[current].soc_con_p->domain_string, "AF_UNIX") == 0)
923 kill(session[current].soc_con_p->tip_pid, SIGINT);
924 else
925 udr_signal(udrs);
926
927/* XXX - should clean up session[] and soc_con[] structs here as well... */
928
929 return;
930}
931
932/******************************************************************** UDI_WAIT
933* UDIWait() returns the state of the target procesor.
934*/
935UDIError UDIWait(maxtime, pid, stop_reason)
936UDIInt32 maxtime; /* in -- maximum time to wait for completion */
937UDIPId *pid; /* out -- pid of process which stopped if any */
938UDIUInt32 *stop_reason; /* out -- PC where process stopped */
939{
940 UDIInt32 service_id = UDIWait_c;
941
942 udr_errno = 0;
943 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
944 udr_UDIInt32(udrs, &service_id);
945 udr_UDIInt32(udrs, &maxtime);
946 udr_sendnow(udrs);
947 if(udr_errno) return udr_errno;
948
949 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
950 udr_UDIPId(udrs, pid);
951 udr_UDIUInt32(udrs, stop_reason);
952 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
953 return dfe_errno;
954}
955
956/********************************************************** UDI_SET_BREAKPOINT
957* UDISetBreakpoint() sets a breakpoint at an adress
958* and uses the passcount to state how many
959* times that instruction should be hit before the
960* break occurs.
961*/
962UDIError UDISetBreakpoint (addr, passcount, type, break_id)
963UDIResource addr; /* in -- where breakpoint gets set */
964UDIInt32 passcount; /* in -- passcount for breakpoint */
965UDIBreakType type; /* in -- breakpoint type */
966UDIBreakId *break_id; /* out - assigned break id */
967{
968 UDIInt32 service_id = UDISetBreakpoint_c;
969
970 udr_errno = 0;
971 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
972 udr_UDIInt32(udrs, &service_id);
973 udr_UDIResource(udrs, &addr);
974 udr_UDIInt32(udrs, &passcount);
975 udr_UDIBreakType(udrs, &type);
976 udr_sendnow(udrs);
977 if(udr_errno) return udr_errno;
978
979 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
980 udr_UDIBreakId(udrs, break_id);
981 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
982 return dfe_errno;
983}
984
985/******************************************************** UDI_QUERY_BREAKPOINT
986*/
987UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count)
988UDIBreakId break_id; /* in -- assigned break id */
989UDIResource *addr; /* out - where breakpoint was set */
990UDIInt32 *passcount; /* out - trigger passcount for breakpoint */
991UDIBreakType *type; /* out - breakpoint type */
992UDIInt32 *current_count; /* out - current count for breakpoint */
993{
994 UDIInt32 service_id = UDIQueryBreakpoint_c;
995
996 udr_errno = 0;
997 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
998 udr_UDIInt32(udrs, &service_id);
999 udr_UDIBreakId(udrs, &break_id);
1000 udr_sendnow(udrs);
1001 if(udr_errno) return udr_errno;
1002
1003 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1004 udr_UDIResource(udrs, addr);
1005 udr_UDIInt32(udrs, passcount);
1006 udr_UDIBreakType(udrs, type);
1007 udr_UDIInt32(udrs, current_count);
1008 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1009 return dfe_errno;
1010}
1011
1012/******************************************************** UDI_CLEAR_BREAKPOINT
1013* UDIClearBreakpoint() is used to clear a breakpoint.
1014*/
1015UDIError UDIClearBreakpoint (break_id)
1016UDIBreakId break_id; /* in -- assigned break id */
1017{
1018 UDIInt32 service_id = UDIClearBreakpoint_c;
1019
1020 udr_errno = 0;
1021 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1022 udr_UDIInt32(udrs, &service_id);
1023 udr_UDIBreakId(udrs, &break_id);
1024 udr_sendnow(udrs);
1025 if(udr_errno) return udr_errno;
1026
1027 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1028 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1029 return dfe_errno;
1030}
1031
1032/************************************************************** UDI_GET_STDOUT
1033* UDIGetStdout() is called when a call to
1034* UDIWait() indicates there is STD output data ready.
1035*/
1036UDIError UDIGetStdout(buf, bufsize, count_done)
1037UDIHostMemPtr buf; /* out -- buffer to be filled */
1038UDISizeT bufsize; /* in -- buffer size in bytes */
1039UDISizeT *count_done; /* out -- number of bytes written to buf */
1040{
1041 UDIInt32 service_id = UDIGetStdout_c;
1042
1043 udr_errno = 0;
1044 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1045 udr_UDIInt32(udrs, &service_id);
1046 udr_UDISizeT(udrs, &bufsize);
1047 udr_sendnow(udrs);
1048 if(udr_errno) return udr_errno;
1049
1050 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1051 udr_UDISizeT(udrs, count_done);
1052 udr_bytes(udrs, buf, *count_done);
1053 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1054 return dfe_errno;
1055}
1056
1057/************************************************************** UDI_GET_STDERR
1058* UDIGetStderr() is called when a call to
1059* UDIWait() indicates there is STDERR output data ready
1060*/
1061UDIError UDIGetStderr(buf, bufsize, count_done)
1062UDIHostMemPtr buf; /* out -- buffer to be filled */
1063UDISizeT bufsize; /* in -- buffer size in bytes */
1064UDISizeT *count_done; /* out -- number of bytes written to buf */
1065{
1066 UDIInt32 service_id = UDIGetStderr_c;
1067
1068 udr_errno = 0;
1069 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1070 udr_UDIInt32(udrs, &service_id);
1071 udr_UDISizeT(udrs, &bufsize);
1072 udr_sendnow(udrs);
1073 if(udr_errno) return udr_errno;
1074
1075 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1076 udr_UDISizeT(udrs, count_done);
1077 udr_bytes(udrs, buf, *count_done);
1078 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1079 return dfe_errno;
1080}
1081
1082/*************************************************************** UDI_PUT_STDIN
1083* UDIPutStdin() is called whenever the DFE wants to
1084* deliver an input character to the TIP.
1085*/
1086UDIError UDIPutStdin (buf, count, count_done)
1087UDIHostMemPtr buf; /* in -- buffer to be filled */
1088UDISizeT count; /* in -- buffer size in bytes */
1089UDISizeT *count_done; /* out - number of bytes written to buf */
1090{
1091 UDIInt32 service_id = UDIPutStdin_c;
1092
1093 udr_errno = 0;
1094 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1095 udr_UDIInt32(udrs, &service_id);
1096 udr_UDISizeT(udrs, &count);
1097 udr_bytes(udrs, buf, count);
1098 udr_sendnow(udrs);
1099 if(udr_errno) return udr_errno;
1100
1101 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1102 udr_UDISizeT(udrs, count_done);
1103 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1104 return dfe_errno;
1105}
1106
1107/************************************************************** UDI_STDIN_MODE
1108* UDIStdinMode() is used to change the mode that chazcters
1109* are fetched from the user.
1110*/
1111UDIError UDIStdinMode(mode)
1112UDIMode *mode; /* out - */
1113{
1114 UDIInt32 service_id = UDIStdinMode_c;
1115
1116 udr_errno = 0;
1117 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1118 udr_UDIInt32(udrs, &service_id);
1119 udr_sendnow(udrs);
1120 if(udr_errno) return udr_errno;
1121
1122 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1123 udr_UDIMode(udrs, mode);
1124 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1125 return dfe_errno;
1126}
1127
1128/*************************************************************** UDI_PUT_TRANS
1129* UDIPutTrans() is used to feed input to the passthru mode.
1130*/
1131UDIError UDIPutTrans (buf, count, count_done)
1132UDIHostMemPtr buf; /* in -- buffer address containing input data */
1133UDISizeT count; /* in -- number of bytes in buf */
1134UDISizeT *count_done; /* out-- number of bytes transfered */
1135{
1136 UDIInt32 service_id = UDIPutTrans_c;
1137
1138 udr_errno = 0;
1139 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1140 udr_UDIInt32(udrs, &service_id);
1141 udr_UDISizeT(udrs, &count);
1142 udr_bytes(udrs, buf, count);
1143 udr_sendnow(udrs);
1144 if(udr_errno) return udr_errno;
1145
1146 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1147 udr_UDISizeT(udrs, count_done);
1148 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1149 return dfe_errno;
1150}
1151
1152/*************************************************************** UDI_GET_TRANS
1153* UDIGetTrans() is used to get output lines from the
1154* passthru mode.
1155*/
1156UDIError UDIGetTrans (buf, bufsize, count_done)
1157UDIHostMemPtr buf; /* out -- buffer to be filled */
1158UDISizeT bufsize; /* in -- size of buf */
1159UDISizeT *count_done; /* out -- number of bytes in buf */
1160{
1161 UDIInt32 service_id = UDIGetTrans_c;
1162
1163 udr_errno = 0;
1164 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1165 udr_UDIInt32(udrs, &service_id);
1166 udr_UDISizeT(udrs, &bufsize);
1167 udr_sendnow(udrs);
1168 if(udr_errno) return udr_errno;
1169
1170 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1171 udr_UDISizeT(udrs, count_done);
1172 udr_bytes(udrs, buf, *count_done);
1173 udr_UDIError(udrs, &dfe_errno); /* get any TIP error */
1174 return dfe_errno;
1175}
1176
1177/************************************************************** UDI_Trans_Mode
1178* UDITransMode() is used to change the mode that the
1179* transparent routines operate in.
1180*/
1181UDIError UDITransMode(mode)
1182UDIMode *mode; /* out -- selected mode */
1183{
1184 UDIInt32 service_id = UDITransMode_c;
1185
1186 udr_errno = 0;
1187 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1188 udr_UDIInt32(udrs, &service_id);
1189 udr_UDIMode(udrs, mode);
1190 udr_sendnow(udrs);
1191 if(udr_errno) return udr_errno;
1192
1193 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1194 udr_UDIError(udrs, &dfe_errno);
1195 return dfe_errno;
1196}
1197
1198/******************************************************************** UDI_TEST
1199*/
1200UDIError UDITest( cnt, str_p, array)
1201UDISizeT cnt;
1202UDIHostMemPtr str_p;
1203UDIInt32 array[];
1204{
1205 UDIInt32 service_id = UDITest_c;
1206 UDIInt16 scnt = cnt;
1207 UDISizeT r_cnt;
1208 char buf[256];
1209
1210 udr_errno = 0;
1211 udrs->udr_op = UDR_ENCODE; /* send all "in" parameters */
1212 udr_UDIInt32(udrs, &service_id);
1213
1214 printf("send cnt=%d scnt=%d\n", cnt, scnt);
1215 udr_UDISizeT(udrs, &cnt);
1216 udr_UDIInt16(udrs, &scnt);
1217 printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
1218 array[0], array[1], array[2], array[3]);
1219 udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
1220 printf(" string=%s\n", str_p);
1221 udr_string(udrs, str_p);
1222 udr_sendnow(udrs);
1223 if(udr_errno)
1224 { fprintf(stderr, " DFE-ipc Send ERROR\n");
1225 return udr_errno;
1226 }
1227
1228 udrs->udr_op = UDR_DECODE; /* receive all "out" parameters */
1229 printf("recv ");
1230 udr_UDISizeT(udrs, &r_cnt);
1231 udr_UDIInt16(udrs, &scnt);
1232 printf(" rcnt=%d scnt=%d\n", r_cnt, scnt);
1233 udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
1234
1235 printf(" array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
1236 array[0], array[1], array[2], array[3]);
1237 udr_string(udrs, str_p);
1238 printf(" string=%s\n", str_p);
1239
1240 udr_UDIError(udrs, &dfe_errno);
1241 return dfe_errno;
1242}
1243
1244
1245
1246UDIUInt32 UDIGetDFEIPCId()
1247{
1248 return ((company_c << 16) + (product_c << 12) + version_c);
1249}
1250#endif /* __GO32__ */
GDB Binutils - Deliverables
This page took 0.118762 seconds and 4 git commands to generate.