Subversion Repositories or1k

/******************************************************************************

* Copyright 1991 Advanced Micro Devices, Inc.

*

* This software is the property of Advanced Micro Devices, Inc  (AMD)  which

* specifically  grants the user the right to modify, use and distribute this

* software provided this notice is not removed or altered.  All other rights

* are reserved by AMD.

*

* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS

* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL

* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR

* USE OF THIS SOFTWARE.

*

* So that all may benefit from your experience, please report  any  problems

* or  suggestions about this software to the 29K Technical Support Center at

* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or

* 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.

*

* Advanced Micro Devices, Inc.

* 29K Support Products

* Mail Stop 573

* 5900 E. Ben White Blvd.

* Austin, TX 78741

* 800-292-9263 (US)

*****************************************************************************

*/

static  char soc2udip_c[]="@(#)soc2udip.c       2.14  Daniel Mann";

static char soc2udip_c_AMD[]="@(#)soc2udip.c    3.2, AMD";

/*

*       This module converts UDI socket messages

*       into UDI Procedural calls.

*       It is used by TIP server processes

********************************************************************** HISTORY

*/

#include <stdio.h>

#include <stdio.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/file.h>

#ifdef __hpux

#else

/* #include <sys/sockio.h> */

#endif

#include <sys/fcntl.h>

#include <netdb.h>

#include <netinet/in.h>

#include <signal.h>

#include <setjmp.h>

#include "udiproc.h"

#include "udisoc.h"

extern  int     errno;

/* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE

*/

#define version_c 0x121         /* TIP-IPC version id */

#define PORT_NUM        7000

#define MAX_ERRNO       1

#define SOC_BUF_SIZE    4* 1024 /* size of socket comms buffer */

#define SBUF_SIZE       500     /* size of string buffer */

/* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS

*/

/* local dec/defs. which are not in a .h   file *************** LOCAL DEC/DEFS

*/

LOCAL UDIError  tip_errno;

LOCAL int       tip_sd;

LOCAL int       connect_count = 0;

LOCAL int       ns;

LOCAL int       getlength;

LOCAL struct sockaddr getname;

LOCAL UDR       udr;

LOCAL UDR*      udrs = &udr;

LOCAL char      sbuf[SBUF_SIZE];        /* String handler buffer */

LOCAL char*     tip_errmsg[/*MAX_ERRNO*/] =

{ "Trying to present non negative error number to TIP "

};

LOCAL sig_handler(sig, code, scp, addr)

int     sig;

int     code;

struct  sigcontext *scp;

char    *addr;

{

    if(sig == SIGUSR1)

    {

        UDIStop();

        return;

    }

    if(sig == SIGIO )

    {

        return;

    }

    if(sig == SIGURG)

    {

        UDIStop();

        return;

    }

    if(sig != -1)fprintf(stderr,

                        "\nTIP-ipc caught a signal %d, socket shutdown\n",sig);

#if 0

    else fprintf(stderr,"\nTIP-ipc, socket shutdown\n");

#endif

    sigblock(sigmask(SIGIO));

    if(shutdown(tip_sd, 2))

        fprintf(stderr, "TIP-ipc WARNING: socket shutdown failed");

    if(udrs->domain == AF_UNIX)

        if(unlink(udrs->soc_name))

           fprintf(stderr,

                "TIP-ipc WARNING: failed to unlink %s\n",udrs->soc_name);

    exit(0);

}

/*********************************************************************** MAIN

*/

main(argc, argv)

int     argc;

char*   argv[];

{

    char        *domain_string = argv[1];

    char        *tip_string = argv[2];

    struct sockaddr_in  dfe_sockaddr;

    struct sockaddr_in  tip_sockaddr_in;

    struct sockaddr     tip_sockaddr;

    struct hostent      *tip_info_p;

    int         dfe_addrlen;

    int         domain;

    int         pgrp;

#define NAME_LEN 20

    char        tip_host[NAME_LEN];

    pgrp = getpid();

    setpgrp(0, pgrp);            /* TIP not in same pgrp as DFE */

    if(argc < 3)

    {

        TIPPrintUsage(argv[0]);

        fprintf(stderr,"TIP UDI-IPC Version %d.%d.%d\n",

                 (version_c&0xf00)>>8, (version_c&0x0f0)>>4, (version_c&0x00f));

        exit(1);

    }

    signal(SIGINT, sig_handler);

    signal(SIGKILL, sig_handler);

    signal(SIGQUIT, sig_handler);

    signal(SIGTERM, sig_handler);

    signal(SIGSEGV, sig_handler);

    signal(SIGURG, sig_handler);

    signal(SIGIO, sig_handler);

    signal(SIGUSR1, sig_handler);

/*----------------------------------------------------------------- SOCKET */

    if(!strcmp(domain_string, "AF_UNIX"))

        domain = AF_UNIX;

    else if(!strcmp(domain_string, "AF_INET"))

        domain = AF_INET;

    else

    {   fprintf(stderr, " TIP-ipc ERROR: address family not known\n");

        exit(1);

    }

    tip_sd = socket(domain, SOCK_STREAM, 0);

    if (tip_sd == -1 )

    {   perror(" TIP-ipc ERROR, server socket() call failed");

        sig_handler(-1);

    }

/*------------------------------------------------------------------- BIND */

    if(domain==AF_UNIX)

    {

        memset( (char*)&tip_sockaddr, 0, sizeof(tip_sockaddr));

        tip_sockaddr.sa_family = domain;

        bcopy(tip_string, tip_sockaddr.sa_data, strlen(tip_string));

        if (bind(tip_sd, &tip_sockaddr, sizeof(tip_sockaddr)) )

        {   perror("TIP-ipc WARNING, server bind() failed");

        }

    }

    else if(domain == AF_INET)

    {

        if(gethostname(tip_host, NAME_LEN))

        {   fprintf(stderr,"TIP-ipc ERROR, unable to get TIP host name");

            exit(1);

        }

        memset( (char*)&tip_sockaddr_in, 0, sizeof(tip_sockaddr_in));

        tip_sockaddr_in.sin_family = domain;

        tip_sockaddr_in.sin_family = AF_INET;

        tip_sockaddr_in.sin_addr.s_addr = inet_addr(tip_host);

        if( tip_sockaddr_in.sin_addr.s_addr == -1)

        {

            tip_info_p = gethostbyname(tip_host);       /* use host name */

            if( tip_info_p == NULL)

            {  fprintf(stderr," TIP-ipc ERROR, %s not found in /etc/hosts\n",

                        tip_host);

               exit(1);

            }

            bcopy(tip_info_p->h_addr, (char *) &tip_sockaddr_in.sin_addr,

                tip_info_p->h_length);

        }

        tip_sockaddr_in.sin_port = htons(atoi(tip_string));

        if (bind(tip_sd, &tip_sockaddr_in, sizeof(tip_sockaddr_in)))

        {   perror(" TIP-ipc WARNING, server bind() failed");

        }

    }

/*----------------------------------------------------------------- LISTEN */

    if(listen(tip_sd,1))

    {   perror(" TIP-ipc ERROR, server listen failed");

        sig_handler(-1);

    }

/*----------------------------------------------------------------- ACCEPT */

    while(1)

    {   while(1)

        {   dfe_addrlen = sizeof(dfe_sockaddr);

            ns =accept(tip_sd, &dfe_sockaddr, &dfe_addrlen);

            if(ns  == -1)

            {   if(errno == EINTR) continue;

                perror(" TIP-ipc ERROR, server accept call");

                sig_handler(-1);

            }

            else break;

        }

        errno = 0;

        if(domain == AF_INET)

        {

#ifdef __hpux

#else

            if(fcntl(ns, F_SETOWN, getpid()) == -1)

            {   perror(" TIP-ipc, fcntl(..F_SETOWN) call: ");

                sig_handler(-1);

            }

            if(fcntl(ns, F_SETFL, FASYNC) == -1)

            {   perror(" TIP-ipc, fcntl(..FASYNC) call: ");

                sig_handler(-1);

            }

#endif

        }

        udr_create(udrs, ns, SOC_BUF_SIZE);

        udrs->domain = domain;

        udrs->soc_name = tip_string;

        service();

        udr_free(udrs);

   }

}

/******************************************************************** SERVICE

* Service each DFE request as they arrive.

*/

service()

{

 UDIInt32       service_id;     /* requested DFE service */

 for(;;)

 {

  tip_errno = 0;

  udrs->udr_op = UDR_DECODE;

  if(udr_UDIInt32(udrs, &service_id))

  { connect_count--;

    return -1;

  }

  switch(service_id)

  {

    default:

    {

        break;

    }

/*----------------------------------------------------------------- UDIConnect

*/

    case UDIConnect_c:

    {

        char*           Config;         /* in  -- identification string */

        UDISessionId    Session;        /* out -- session ID */

        int             tip_pid;        /* pid of TIP process */

        UDIUInt32       TIPIPCId;

        UDIUInt32       DFEIPCId;

        udr_UDIUInt32(udrs, &DFEIPCId); /* recv all "in" params */

        if ((DFEIPCId & 0xfff) < version_c) {

            fprintf(stderr, "TIP-ipc: Connect from obsolete DFE\n");

            sig_handler(-1);

        }

        udr_string(udrs, sbuf);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIConnect(sbuf, &Session);

        if( tip_errno <= UDINoError) connect_count++;

        TIPIPCId = (company_c << 16) + (product_c << 12) + version_c;

        udr_UDIUInt32(udrs, &TIPIPCId);

        tip_pid = getpid();

        udr_UDIInt32(udrs, &tip_pid);

        udr_UDISessionId(udrs, &Session);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*-------------------------------------------------------------- UDIDisconnect

*/

    case UDIDisconnect_c:

    {

        UDISessionId    Session;        /* In */

        UDIBool         Terminate;      /* In */

        udr_UDISessionId(udrs, &Session);

        udr_UDIBool(udrs, &Terminate);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIDisconnect(Session, Terminate);

        if( tip_errno == UDINoError) connect_count--;

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        if(Terminate != UDIContinueSession && connect_count == 0)

        {

#if 0

            fprintf(stderr, "\nTIP-ipc: DFE has disconnected all sessions\n");

#endif

            sig_handler(-1);

        }

        if(connect_count == 0) return;

        break;

    }

/*-------------------------------------------------------------------- UDIKill

*/

    case UDIKill_c:

    {

        UDISessionId    Session;        /* In */

        UDIInt32        signal; /* In */

        udr_UDISessionId(udrs, &Session);

        udr_UDIInt32(udrs, signal);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = 0;

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        if(connect_count == 0)

        {

#if 0

            fprintf(stderr, "\nTIP-ipc: DFE has disconnected all sessions\n");

#endif

            sig_handler(-1);

        }

        break;

    }

/*---------------------------------------------------- UDISetCurrentConnection

*/

    case UDISetCurrentConnection_c:

    {

        UDISessionId    Session;        /* In */

        udr_UDISessionId(udrs, &Session);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDISetCurrentConnection(Session);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*------------------------------------------------------------ UDICapabilities

*/

    case UDICapabilities_c:

    {

        UDIUInt32       TIPId;          /* out */

        UDIUInt32       TargetId;       /* out */

        UDIUInt32       DFEId;          /* in */

        UDIUInt32       DFE;            /* in */

        UDIUInt32       TIP;            /* out */

        UDIUInt32       DFEIPCId;       /* out */

        UDIUInt32       TIPIPCId;       /* out */

        char    *TIPString = sbuf;      /* out */

        strcpy(TIPString, "No TIP Capability string");

        udr_UDIUInt32(udrs, &DFEId);

        udr_UDIUInt32(udrs, &DFE);

        udrs->udr_op = UDR_ENCODE;              /* send all "out" paramters */

        tip_errno = UDICapabilities( &TIPId, &TargetId, DFEId, DFE,

                &TIP, &DFEIPCId, &TIPIPCId, TIPString);

        udr_UDIUInt32(udrs, &TIPId);

        udr_UDIUInt32(udrs, &TargetId);

        udr_UDIUInt32(udrs, &TIP);

        udr_UDIUInt32(udrs, &DFEIPCId);

        TIPIPCId = (company_c << 16) + (product_c << 12) + version_c;

        udr_UDIUInt32(udrs, &TIPIPCId);

        udr_string(udrs, TIPString);

        udr_UDIError(udrs, &tip_errno);         /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*------------------------------------------------------------- UDIGetErrorMsg

*/

    case UDIGetErrorMsg_c:

    {

        UDIError        error_code;     /* In */

        UDISizeT        msg_len;        /* In  -- allowed message space */

        char*           msg = sbuf;     /* Out -- length of message */

        UDISizeT        CountDone;      /* Out -- number of chars */

        strcpy(msg, "No TIP message");

        udr_UDIError(udrs, &error_code); /* recv all "in" parameters */

        udr_UDISizeT(udrs, &msg_len);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        if(error_code < 0)

        {

            if(SBUF_SIZE < msg_len) msg_len = SBUF_SIZE;

            tip_errno = UDIGetErrorMsg(error_code, msg_len, msg, &CountDone);

            udr_string(udrs, msg);

        }

        else

        {

            udr_string(udrs, tip_errmsg[0]);

            tip_errno = UDIErrorCantHappen;

            CountDone = strlen(tip_errmsg[0]);

        }

        udr_UDISizeT(udrs, &CountDone);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*--------------------------------------------------------- UDIGetTargetConfig

*/

    case UDIGetTargetConfig_c:

    {

        char*           KnownMemory_p;          /* Out */

        UDIInt          NumberOfRanges;         /* In and Out */

        char*           ChipVersions_p;         /* Out */

        UDIInt          NumberOfChips;          /* In and Out */

        int             cnt;

        int             MaxOfRanges;

        char*           NumberOfRanges_p;

        udr_UDIInt(udrs, &NumberOfRanges);      /* recieve all "in" params */

        MaxOfRanges = NumberOfRanges;

        udr_UDIInt(udrs, &NumberOfChips);

        udrs->udr_op = UDR_ENCODE;              /* send all "out" parameters */

        udr_work(udrs, &NumberOfRanges, 0);      /* nothing yet */

        KnownMemory_p = udr_getpos(udrs);

        udr_inline(udrs, MaxOfRanges * sizeof(UDIMemoryRange) );

        NumberOfRanges_p = udr_getpos(udrs);

        udr_inline(udrs, sizeof(UDIInt) );      /* space for NumberOfRanges */

        udr_inline(udrs, sizeof(UDIInt) );      /* space for NumberOfChips */

        ChipVersions_p = udr_getpos(udrs);

        tip_errno = UDIGetTargetConfig(KnownMemory_p, &NumberOfRanges,

                ChipVersions_p, &NumberOfChips);

        udr_setpos(udrs, NumberOfRanges_p);

        udr_UDIInt(udrs, &NumberOfRanges);

        udr_UDIInt(udrs, &NumberOfChips);

        udr_inline(udrs, NumberOfChips * sizeof(UDIInt32) );

        udr_UDIError(udrs, &tip_errno);

        udr_sendnow(udrs);

        break;

    }

/*----------------------------------------------------------- UDICreateProcess

*/

    case UDICreateProcess_c:

    {

        UDIPId  pid;            /* out */

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDICreateProcess(&pid);

        udr_UDIPId(udrs, &pid);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*------------------------------------------------------- UDIInitializeProcess

*/

    case UDIInitializeProcess_c:

    {

        char*           ProcessMemory_p;        /* In */

        UDIInt          NumberOfRanges;         /* In */

        UDIResource     EntryPoint;             /* In */

        char*           StackSizes_p;           /* In */

        UDIInt          NumberOfStacks;         /* In */

        char            *ArgString = sbuf;      /* In */

        int             cnt;

        udr_UDIInt(udrs, &NumberOfRanges); /* recv all "in" parameters */

        ProcessMemory_p = udr_getpos(udrs);

        udr_inline(udrs, NumberOfRanges * sizeof(UDIMemoryRange) );

        udr_UDIResource(udrs, &EntryPoint);

        udr_UDIInt(udrs, &NumberOfStacks);

        StackSizes_p = udr_getpos(udrs);

        udr_inline(udrs, NumberOfStacks * sizeof(CPUSizeT) );

        udr_string(udrs, ArgString);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIInitializeProcess( ProcessMemory_p, NumberOfRanges,

                EntryPoint, StackSizes_p, NumberOfStacks, ArgString);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*------------------------------------------------------- UDISetCurrentProcess

*/

    case UDISetCurrentProcess_c:

    {

        UDIPId   pid;                   /* in */

        udr_UDIPId(udrs, &pid);         /* recv all "in" parameters */

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDISetCurrentProcess(pid);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*---------------------------------------------------------- UDIDestroyProcess

*/

    case UDIDestroyProcess_c:

    {

        UDIPId   pid;                   /* in */

        udr_UDIPId(udrs, &pid);         /* recv all "in" parameters */

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIDestroyProcess(pid);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*-------------------------------------------------------------------- UDIRead

*/

    case UDIRead_c:

    {

        UDIResource     from;           /* in - source address on target */

        UDIHostMemPtr   to_dfe;         /* out - destination adds on dfe host */

        UDICount        count;          /* in -- count of objects */

        UDISizeT        size;           /* in -- size of each object */

        UDICount        count_done;     /* out - count actually transferred */

        UDIBool         host_endian;    /* in -- flag for endian information */

        char*           count_done_p;

        char*           to_dfe_p;

        udr_UDIResource(udrs, &from);   /* recv all "in" parameters */

        udr_UDICount(udrs, &count);

        udr_UDISizeT(udrs, &size);

        udr_UDIBool(udrs, &host_endian);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        udr_work(udrs, count_done, 0);   /* nothing to send yet */

        count_done_p = udr_getpos(udrs);

        udr_inline(udrs, sizeof(UDICount));/* make space for count_done */

        to_dfe_p = udr_getpos(udrs);

        tip_errno = UDIRead (from, to_dfe_p, count, size,

                &count_done, host_endian);

        udr_inline(udrs,count_done*size);/* make space in socket buffer */

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_setpos(udrs, count_done_p); /* restore count_done stream position */

        udr_UDICount(udrs, &count_done);

        udr_sendnow(udrs);

        break;

    }

/*------------------------------------------------------------------- UDIWrite

*/

    case UDIWrite_c:

    {

        UDIHostMemPtr   from_dfe;       /* in -- source address on DFE host */

        UDIResource     to;             /* in -- destination adds on target */

        UDICount        count;          /* in -- count of objects */

        UDISizeT        size;           /* in -- size of each object */

        UDICount        count_done;     /* out - count actually transferred */

        UDIBool         host_endian;    /* in -- flag for endian information */

        int             byte_count;

        char*           from_dfe_p;

        udr_UDIResource(udrs, &to);     /* recv all "in" parameters */

        udr_UDICount(udrs, &count);

        udr_UDISizeT(udrs, &size);

        udr_UDIBool(udrs, &host_endian);

        from_dfe_p = udr_getpos(udrs);  /* fake DFE host address */

        byte_count = size * count;

        udr_readnow(udrs, byte_count);  /* read all data available from the

                                           socket into the stream buffer */

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIWrite( from_dfe_p, to, count, size,

                &count_done, host_endian );

        udr_UDICount(udrs, &count_done);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*-------------------------------------------------------------------- UDICopy

*/

    case UDICopy_c:

    {

        UDIResource     from;           /* in -- dest. address on target */

        UDIResource     to;             /* in -- source address on target */

        UDICount        count;          /* in -- count of objects */

        UDISizeT        size;           /* in -- size of each object */

        UDICount        count_done;     /* out - count actually transferred */

        UDIBool         direction;      /* in -- high-to-low or reverse */

        udr_UDIResource(udrs, &from);   /* recv all "in" parameters */

        udr_UDIResource(udrs, &to);

        udr_UDICount(udrs, &count);

        udr_UDISizeT(udrs, &size);

        udr_UDIBool(udrs, &direction);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDICopy(from, to, count, size, &count_done, direction );

        udr_UDICount(udrs, &count_done);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*----------------------------------------------------------------- UDIExecute

*/

    case UDIExecute_c:

    {

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIExecute();

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*-------------------------------------------------------------------- UDIStep

*/

    case UDIStep_c:

    {

        UDIUInt32       steps;          /* in -- number of steps */

        UDIStepType     steptype;       /* in -- type of stepping to be done */

        UDIRange        range;          /* in -- range if StepInRange is TRUE */

        udr_UDIInt32(udrs, &steps);     /* recv all "in" parameters */

        udr_UDIStepType(udrs, &steptype);

        udr_UDIRange(udrs, &range);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIStep(steps, steptype, range);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*-------------------------------------------------------------------- UDIWait

*/

    case UDIWait_c:

    {

        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 */

        udr_UDIInt32(udrs, &maxtime);

        udrs->udr_op = UDR_ENCODE;      /* send all "out" parameters */

        tip_errno = UDIWait(maxtime, &pid, &stop_reason);

        udr_UDIPId(udrs, &pid);

        udr_UDIUInt32(udrs, &stop_reason);

        udr_UDIError(udrs, &tip_errno); /* send any TIP error */

        udr_sendnow(udrs);

        break;

    }

/*----------------------------------------------------------- UDISetBreakpoint

*/

    case UDISetBreakpoint_c:

    {

        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 */

        udr_UDIResource(udrs, &addr); /* recv all "in" parameters */

        udr_UDIInt32(udrs, &passcount);

        udr_UDIBreakType(udrs, &type);