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