udr.c   [plain text]

/* This module supports sending and receiving data objects over a
   socket conection.

   Copyright 1993 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

static char udr_c[]="@(#)udr.c	2.8  Daniel Mann";
static char udr_c_AMD[]="@(#)udr.c	2.3, AMD";
/* 
*	All data is serialised into a character stream,
*	and de-serialised back into the approproiate objects.
********************************************************************** HISTORY
*/
/* This is all unneeded on DOS machines.  */
#ifndef __GO32__

#include <stdio.h>
#include <sys/types.h>

/* This used to say sys/fcntl.h, but the only systems I know of that
   require that are old (pre-4.3, at least) BSD systems, which we
   probably don't need to worry about.  */
#include <fcntl.h>

#include <sys/socket.h>
#include "udiproc.h"
#include "udisoc.h"

extern	int	errno;
extern	char*	malloc();

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

/* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS
*/
int		udr_errno;		/* error occurs during UDR service */

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

/****************************************************************** UDR_CREATE
* Build UDR structure for character stream processing.
*/
int udr_create(udrs, sd, size)
UDR*	udrs;
int	sd;
int	size;
{
    udrs->sd = sd;
    if(!udrs->buff) udrs->buff = malloc(size);
    udrs->getbytes = udrs->buff;	/* set the buffer to the start */
    udrs->putbytes = udrs->buff;
    udrs->putend = udrs->buff;
    udrs->udr_op = -1;			/* don't know the direction */
    udrs->previous_op = -1;		/* don't know the direction */
    udrs->bufsize = size;
    return 0;
}

/******************************************************************** UDR_FREE
* Free USR structure and close socket.
*/
int udr_free(udrs)
UDR*	udrs;
{
    close(udrs->sd);
    free(udrs->buff);
    return 0;
}

/****************************************************************** UDR_SIGNAL
* Send a signal to the process at the other end of the socket,
* indicating that it should expect to recieve a new message shortly.
*/
int udr_signal(udrs)
UDR*	udrs;
{
    if(send(udrs->sd, "I", 1, MSG_OOB) == -1)
    {	perror("ERROR, udr_signal(), send(...MSG_OOB)");
	udr_errno =  UDIErrorIPCInternal;
    	return -1;		/* return error code */
    }
    return 0;
}

/***************************************************************** UDR_SENDNOW
* used to flush the current character stream buffer to
* the associated socket.  */
int udr_sendnow(udrs)
UDR*	udrs;
{
    int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff);
    if(udrs->previous_op == 0)
    {   udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
    udrs->putbytes = udrs->buff;
    udrs->putend = udrs->buff;
    if (write(udrs->sd, udrs->buff, size) == -1)
    {	perror("ERROR, udr_sendnow(), write() call: ");
	udr_errno =  UDIErrorIPCInternal;
    	return -1;		/* return error code */
    }
    return 0;
}

/******************************************************************** UDR_WORK
* Function to send or recieve data from the buffers supporting
* socket communication. The buffer contains serialised objects
* sent/recieved over a socket connection.
*/
int udr_work(udrs, object_p, size)
UDR*	udrs;
void*	object_p;
int	size;
{
    int	    cnt, remain;

    if(udrs->udr_op != udrs->previous_op)
    {	if(udrs->previous_op == 0)
	{   udr_errno =  UDIErrorIPCInternal;
	    return -1;
        }
	udrs->previous_op= udrs->udr_op;
	udrs->putbytes = udrs->buff;
	udrs->getbytes = udrs->buff;
    }

    if(udrs->udr_op == UDR_ENCODE)
    {			/* write data into character stream buffer */
    	if( (UDIUInt32)(udrs->putbytes) + size >
	    (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) )
	{   udr_errno =  UDIErrorIPCInternal;
	    return -1;
        }
	memcpy(udrs->putbytes, (char*)object_p, size);
    	udrs->putbytes += size;
    	if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes;
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
	{		 /* need more data in character stream buffer */
       	    remain = (UDIUInt32)(udrs->bufsize) -
		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
       	    if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff)
		- (UDIUInt32)(udrs->getbytes)) < size)
	    {   udr_errno =  UDIErrorIPCInternal;
	        return -1;
            }
    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
	    udrs->putbytes += cnt;
    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
	    {	udr_errno =  UDIErrorIPCInternal;
	        return -1;		/* return error code */
    	    }
    	}		/* read data from character stream buffer */
	memcpy((char*)object_p,  udrs->getbytes, size);
    	udrs->getbytes += size;
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
    return 0;
}

/************************************************************* UDR_UDIResource
*/
int udr_UDIResource(udrs, object_p)
UDR*	udrs;
UDIResource*	object_p;
{
    int	retval;

    retval = udr_CPUSpace(udrs, &object_p->Space);
    retval = retval |  udr_CPUOffset(udrs, &object_p->Offset);
    return retval;
}

/**************************************************************** UDR_UDIRange
*/
int udr_UDIRange(udrs, object_p)
UDR*		udrs;
UDIRange*	object_p;
{
    int	retval;

    retval = udr_CPUOffset(udrs, &object_p->Low);
    retval = retval | udr_CPUOffset(udrs, &object_p->High);
    return retval;
}

/********************************************************** UDR_UDIMemoryRange
*/
int udr_UDIMemoryRange(udrs, object_p)
UDR*		udrs;
UDIMemoryRange*	object_p;
{
    int	retval;

    retval = udr_CPUSpace(udrs, &object_p->Space);
    retval = retval | udr_CPUOffset(udrs, &object_p->Offset);
    retval = retval | udr_CPUSizeT(udrs, &object_p->Size);
    return retval;
}

/****************************************************************** UDR_string
*/
int udr_string(udrs, sp)
UDR*	udrs;
char*	sp;
{
    int	len, retval;

    if(udrs->udr_op == UDR_ENCODE)
    {
	if(sp)
    	{   len = strlen(sp) + 1;
    	    retval = udr_UDIInt32(udrs, &len);
    	    retval = retval | udr_work(udrs, sp, len);
	}
	else	/* deal with NULL pointer */
	{   len = 0;
    	    retval = udr_UDIInt32(udrs, &len);
	}
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
    	retval = udr_UDIInt32(udrs, &len);
	if(len)
    	    retval = retval | udr_work(udrs, sp, len);
	else	*sp = '\0';			/* terminate string */
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
    return retval;
}

/******************************************************************* UDR_BYTES
*/
int udr_bytes(udrs, ptr, len)
UDR*	udrs;
char*	ptr;
int	len;
{
    return udr_work(udrs, ptr, len);
}

/********************************************************************* UDR_INT
*/
int udr_int(udrs, int_p)
UDR*	udrs;
int*	int_p;
{
    int ret_val;
    UDIInt32  udr_obj;			/* object of know size */

    if(udrs->udr_op == UDR_ENCODE)
    {
        udr_obj = *int_p;		/* copy into know object size */
        return udr_UDIInt32(udrs, &udr_obj);
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
        ret_val = udr_UDIInt32(udrs, &udr_obj);	/* get object of known size */
	*int_p = udr_obj;
	return ret_val;
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
}

/****************************************************************** UDR_INLINE
*/
char* udr_inline(udrs, size)
UDR*	udrs;
int	size;
{
    if(udrs->udr_op != udrs->previous_op)
    {	if(udrs->previous_op == 0)
	{   udr_errno =  UDIErrorIPCInternal;
	    return 0;
        }
    	udrs->previous_op= udrs->udr_op;
	udrs->putbytes = udrs->buff;
	udrs->getbytes = udrs->buff;
    }
    if(udrs->udr_op == UDR_ENCODE)
    {
    	if(udrs->putbytes + size > udrs->bufsize + udrs->buff)
	   return 0;
    	udrs->putbytes += size;
	return udrs->putbytes - size;
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
    	if(udrs->getbytes + size > udrs->bufsize + udrs->buff)
	   return 0;
    	udrs->getbytes += size;
	return udrs->getbytes - size;
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return 0;
    }
}

/****************************************************************** UDR_GETPOS
*/
char*	udr_getpos(udrs)
UDR*	udrs;
{
    if(udrs->udr_op == UDR_ENCODE)
    {
	return udrs->putbytes;
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
	return udrs->getbytes;
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return 0;
    }
}

/****************************************************************** UDR_SETPOS
*/
int	udr_setpos(udrs, pos)
UDR*	udrs;
char*	pos;
{
    if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize))
     || ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) )
    {	udr_errno =  UDIErrorIPCInternal;
	return 0;
    }
    if(udrs->udr_op == UDR_ENCODE)
    {
	udrs->putbytes = pos;
	return 1;
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
	udrs->getbytes = pos;
	return 1;
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return 0;
    }
}

/***************************************************************** UDR_READNOW
* Try and ensure "size" bytes are available in the
* receive buffer character stream.
*/
int	udr_readnow(udrs, size)
UDR*	udrs;
int	size;
{
    int	cnt, remain;

    if(udrs->udr_op == UDR_ENCODE)
    {
	udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
    else if(udrs->udr_op == UDR_DECODE)
    {
    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
	{		 /* need more data in character stream buffer */
       	    remain = (UDIUInt32)(udrs->bufsize) -
		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
	    udrs->putbytes += cnt;
    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
    	    {  fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n");
	       return -1;		/* return error code */
    	    }
    	}		
    }
    else
    {	udr_errno =  UDIErrorIPCInternal;
	return -1;
    }
    return 0;
}

/******************************************************************* UDR_ALIGN
*/
int udr_align(udrs, size)
UDR*	udrs;
int	size;
{
    char*   align;
    int	    offset;	

    align = udr_getpos(udrs);
    offset = size - ((int)align & (size -1));
    offset = offset & (size -1);
    if(offset) udr_setpos(udrs, align + offset);
}
#endif /* __GO32__ */