rvsocket_.c

h.248协议源码

/*****************************************************************************
Filename   : rvsocket_.c
Description: Socket porting interface definition.
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
******************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision Inc.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision Inc.

RADVision Inc. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:$
$Author: S. Cipolli$
*****************************************************************************/

#include "rvsocket_.h"
#include "rvsocketaddr.h"

#if defined(RV_SOCKETS_BSD)
#if defined(RV_OS_REDHAT) || defined(RV_OS_SOLARIS)
#include <fcntl.h>
#include <sys/file.h>
#endif
#endif

#if defined(RV_SOCKETS_NUCLEUS)
/* redefine stuff for Nucleus so we don't have to special case eveything */
#define accept NU_Accept
#define recvfrom NU_Recv_From

/* Nucleus port numbers have to be unswapped because its not in network order */
#define rvNucPortSwap TLS_Intswap
#endif

#if defined(RV_SOCKETS_PSOS)
   /* pSOS sockets are thread specific and sharable only by the owning task. */
   /* Thus the only way not to leave sockets open is to create them in the */
   /* sharer task, get a shared handle when we need to make a socket call, and */
   /* close that shared handle when we're done. */
#include "rvsharer.h"

long rvSocketBind_(RvSocket socket, const RvSocketAddr *addressPtr) {
	RvSocket oursocket;
	struct sockaddr *saddr;
	int addrlen;
	long result;

	oursocket = rvSharerShareSocket(socket);
	saddr = (struct sockaddr *)rvSocketAddrGetRawAddress(addressPtr);
	addrlen = rvSocketAddrGetLength(addressPtr);
	result = bind(oursocket, saddr, addrlen);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketListen_(RvSocket socket, int backlog) {
	RvSocket oursocket;
	long result;
	
	oursocket = rvSharerShareSocket(socket);
	result = listen(oursocket, backlog);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketConnect_(RvSocket socket, RvSocketAddr *addressPtr) {
	RvSocket oursocket;
	struct sockaddr *saddr;
	int addrlen;
	long result;

	oursocket = rvSharerShareSocket(socket);
	saddr = (struct sockaddr *)rvSocketAddrGetRawAddress(addressPtr);
	addrlen = rvSocketAddrGetLength(addressPtr);
	result = connect(oursocket,  saddr, addrlen);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketSendTo_(RvSocket socket, char *buf, int len, int flags, const RvSocketAddr *addressPtr) {
	RvSocket oursocket;
	struct sockaddr *saddr;
	int addrlen;
	long result;

	oursocket = rvSharerShareSocket(socket);
	saddr = (struct sockaddr *)rvSocketAddrGetRawAddress(addressPtr);
	addrlen = rvSocketAddrGetLength(addressPtr);
	result = sendto(oursocket, buf, len, flags, saddr, addrlen);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketSetSockOpt_(RvSocket socket, int level, int optname, char *optval, int optlen) {
	RvSocket oursocket;
	long result;

	oursocket = rvSharerShareSocket(socket);
	result = setsockopt(oursocket, level, optname, optval, optlen);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketGetSockOpt_(RvSocket socket, int level, int optname, char *optval, int* optlen) {
	RvSocket oursocket;
	long result;

	oursocket = rvSharerShareSocket(socket);
	result = getsockopt(oursocket, level, optname, optval, optlen);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketRecv_(RvSocket socket, char *buffer, int len, int flags) {
	RvSocket oursocket;
	long result;

	oursocket = rvSharerShareSocket(socket);
	result = recv(oursocket, buffer, len, flags);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketSend_(RvSocket socket, char *buf, int len, int flags) {
	RvSocket oursocket;
	long result;

	oursocket = rvSharerShareSocket(socket);
	result = send(oursocket, buf, len, flags);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketBlock_(RvSocket socket)
{
	RvSocket oursocket;
	long result;
	unsigned long blockon = 0;
	
	oursocket = rvSharerShareSocket(socket);
    result = ioctl(oursocket, FIONBIO, &blockon);
	rvSharerClose(oursocket);
	return result;
}

long rvSocketUnblock_(RvSocket socket)
{
	RvSocket oursocket;
	long result;
	unsigned long blockoff = 1;

	oursocket = rvSharerShareSocket(socket);
	result = ioctl(oursocket, FIONBIO, &blockoff);
	rvSharerClose(oursocket);
	return result;
}

#endif

RvBool rvSocketAccept_(RvSocket socket, RvSocket* cSocket, RvSocketAddr *addressPtr)
{			    
	struct sockaddr *saddr;
#if defined(RV_SOCKETS_PSOS)
	RvSocket oursocket;
#endif
	
	saddr = (struct sockaddr *)rvSocketAddrGetRawAddress(addressPtr);
    addressPtr->length = RV_SOCKADDR_MAXSIZE;
#if defined(RV_SOCKETS_PSOS)
	/* See pSOS note above */
	oursocket = rvSharerShareSocket(socket);
	*cSocket = accept(oursocket, saddr, &addressPtr->length);
	rvSharerClose(oursocket);
#else
	*cSocket = accept(socket, saddr, &addressPtr->length);
#endif
#if defined(RV_SOCKETS_NUCLEUS)
	saddr->port = rvNucPortSwap(saddr->port); /* Nucleus internal is unswapped */
#endif
    rvSocketAddrSetProtocolFromSockAddr(addressPtr);
    
    return (*cSocket != -1);
}

RvBool rvSocketGetSockName_(RvSocket socket, RvSocketAddr *addressPtr)
{
    RvBool retVal;
#if defined(RV_SOCKETS_PSOS)
	RvSocket oursocket;
#endif
#if defined(RV_SOCKETS_NUCLEUS)
	struct sockaddr_struct temp;
	struct addr_struct *sptr;
	INT16 len;
#endif

	addressPtr->length = RV_SOCKADDR_MAXSIZE;
#if defined(RV_SOCKETS_NUCLEUS) /* hardcode for Nucleus nonsense */
	len = sizeof(struct sockaddr_struct);
	if(NU_Get_Sock_Name(socket, &temp, &len) == 0) {
		retVal = rvTrue;
		sptr = (struct addr_struct *)&addressPtr->address;
		sptr->family = AF_INET;
		sptr->port = rvNucPortSwap(temp.port_num); /* Nucleus internal is unswapped */
		memcpy(&sptr->id.is_ip_addrs, &temp.ip_num.is_ip_addrs, 4);
	} else retVal = rvFalse;
#else
#if defined(RV_SOCKETS_PSOS)
	/* See pSOS note above */
	oursocket = rvSharerShareSocket(socket);
	retVal = getsockname(oursocket,(struct sockaddr *)&(addressPtr->address), &addressPtr->length) == 0;
	rvSharerClose(oursocket);
#else	
	retVal = getsockname(socket,(struct sockaddr *)&(addressPtr->address), &addressPtr->length) == 0;
#endif
#endif
	rvSocketAddrSetProtocolFromSockAddr(addressPtr);

    return retVal;
}

RvBool rvSocketGetPeerName_(RvSocket socket, RvSocketAddr *addressPtr)
{
    RvBool retVal;
#if defined(RV_SOCKETS_PSOS)
	RvSocket oursocket;
#endif
#if defined(RV_SOCKETS_NUCLEUS)
	struct sockaddr_struct temp;
	struct addr_struct *sptr;
	INT16 len;
	
#endif
	addressPtr->length = RV_SOCKADDR_MAXSIZE;
#if defined(RV_SOCKETS_NUCLEUS) /* hardcode for Nucleus nonsense */
	len = sizeof(struct sockaddr_struct);
	if(NU_Get_Peer_Name(socket, &temp, &len) == 0) {
		retVal = rvTrue;
		sptr = (struct addr_struct *)&addressPtr->address;
		sptr->family = AF_INET;
		sptr->port = rvNucPortSwap(temp.port_num); /* Nucleus internal is unswapped */
		memcpy(&sptr->id.is_ip_addrs, &temp.ip_num.is_ip_addrs, 4);
	} else retVal = rvFalse;
#else
#if defined(RV_SOCKETS_PSOS)
	/* See pSOS note above */
	oursocket = rvSharerShareSocket(socket);
	retVal = getpeername(oursocket,(struct sockaddr *)&(addressPtr->address), &addressPtr->length) == 0;
	rvSharerClose(oursocket);
#else
	retVal = getpeername(socket,(struct sockaddr *)&(addressPtr->address), &addressPtr->length) == 0;
#endif
#endif
	rvSocketAddrSetProtocolFromSockAddr(addressPtr);

    return retVal;
}

int rvSocketRecvFrom_(RvSocket socket, void *buffer, size_t bufferLength, int flags, RvSocketAddr *addressPtr)
{
    int retVal;
	struct sockaddr *saddr;
#if defined(RV_SOCKETS_PSOS)
	RvSocket oursocket;
#endif

	saddr = (struct sockaddr *)rvSocketAddrGetRawAddress(addressPtr);
	addressPtr->length = RV_SOCKADDR_MAXSIZE;
#if defined(RV_SOCKETS_PSOS)
	/* See pSOS note above */
	oursocket = rvSharerShareSocket(socket);
	retVal = recvfrom(oursocket, buffer, bufferLength, flags, saddr, &addressPtr->length);
	rvSharerClose(oursocket);
#else
	retVal = recvfrom(socket, buffer, bufferLength, flags, saddr, &addressPtr->length);
#endif
#if defined(RV_SOCKETS_NUCLEUS)
	saddr->family = AF_INET; /* Nucleus doesn't fill in everything in from address */
	saddr->port = rvNucPortSwap(saddr->port); /* Nucleus internal is unswapped */
#endif
    rvSocketAddrSetProtocolFromSockAddr(addressPtr);

    return retVal;
}

#if defined(RV_SOCKETS_NUCLEUS)
/* deal with Nucleus swapped port address and non-zero return codes */

int rvSocketBind_(RvSocket socket, const RvSocketAddr *addressPtr)
{
	int result;
	struct addr_struct saddr;

	/* Copy the structure since we don't want to mess with callers data */
	memcpy(&saddr, rvSocketAddrGetRawAddress(addressPtr), sizeof(saddr));
	saddr.port = rvNucPortSwap(saddr.port); /* Nucleus internal is unswapped */
	result = NU_Bind(socket, &saddr, sizeof(saddr));
	if(result > 0) result = 0; /* standard bind has 0 == OK, not >= 0 */
	return result;
}

int rvSocketConnect_(RvSocket socket, const RvSocketAddr *addressPtr)
{
	int result;
	struct addr_struct saddr;

	/* Copy the structure since we don't want to mess with callers data */
	memcpy(&saddr, rvSocketAddrGetRawAddress(addressPtr), sizeof(saddr));
	saddr.port = rvNucPortSwap(saddr.port); /* Nucleus internal is unswapped */
	result = NU_Connect(socket, &saddr, sizeof(saddr));
	if(result > 0) result = 0; /* standard bind has 0 == OK, not >= 0 */
	return result;
}

int rvSocketSendTo_(RvSocket socket, char *buf, int nbytes, int flags, const RvSocketAddr *toAddr)
{
	int result;
	struct addr_struct saddr;

	/* Copy the structure since we don't want to mess with callers data */
	memcpy(&saddr, rvSocketAddrGetRawAddress(toAddr), sizeof(saddr));
	saddr.port = rvNucPortSwap(saddr.port); /* Nucleus internal is unswapped */
	result = NU_Send_To(socket, buf, nbytes, flags, &saddr, sizeof(saddr));
	return result;
}

#endif

#if defined(RV_SOCKETS_BSD)
#if defined(RV_OS_REDHAT) || defined(RV_OS_SOLARIS)
int rvSocketBlock_(RvSocket socket)
{
	int fileflags;
	
	fileflags = fcntl(socket, F_GETFL, 0);
	if(fileflags < 0)
		return fileflags;

	if (fcntl(socket, F_SETFL, fileflags | FNDELAY) == -1)
		return -1;
	return 0;
}


int rvSocketUnblock_(RvSocket socket)
{
	int fileflags;

	fileflags = fcntl(socket, F_GETFL, 0);
	if(fileflags < 0)
		return fileflags;

	if (fcntl(socket, F_SETFL, fileflags & (~FNDELAY)) == -1)
		return -1;
	return 0;
}
#endif
#endif