URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [insight/] [gdb/] [29k-share/] [udi/] [udr.c] - Rev 1765
Compare with Previous | Blame | View Log
/* 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__ */