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 / udr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  11.2 KB  |  426 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 udr_c[]="@(#)udr.c    2.8  Daniel Mann";
  28. static char udr_c_AMD[]="@(#)udr.c    2.3, AMD";
  29. /* 
  30. *    This module supports sending and receiving
  31. *    data objects over a socket conection.
  32. *    All data is serialised into a character stream,
  33. *    and de-serialised back into the approproiate objects.
  34. ********************************************************************** HISTORY
  35. */
  36. #include <stdio.h>
  37. #include <sys/fcntl.h>
  38. #include <sys/types.h>
  39. #include <sys/socket.h>
  40. #include "udiproc.h"
  41. #include "udisoc.h"
  42.  
  43. extern    int    errno;
  44. extern    char*    malloc();
  45.  
  46. /* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE
  47. */
  48.  
  49. /* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS
  50. */
  51. int        udr_errno;        /* error occurs during UDR service */
  52.  
  53. /* local dec/defs. which are not in a .h   file *************** LOCAL DEC/DEFS
  54. */
  55.  
  56. /****************************************************************** UDR_CREATE
  57. * Build UDR structure for character stream processing.
  58. */
  59. int udr_create(udrs, sd, size)
  60. UDR*    udrs;
  61. int    sd;
  62. int    size;
  63. {
  64.     udrs->sd = sd;
  65.     if(!udrs->buff) udrs->buff = malloc(size);
  66.     udrs->getbytes = udrs->buff;    /* set the buffer to the start */
  67.     udrs->putbytes = udrs->buff;
  68.     udrs->putend = udrs->buff;
  69.     udrs->udr_op = -1;            /* don't know the direction */
  70.     udrs->previous_op = -1;        /* don't know the direction */
  71.     udrs->bufsize = size;
  72.     return 0;
  73. }
  74.  
  75. /******************************************************************** UDR_FREE
  76. * Free USR structure and close socket.
  77. */
  78. int udr_free(udrs)
  79. UDR*    udrs;
  80. {
  81.     close(udrs->sd);
  82.     free(udrs->buff);
  83.     return 0;
  84. }
  85.  
  86. /****************************************************************** UDR_SIGNAL
  87. * Send a signal to the process at the other end of the socket,
  88. * indicating that it should expect to recieve a new message shortly.
  89. */
  90. int udr_signal(udrs)
  91. UDR*    udrs;
  92. {
  93.     if(send(udrs->sd, "I", 1, MSG_OOB) == -1)
  94.     {    perror("ERROR, udr_signal(), send(...MSG_OOB)");
  95.     udr_errno =  UDIErrorIPCInternal;
  96.         return -1;        /* return error code */
  97.     }
  98.     return 0;
  99. }
  100.  
  101. /***************************************************************** UDR_SENDNOW
  102. * used to flush the current character stream buffer to
  103. * the associated socket.  */
  104. int udr_sendnow(udrs)
  105. UDR*    udrs;
  106. {
  107.     int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff);
  108.     if(udrs->previous_op == 0)
  109.     {   udr_errno =  UDIErrorIPCInternal;
  110.     return -1;
  111.     }
  112.     udrs->putbytes = udrs->buff;
  113.     udrs->putend = udrs->buff;
  114.     if (write(udrs->sd, udrs->buff, size) == -1)
  115.     {    perror("ERROR, udr_sendnow(), write() call: ");
  116.     udr_errno =  UDIErrorIPCInternal;
  117.         return -1;        /* return error code */
  118.     }
  119.     return 0;
  120. }
  121.  
  122. /******************************************************************** UDR_WORK
  123. * Function to send or recieve data from the buffers supporting
  124. * socket communication. The buffer contains serialised objects
  125. * sent/recieved over a socket connection.
  126. */
  127. int udr_work(udrs, object_p, size)
  128. UDR*    udrs;
  129. void*    object_p;
  130. int    size;
  131. {
  132.     int        cnt, remain;
  133.  
  134.     if(udrs->udr_op != udrs->previous_op)
  135.     {    if(udrs->previous_op == 0)
  136.     {   udr_errno =  UDIErrorIPCInternal;
  137.         return -1;
  138.         }
  139.     udrs->previous_op= udrs->udr_op;
  140.     udrs->putbytes = udrs->buff;
  141.     udrs->getbytes = udrs->buff;
  142.     }
  143.  
  144.     if(udrs->udr_op == UDR_ENCODE)
  145.     {            /* write data into character stream buffer */
  146.         if( (UDIUInt32)(udrs->putbytes) + size >
  147.         (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) )
  148.     {   udr_errno =  UDIErrorIPCInternal;
  149.         return -1;
  150.         }
  151.     bcopy((char*)object_p, udrs->putbytes, size);
  152.         udrs->putbytes += size;
  153.         if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes;
  154.     }
  155.     else if(udrs->udr_op == UDR_DECODE)
  156.     {
  157.         if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
  158.     {         /* need more data in character stream buffer */
  159.                remain = (UDIUInt32)(udrs->bufsize) -
  160.         ( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
  161.                if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff)
  162.         - (UDIUInt32)(udrs->getbytes)) < size)
  163.         {   udr_errno =  UDIErrorIPCInternal;
  164.             return -1;
  165.             }
  166.             cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
  167.         if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
  168.         udrs->putbytes += cnt;
  169.             if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
  170.         {    udr_errno =  UDIErrorIPCInternal;
  171.             return -1;        /* return error code */
  172.             }
  173.         }        /* read data from character stream buffer */
  174.     bcopy(udrs->getbytes, (char*)object_p,  size);
  175.         udrs->getbytes += size;
  176.     }
  177.     else
  178.     {    udr_errno =  UDIErrorIPCInternal;
  179.     return -1;
  180.     }
  181.     return 0;
  182. }
  183.  
  184. /************************************************************* UDR_UDIResource
  185. */
  186. int udr_UDIResource(udrs, object_p)
  187. UDR*    udrs;
  188. UDIResource*    object_p;
  189. {
  190.     int    retval;
  191.  
  192.     retval = udr_CPUSpace(udrs, &object_p->Space);
  193.     retval = retval |  udr_CPUOffset(udrs, &object_p->Offset);
  194.     return retval;
  195. }
  196.  
  197. /**************************************************************** UDR_UDIRange
  198. */
  199. int udr_UDIRange(udrs, object_p)
  200. UDR*        udrs;
  201. UDIRange*    object_p;
  202. {
  203.     int    retval;
  204.  
  205.     retval = udr_CPUOffset(udrs, &object_p->Low);
  206.     retval = retval | udr_CPUOffset(udrs, &object_p->High);
  207.     return retval;
  208. }
  209.  
  210. /********************************************************** UDR_UDIMemoryRange
  211. */
  212. int udr_UDIMemoryRange(udrs, object_p)
  213. UDR*        udrs;
  214. UDIMemoryRange*    object_p;
  215. {
  216.     int    retval;
  217.  
  218.     retval = udr_CPUSpace(udrs, &object_p->Space);
  219.     retval = retval | udr_CPUOffset(udrs, &object_p->Offset);
  220.     retval = retval | udr_CPUSizeT(udrs, &object_p->Size);
  221.     return retval;
  222. }
  223.  
  224. /****************************************************************** UDR_string
  225. */
  226. int udr_string(udrs, sp)
  227. UDR*    udrs;
  228. char*    sp;
  229. {
  230.     int    len, retval;
  231.  
  232.     if(udrs->udr_op == UDR_ENCODE)
  233.     {
  234.     if(sp)
  235.         {   len = strlen(sp) + 1;
  236.             retval = udr_UDIInt32(udrs, &len);
  237.             retval = retval | udr_work(udrs, sp, len);
  238.     }
  239.     else    /* deal with NULL pointer */
  240.     {   len = 0;
  241.             retval = udr_UDIInt32(udrs, &len);
  242.     }
  243.     }
  244.     else if(udrs->udr_op == UDR_DECODE)
  245.     {
  246.         retval = udr_UDIInt32(udrs, &len);
  247.     if(len)
  248.             retval = retval | udr_work(udrs, sp, len);
  249.     else    *sp = '\0';            /* terminate string */
  250.     }
  251.     else
  252.     {    udr_errno =  UDIErrorIPCInternal;
  253.     return -1;
  254.     }
  255.     return retval;
  256. }
  257.  
  258. /******************************************************************* UDR_BYTES
  259. */
  260. int udr_bytes(udrs, ptr, len)
  261. UDR*    udrs;
  262. char*    ptr;
  263. int    len;
  264. {
  265.     return udr_work(udrs, ptr, len);
  266. }
  267.  
  268. /********************************************************************* UDR_INT
  269. */
  270. int udr_int(udrs, int_p)
  271. UDR*    udrs;
  272. int*    int_p;
  273. {
  274.     int ret_val;
  275.     UDIInt32  udr_obj;            /* object of know size */
  276.  
  277.     if(udrs->udr_op == UDR_ENCODE)
  278.     {
  279.         udr_obj = *int_p;        /* copy into know object size */
  280.         return udr_UDIInt32(udrs, &udr_obj);
  281.     }
  282.     else if(udrs->udr_op == UDR_DECODE)
  283.     {
  284.         ret_val = udr_UDIInt32(udrs, &udr_obj);    /* get object of known size */
  285.     *int_p = udr_obj;
  286.     return ret_val;
  287.     }
  288.     else
  289.     {    udr_errno =  UDIErrorIPCInternal;
  290.     return -1;
  291.     }
  292. }
  293.  
  294. /****************************************************************** UDR_INLINE
  295. */
  296. char* udr_inline(udrs, size)
  297. UDR*    udrs;
  298. int    size;
  299. {
  300.     if(udrs->udr_op != udrs->previous_op)
  301.     {    if(udrs->previous_op == 0)
  302.     {   udr_errno =  UDIErrorIPCInternal;
  303.         return 0;
  304.         }
  305.         udrs->previous_op= udrs->udr_op;
  306.     udrs->putbytes = udrs->buff;
  307.     udrs->getbytes = udrs->buff;
  308.     }
  309.     if(udrs->udr_op == UDR_ENCODE)
  310.     {
  311.         if(udrs->putbytes + size > udrs->bufsize + udrs->buff)
  312.        return 0;
  313.         udrs->putbytes += size;
  314.     return udrs->putbytes - size;
  315.     }
  316.     else if(udrs->udr_op == UDR_DECODE)
  317.     {
  318.         if(udrs->getbytes + size > udrs->bufsize + udrs->buff)
  319.        return 0;
  320.         udrs->getbytes += size;
  321.     return udrs->getbytes - size;
  322.     }
  323.     else
  324.     {    udr_errno =  UDIErrorIPCInternal;
  325.     return 0;
  326.     }
  327. }
  328.  
  329. /****************************************************************** UDR_GETPOS
  330. */
  331. char*    udr_getpos(udrs)
  332. UDR*    udrs;
  333. {
  334.     if(udrs->udr_op == UDR_ENCODE)
  335.     {
  336.     return udrs->putbytes;
  337.     }
  338.     else if(udrs->udr_op == UDR_DECODE)
  339.     {
  340.     return udrs->getbytes;
  341.     }
  342.     else
  343.     {    udr_errno =  UDIErrorIPCInternal;
  344.     return 0;
  345.     }
  346. }
  347.  
  348. /****************************************************************** UDR_SETPOS
  349. */
  350. int    udr_setpos(udrs, pos)
  351. UDR*    udrs;
  352. char*    pos;
  353. {
  354.     if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize))
  355.      || ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) )
  356.     {    udr_errno =  UDIErrorIPCInternal;
  357.     return 0;
  358.     }
  359.     if(udrs->udr_op == UDR_ENCODE)
  360.     {
  361.     udrs->putbytes = pos;
  362.     return 1;
  363.     }
  364.     else if(udrs->udr_op == UDR_DECODE)
  365.     {
  366.     udrs->getbytes = pos;
  367.     return 1;
  368.     }
  369.     else
  370.     {    udr_errno =  UDIErrorIPCInternal;
  371.     return 0;
  372.     }
  373. }
  374.  
  375. /***************************************************************** UDR_READNOW
  376. * Try and ensure "size" bytes are available in the
  377. * receive buffer character stream.
  378. */
  379. int    udr_readnow(udrs, size)
  380. UDR*    udrs;
  381. int    size;
  382. {
  383.     int    cnt, remain;
  384.  
  385.     if(udrs->udr_op == UDR_ENCODE)
  386.     {
  387.     udr_errno =  UDIErrorIPCInternal;
  388.     return -1;
  389.     }
  390.     else if(udrs->udr_op == UDR_DECODE)
  391.     {
  392.         if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
  393.     {         /* need more data in character stream buffer */
  394.                remain = (UDIUInt32)(udrs->bufsize) -
  395.         ( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
  396.             cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
  397.         if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
  398.         udrs->putbytes += cnt;
  399.             if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
  400.             {  fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n");
  401.            return -1;        /* return error code */
  402.             }
  403.         }        
  404.     }
  405.     else
  406.     {    udr_errno =  UDIErrorIPCInternal;
  407.     return -1;
  408.     }
  409.     return 0;
  410. }
  411.  
  412. /******************************************************************* UDR_ALIGN
  413. */
  414. int udr_align(udrs, size)
  415. UDR*    udrs;
  416. int    size;
  417. {
  418.     char*   align;
  419.     int        offset;    
  420.  
  421.     align = udr_getpos(udrs);
  422.     offset = size - ((int)align & (size -1));
  423.     offset = offset & (size -1);
  424.     if(offset) udr_setpos(udrs, align + offset);
  425. }
  426.