rvsharer.c

h.248协议源码

#if (0)
******************************************************************************
Filename   :
Description:
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. 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$
******************************************************************************
#endif

/* 
 * The following code implements a socket sharing service required to
 * circumvent thread-local socket concepts like PSoS/PNA.  Other OS's
 * don't use this service at all.
 *
 * The service creates and destroys all sockets from it's thread and
 * allows other threads to request socket sharing.  Once a thread has 
 * shared a given socket, the information is cached so future references
 * to the socket from that thread do not access the service.   
 */

#include "rvplatform.h"
#if defined(RV_SOCKETS_PSOS)

#include "rvdefalloc.h"
#include "rvsharer.h"

static RvSharer rvSharer;

#if defined(RV_DIRTY_SOCKETS)
rvDefineHash(RvSharerKey, int)

size_t rvSharerKeyHash(const RvSharerKey* k) {
	return k->task | k->sock;
}

RvSharerKey* rvSharerKeyConstruct(RvSharerKey* x, int s, int task)
{
	x->sock = s;
	x->task = task;
	return (x);
}

#endif

static void rvSharerThread(RvThread* t, void* data) {
	RvSharer* s = (RvSharer*)data;
	RvSharerCmd* cmd;

	while (rvQueuePop(&rvSharer.server, &cmd) == 0) {
		if (cmd->verb == 'C') {			/* Create sock */
			int sock = socket(cmd->family, cmd->type, cmd->proto);
			rvQueuePush(&rvSharer.client, (void*)sock);
		} else if (cmd->verb == 'D') {	/* Destroy sock */
			int result = close(cmd->sock);
			rvQueuePush(&rvSharer.client, (void*)result);
		} else if (cmd->verb == 'S') {	/* Share sock */
			int sock = shr_socket(cmd->sock, cmd->task);
			rvQueuePush(&rvSharer.client, (void*)sock);
		}
	}
}

#if defined(RV_DIRTY_SOCKETS)
static int* rvSharerFind(RvSharer* s, int sock, int task) {
	RvSharerKey key;
	int* socketRef;

	rvSharerKeyConstruct(&key, sock, task);

	rvMutexLock(&rvSharer.mutex);
	socketRef = rvHashFind(RvSharerKey, int)(&rvSharer.table, &key);
	rvMutexUnlock(&rvSharer.mutex);

	return socketRef;
}

static void rvSharerAdd(RvSharer* s, int sock, int task, 
  int* socketRef) {
	RvSharerKey key;
	
	rvSharerKeyConstruct(&key, sock, task);
	rvHashInsertUnique(RvSharerKey, int)(&rvSharer.table, &key, socketRef);
}

static void rvSharerRemove(RvSharer* s, int sock, int task) {
	RvSharerKey key;
	
	rvSharerKeyConstruct(&key, sock, task);
	rvHashEraseKey(RvSharerKey, int)(&rvSharer.table, &key);
}
#endif

RvBool rvSharerInit(void) {
#if defined(RV_DIRTY_SOCKETS)
	rvHashConstruct(RvSharerKey, int)(&rvSharer.table, 10, rvSharerKeyHash, 
	  &rvDefaultAlloc, &rvDefaultAlloc);
#endif
	rvMutexConstruct(&rvSharer.mutex);
	rvQueueConstruct(&rvSharer.client, 1);
	rvQueueConstruct(&rvSharer.server, 1);
	rvThreadConstruct(&rvSharer.thread, "sharer", RV_PRIORITYVALUE_NORMAL, RV_STACKSIZE_SHARER, rvSharerThread, &rvSharer);
	rvThreadStart(&rvSharer.thread);
	return rvTrue;
}

void rvSharerEnd(void) {
	rvQueueStop(&rvSharer.server);
	rvQueueStop(&rvSharer.client);
	rvThreadDestruct(&rvSharer.thread);
	rvMutexLock(&rvSharer.mutex);
#if defined(RV_DIRTY_SOCKETS)
	rvHashDestruct(RvSharerKey, int)(&rvSharer.table);
#endif
	rvQueueDestruct(&rvSharer.client);
	rvQueueDestruct(&rvSharer.server);
	rvMutexUnlock(&rvSharer.mutex);
	rvMutexDestruct(&rvSharer.mutex);
}

int rvSharerCreateSocket(int family, int type, int proto) {
	RvSharerCmd cmd;
	int sock;

	cmd.verb = 'C';
	cmd.family = family;
	cmd.type = type;
	cmd.proto = proto;

	rvMutexLock(&rvSharer.mutex);
	rvQueuePush(&rvSharer.server, &cmd);
	rvQueuePop(&rvSharer.client, (void**)&sock);
	rvMutexUnlock(&rvSharer.mutex);

	return sock;
}

int rvSharerDestroySocket(int sock) {
	RvSharerCmd cmd;
	int result; 
	int task;

	cmd.verb = 'D';
	cmd.sock = sock;

	task = rvThreadIdCurrent(); 

	rvMutexLock(&rvSharer.mutex);
	rvQueuePush(&rvSharer.server, &cmd);
	rvQueuePop(&rvSharer.client, (void**)&result);
#if defined(RV_DIRTY_SOCKETS)
	rvSharerRemove(&rvSharer, sock, task);
#endif
	rvMutexUnlock(&rvSharer.mutex);

	return result;
}

int rvSharerShareSocket(int sock) {
	RvSharerCmd cmd;
	int* socketRefPtr;
	int socketRef;
	int task;

	task = rvThreadIdCurrent(); 
#if defined(RV_DIRTY_SOCKETS)
	/* Don't bother looking things up. Sharer cache is only used */
	/* with the RV_DIRTY_SOCKETS option */
	if ((socketRefPtr = rvSharerFind(&rvSharer, sock, task)) == NULL) {
#endif
		cmd.verb = 'S';
		cmd.sock = sock;
		cmd.task = task;

		rvMutexLock(&rvSharer.mutex);
		rvQueuePush(&rvSharer.server, &cmd);
		rvQueuePop(&rvSharer.client, (void**)&socketRef);
#if defined(RV_DIRTY_SOCKETS)
		rvSharerAdd(&rvSharer, sock, task, &socketRef);
#endif
		rvMutexUnlock(&rvSharer.mutex);
		socketRefPtr = &socketRef;
#if defined(RV_DIRTY_SOCKETS)
	}
#endif

	return *socketRefPtr;
}

#endif