/*----------------------------------------------------------------------*
rtp_net_gethostbyname
*----------------------------------------------------------------------*/
int rtp_net_gethostbyname (unsigned char *ipAddr, int *type, char *name)
{
#if (INCLUDE_DNS)
#ifdef RTP_DEBUG
int result;
#endif
PFHOSTENT hp = NULL;
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (!(hp = gethostbyname(name)))
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_gethostbyname: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
if (hp->h_addrtype != AF_INET)
{
#ifdef RTP_DEBUG
set_errno (EAFNOSUPPORT);
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_gethostbyname: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*type = RTP_NET_TYPE_IPV4;
ipAddr[0] = (unsigned char) hp->h_addr_list[0][0];
ipAddr[1] = (unsigned char) hp->h_addr_list[0][1];
ipAddr[2] = (unsigned char) hp->h_addr_list[0][2];
ipAddr[3] = (unsigned char) hp->h_addr_list[0][3];
return (0);
#else
rtp_not_yet_implemented();
return (-1);
#endif /* INCLUDE_DNS */
}
/*----------------------------------------------------------------------*
rtp_net_setmcastttl
*----------------------------------------------------------------------*/
int rtp_net_setmcastttl(RTP_HANDLE sockHandle, int ttl)
{
int result;
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
result = setsockopt( sockHandle, IPPROTO_IP,
IP_MULTICAST_TTL, (char *) &ttl, sizeof (int));
if (result != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_setmcastttl: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_setkeepalive
*----------------------------------------------------------------------*/
int rtp_net_setkeepalive (RTP_HANDLE sockHandle, unsigned int onBool)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (setsockopt((int) sockHandle, SOL_SOCKET,
SO_KEEPALIVE, (PFCCHAR)&onBool,
sizeof (int)) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_setkeepalive: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_setblocking
*----------------------------------------------------------------------*/
int rtp_net_setblocking (RTP_HANDLE sockHandle, unsigned int onBool)
{
unsigned long arg;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
arg = (unsigned long)(!onBool);
if (ioctlsocket((int) sockHandle, FIONBIO, &arg) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_setblocking: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_open
*----------------------------------------------------------------------*/
int rtp_file_open (RTP_HANDLE * fdPtr, const char * name, unsigned short flag, unsigned short mode)
{
long fileHandle;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
name = (char *) _rtp_name_to_nativename((char *) name);
fileHandle = (long) vf_open((PFCHAR) name, (word) _rtp_flag_to_operation(flag), (word) _rtp_mode_to_permission(mode));
if (fileHandle == (-1))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_open: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*fdPtr = (RTP_HANDLE) fileHandle;
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_socket_stream
*----------------------------------------------------------------------*/
int rtp_net_socket_stream (RTP_HANDLE *sockHandle)
{
int sock;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
*sockHandle = ((RTP_HANDLE)-1);
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_socket_stream: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*sockHandle = (RTP_HANDLE) sock;
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_getntoread
*----------------------------------------------------------------------*/
int rtp_net_getntoread (RTP_HANDLE sockHandle, unsigned long * nToRead)
{
unsigned long arg;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (ioctlsocket((int) sockHandle, FIONREAD, &arg) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_getntoread: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*nToRead = arg;
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_rmdir
*----------------------------------------------------------------------*/
int rtp_file_rmdir (char * name)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
name = _rtp_name_to_nativename(name);
if (!vf_rmdir((PFCHAR)name))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_rmdir: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_recv
*----------------------------------------------------------------------*/
long rtp_net_recv (RTP_HANDLE sockHandle, unsigned char * buffer, long size)
{
long result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
result = (long) recv((int) sockHandle, (char *) buffer, (int) size, 0);
if (result < 0)
{
result = (long) xn_getlasterror();
if ((result == EINPROGRESS) || (result == EWOULDBLOCK))
{
RTP_DEBUG_OUTPUT_STR("rtp_net_recv: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-2);
}
RTP_DEBUG_OUTPUT_STR("rtp_net_recv: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-1);
}
return (result);
}
/*----------------------------------------------------------------------*
rtp_file_pwd
*----------------------------------------------------------------------*/
int rtp_file_pwd (char * name, long size)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (!vf_pwd(name))
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_file_pwd: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
name = _rtp_nativename_to_name(name);
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_gfirst
*----------------------------------------------------------------------*/
int rtp_file_gfirst (void ** dirobj, char * name)
{
VDSTAT* nativeDirObj;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
nativeDirObj = (VDSTAT*) rtp_malloc(sizeof(VDSTAT));
rtp_memset(nativeDirObj, 0, sizeof(VDSTAT));
if (!vf_gfirst(nativeDirObj, (PFCHAR) name))
{
rtp_free(nativeDirObj);
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_gfirst: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*dirobj = (void*) nativeDirObj;
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_chmode
*----------------------------------------------------------------------*/
int rtp_file_chmode (char * name, unsigned char attributes)
{
int nativemode;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
nativemode = 0;
nativemode |= (attributes & RTP_FILE_ATTRIB_RDONLY) ? VF_ATTRIB_RDONLY : 0;
nativemode |= (attributes & RTP_FILE_ATTRIB_WRONLY) ? VF_ATTRIB_WRONLY : 0;
nativemode |= (attributes & RTP_FILE_ATTRIB_RDWR) ? VF_ATTRIB_RDWR : 0;
/* nativemode |= (attributes & RTP_FILE_ATTRIB_ARCHIVE) ? unsupported : 0; */
/* nativemode |= (attributes & RTP_FILE_ATTRIB_HIDDEN) ? unsupported : 0; */
/* nativemode |= (attributes & RTP_FILE_ATTRIB_SYSTEM) ? unsupported : 0; */
name = _rtp_name_to_nativename(name);
if (!vf_chmode((PFCHAR) name, nativemode))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_chmode: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_get_free
*----------------------------------------------------------------------*/
int rtp_file_get_free (char * name, unsigned long *total, unsigned long *free,
unsigned long *sectors_per_unit, unsigned short *bytes_per_sector)
{
dword blocks;
dword bfree;
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
name = _rtp_name_to_nativename(name);
if (!vf_get_free((PFCHAR) name, &blocks, &bfree))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_get_free: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*total = (unsigned long) &blocks;
*free = (unsigned long) &bfree;
*sectors_per_unit = (unsigned long) 0; /* [tbd] */
*bytes_per_sector = (unsigned short) 0; /* [tbd] */
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_flush
*----------------------------------------------------------------------*/
int rtp_file_flush (RTP_HANDLE fd)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
/* ----------------------------------- */
/* trick to flush file */
/* ----------------------------------- */
if (!vf_flush(fd))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_flush: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
static INLINE int LastError(void)
{
#ifdef USE_WINDOWS_API
return WSAGetLastError();
#elif defined(EBSNET)
return xn_getlasterror();
#else
return errno;
#endif
}
/*----------------------------------------------------------------------*
rtp_net_read_select
*----------------------------------------------------------------------*/
int rtp_net_read_select (RTP_HANDLE sockHandle, long msecTimeout)
{
struct timeval selectTime;
fd_set read_set;
int result;
/* ----------------------------------- */
/* read list */
/* ----------------------------------- */
FD_ZERO(&read_set);
FD_SET(sockHandle, &read_set);
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (msecTimeout >= 0)
{
selectTime.tv_sec = msecTimeout / 1000;
selectTime.tv_usec = (msecTimeout % 1000) * 1000;
result = select(1, (PFDSET) &read_set, (PFDSET) 0, (PFDSET) 0, (PCTIMEVAL) &selectTime);
}
else
{
result = select(1, (PFDSET) &read_set, (PFDSET) 0, (PFDSET) 0, (PCTIMEVAL) NULL);
}
/* if (result == 1)
| {
| if (!xn_tcp_is_read(sockHandle))
| {
| result = (-1);
| }
| }
*/
/* if an error or if it timed out */
if (result <= 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_read_select: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_recvfrom
*----------------------------------------------------------------------*/
long rtp_net_recvfrom (RTP_HANDLE sockHandle,
unsigned char *buffer, long size,
unsigned char *ipAddr, int *port, int *type)
{
long result;
int remoteLen;
struct sockaddr_in remote;
remoteLen = sizeof (remote);
memset (&remote, 0, remoteLen);
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
result = (long) recvfrom ((int) sockHandle, (PFCHAR) buffer, (int) size, 0, (PSOCKADDR) &remote, (PFINT) &remoteLen);
if (result < 0)
{
result = (long) xn_getlasterror();
if ((result == EINPROGRESS) || (result == EWOULDBLOCK))
{
RTP_DEBUG_OUTPUT_STR("rtp_net_recvfrom: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-2);
}
RTP_DEBUG_OUTPUT_STR("rtp_net_recvfrom: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-1);
}
if (ipAddr)
{
unsigned long d = remote.sin_addr.s_addr;
unsigned char *ptr = (unsigned char *) &d;
ipAddr[0] = ptr[0];
ipAddr[1] = ptr[1];
ipAddr[2] = ptr[2];
ipAddr[3] = ptr[3];
*type = RTP_NET_TYPE_IPV4;
*port = ntohs (remote.sin_port);
}
return (result);
}
/*----------------------------------------------------------------------*
rtp_net_getsockname
*----------------------------------------------------------------------*/
int rtp_net_getsockname (RTP_HANDLE sockHandle, unsigned char *ipAddr, int *port, int *type)
{
struct sockaddr_in localAddr;
int localLen;
#ifdef RTP_DEBUG
int result;
#endif
localLen = sizeof (localAddr);
memset(&localAddr, 0, localLen);
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (getsockname ((int) sockHandle, (PSOCKADDR) &localAddr, (PFINT) &localLen) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_getsockname: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
if (ipAddr)
{
unsigned long d = localAddr.sin_addr.s_addr;
unsigned char *ptr = (unsigned char *) &d;
*type = RTP_NET_TYPE_IPV4;
ipAddr[0] = ptr[0];
ipAddr[1] = ptr[1];
ipAddr[2] = ptr[2];
ipAddr[3] = ptr[3];
}
if (port)
{
*port = ntohs (localAddr.sin_port);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_lseek
*----------------------------------------------------------------------*/
long rtp_file_lseek (RTP_HANDLE fd, long offset, int origin)
{
long result;
int relative_to;
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
switch (origin)
{
case 0:
relative_to = VSEEK_SET;
break;
case 1:
relative_to = VSEEK_CUR;
break;
case 2:
relative_to = VSEEK_END;
break;
default:
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_file_lseek: error returned.\n");
#endif
return (-1);
break;
}
if ((result = vf_lseek((int) fd, offset, relative_to)) < 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_lseek: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (result);
}
/****************************************************
* Initialize socket for RTIP
****************************************************/
int SOCK_Init (void)
{
int iface;
byte tnet_localHost[4] = {192, 168, 1, 43};
byte tnet_maskip[4] = {255, 255, 255, 0};
PRINTF (("about to init xn_rtip\n"));
/* px_init (); */
if(xn_rtip_init()!=0)
{
PRINTF (("SOCK_Init: Error in xn_rtip_init\n"));
return -1;
}
PRINTF (("about to open xn_interface config\n"));
/* packard bell */
/* iface = xn_interface_open_config (NE2000_DEVICE, MINOR_0, 0x220, 10, 0); */
/* IntelliStation */
/* iface = xn_interface_open_config (I82559_DEVICE, MINOR_0, 0x78e0, 8, 0xf000); */
/* Toshiba */
iface = xn_interface_open_config (CE3_PCMCIA_DEVICE, MINOR_0, 0x110, 10, 0);
if(iface < 0)
{
PRINTF (("SOCK_Init: Interface Open Failed - returned %s\n",
xn_geterror_string (xn_getlasterror ())));
return -1;
}
PRINTF (("about to set ip\n"));
if(xn_set_ip(iface, tnet_localHost, tnet_maskip))
{
PRINTF (("SOCK_Init: xn_set_ip error\n"));
return -1;
}
rtsmb_srv_init (tnet_localHost, tnet_maskip, NULL, NULL);
rtsmb_cli_init (tnet_localHost, tnet_maskip);
return 0;
}
/*----------------------------------------------------------------------*
rtp_net_setlinger
*----------------------------------------------------------------------*/
int rtp_net_setlinger (RTP_HANDLE sockHandle, unsigned int onBool, long msecTimeout)
{
LINGER arg;
#ifdef RTP_DEBUG
int result;
#endif
arg.l_onoff = onBool;
arg.l_linger = 0;
if (arg.l_onoff)
{
if (msecTimeout > 0)
{
arg.l_linger = (int) (msecTimeout / 1000);
}
}
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (setsockopt((int) sockHandle, SOL_SOCKET,
SO_LINGER, (PFCCHAR) &arg,
sizeof (struct linger)) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_setlinger: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_shutdown
*----------------------------------------------------------------------*/
int rtp_net_shutdown (RTP_HANDLE sockHandle, int how)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (shutdown((int) sockHandle, how) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror();
RTP_DEBUG_OUTPUT_STR("rtp_net_shutdown: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_truncate
*----------------------------------------------------------------------*/
int rtp_file_truncate (RTP_HANDLE fd, long offset)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (!vf_truncate((int) fd, offset))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_truncate: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_close
*----------------------------------------------------------------------*/
int rtp_file_close (RTP_HANDLE fileHandle)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (vf_close((int) fileHandle) != 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_close: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_gnext
*----------------------------------------------------------------------*/
int rtp_file_gnext (void * dirobj)
{
#ifdef RTP_DEBUG
int result;
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if (!vf_gnext((VDSTAT*) dirobj))
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_gnext: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_file_write
*----------------------------------------------------------------------*/
long rtp_file_write (RTP_HANDLE fileHandle, const unsigned char * buffer, long count)
{
int result;
#ifdef RTP_DEBUG
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
#endif
if ((result = vf_write((int) fileHandle, (PFBYTE) buffer, (word) count)) < 0)
{
#ifdef RTP_DEBUG
result = xn_getlasterror( );
RTP_DEBUG_OUTPUT_STR("rtp_file_write: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (result);
}
/*----------------------------------------------------------------------*
rtp_net_accept
*----------------------------------------------------------------------*/
int rtp_net_accept (RTP_HANDLE *connectSock, RTP_HANDLE serverSock,
unsigned char *ipAddr, int *port, int *type)
{
struct sockaddr_in clientAddr;
int clientLen;
int conSocket;
int result;
clientLen = sizeof (clientAddr);
memset(&clientAddr, 0, clientLen);
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
conSocket = accept ((int) serverSock, (PSOCKADDR) &clientAddr, (PFINT) &clientLen);
if (conSocket < 0)
{
*connectSock = ((RTP_HANDLE)-1);
result = xn_getlasterror();
if ((result == EINPROGRESS) || (result == EWOULDBLOCK))
{
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_accept: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-2);
}
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_accept: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
*connectSock = (RTP_HANDLE)conSocket;
if (ipAddr)
{
unsigned long d = clientAddr.sin_addr.s_addr;
unsigned char *ptr = (unsigned char *) &d;
*type = RTP_NET_TYPE_IPV4;
ipAddr[0] = ptr[0];
ipAddr[1] = ptr[1];
ipAddr[2] = ptr[2];
ipAddr[3] = ptr[3];
}
if (port)
{
*port = ntohs (clientAddr.sin_port);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_connect
*----------------------------------------------------------------------*/
int rtp_net_connect (RTP_HANDLE sockHandle,
unsigned char *ipAddr,
int port, int type)
{
int result;
int sinLen;
struct sockaddr_in sin;
unsigned long in_addr = 0;
sinLen = sizeof (sin);
memset(&sin, 0, sinLen);
if (ipAddr)
{
unsigned char *ptr = (unsigned char *) &in_addr;
if (type != RTP_NET_TYPE_IPV4)
{
return (-1);
}
ptr[0] = ipAddr[0];
ptr[1] = ipAddr[1];
ptr[2] = ipAddr[2];
ptr[3] = ipAddr[3];
}
else
{
/* invalid address */
return (-1);
}
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = in_addr;
sin.sin_port = htons((unsigned short)port);
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
if (connect ((int) sockHandle, (PSOCKADDR) &sin, sinLen) != 0)
{
result = xn_getlasterror();
if ((result == EINPROGRESS) ||
(result == EWOULDBLOCK))
{
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_connect: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-2);
}
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_connect: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
return (0);
}
/*----------------------------------------------------------------------*
rtp_net_sendto
*----------------------------------------------------------------------*/
long rtp_net_sendto (RTP_HANDLE sockHandle,
const unsigned char * buffer, long size,
unsigned char * ipAddr, int port, int type)
{
long result;
int sinLen;
struct sockaddr_in sin;
unsigned long in_addr = 0;
sinLen = sizeof (sin);
memset(&sin, 0, sinLen);
if (ipAddr)
{
unsigned char *ptr = (unsigned char *) &in_addr;
if (type != RTP_NET_TYPE_IPV4)
{
return (-1);
}
ptr[0] = ipAddr[0];
ptr[1] = ipAddr[1];
ptr[2] = ipAddr[2];
ptr[3] = ipAddr[3];
}
else
{
/* invalid address */
return (-1);
}
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = in_addr;
sin.sin_port = htons((unsigned short)port);
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
result = (long) sendto((int) sockHandle, (PFCCHAR) buffer, (int) size, 0, (PCSOCKADDR)&sin, sinLen);
if (result < 0)
{
result = (long) xn_getlasterror();
if ((result == EINPROGRESS) || (result == EWOULDBLOCK))
{
RTP_DEBUG_OUTPUT_STR("rtp_net_sendto: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-2);
}
RTP_DEBUG_OUTPUT_STR("rtp_net_sendto: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
return (-1);
}
return (result);
}
/*----------------------------------------------------------------------*
rtp_net_bind
*----------------------------------------------------------------------*/
int rtp_net_bind (RTP_HANDLE sockHandle, unsigned char *ipAddr, int port, int type)
{
int result;
struct sockaddr_in sin;
unsigned long in_addr = 0;
memset(&sin, 0, sizeof (sin));
if (ipAddr)
{
unsigned char *ptr = (unsigned char *) &in_addr;
if (type == RTP_NET_TYPE_IPV4)
{
ptr[0] = ipAddr[0];
ptr[1] = ipAddr[1];
ptr[2] = ipAddr[2];
ptr[3] = ipAddr[3];
}
else
{
/* ----------------------------------- */
/* RTP_NET_TYPE_IPV6 not yet supported */
/* ----------------------------------- */
return (-1);
}
}
else
{
in_addr = INADDR_ANY;
}
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = in_addr;
sin.sin_port = htons((unsigned short)port);
/* ----------------------------------- */
/* Clear the error state by setting */
/* to 0. */
/* ----------------------------------- */
set_errno (0);
if (bind ((int) sockHandle, (PSOCKADDR) &sin, sizeof (sin)) != 0)
{
result = xn_getlasterror();
if (result == EADDRINUSE)
{
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_bind: non-fatal error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-2);
}
else
{
#ifdef RTP_DEBUG
RTP_DEBUG_OUTPUT_STR("rtp_net_bind: error returned ");
RTP_DEBUG_OUTPUT_INT(result);
RTP_DEBUG_OUTPUT_STR(".\n");
#endif
return (-1);
}
}
return (0);
}
