haiku.git

#include "RPCPendingCalls.h"
#include <string.h>

extern bool conf_no_check_ip_xid;

extern void 
PendingCallInit(struct PendingCall *call)
{
	call->buffer=NULL;
}

extern void 
PendingCallDestroy(struct PendingCall *call)
{
	free (call->buffer);
}

extern void 
RPCPendingCallsInit(struct RPCPendingCalls *calls)
{
	SemaphorePoolInit(&calls->fPool);
	
	calls->fFirst=NULL;
	calls->fSem=create_sem(1,"RPCPendingCalls");
	set_sem_owner (calls->fSem,B_SYSTEM_TEAM);
}

extern void 
RPCPendingCallsDestroy(struct RPCPendingCalls *calls)
{
	delete_sem(calls->fSem);
	
	while (calls->fFirst)
	{
		struct PendingCall *next=calls->fFirst->next;
		
		SemaphorePoolPut (&calls->fPool,calls->fFirst->sem);
		PendingCallDestroy (calls->fFirst);
		free (calls->fFirst);

		calls->fFirst=next;
	}
	
	SemaphorePoolDestroy (&calls->fPool);
}

extern struct PendingCall *
RPCPendingCallsAddPendingCall (struct RPCPendingCalls *calls,
								int32 xid, const struct sockaddr_in *addr)
{
	struct PendingCall *call=(struct PendingCall *)malloc(sizeof(struct PendingCall));
	PendingCallInit (call);
	
	call->sem=SemaphorePoolGet(&calls->fPool);
		
	memcpy(&call->addr,addr,sizeof(struct sockaddr_in));
	call->xid=xid;

	while (acquire_sem (calls->fSem)==B_INTERRUPTED);
	
	call->next=calls->fFirst;
	calls->fFirst=call;

	while (release_sem (calls->fSem)==B_INTERRUPTED);
	
	return call;
}

extern struct PendingCall *
RPCPendingCallsFindAndRemovePendingCall (struct RPCPendingCalls *calls,
										int32 xid, const struct sockaddr_in *addr)
{
	struct PendingCall *last=NULL;
	struct PendingCall *current;
	
	while (acquire_sem (calls->fSem)==B_INTERRUPTED);
	
	current=calls->fFirst; // mmu_man
	
	while (current)
	{
		if (current->xid==xid)
		{
			if (((current->addr.sin_addr.s_addr==addr->sin_addr.s_addr)&&
				(current->addr.sin_port==addr->sin_port)) || conf_no_check_ip_xid)
			{	
				if (last)
					last->next=current->next;
				else
					calls->fFirst=current->next;

				current->next=NULL;			
				
				while (release_sem (calls->fSem)==B_INTERRUPTED);
				return current;
			}
		}

		last=current;
		current=current->next;
	}
	
	while (release_sem (calls->fSem)==B_INTERRUPTED);
	
	return NULL;
}

extern void 
SemaphorePoolInit(struct SemaphorePool *pool)
{
	pool->fPool=NULL;
	pool->fPoolCount=0;
	pool->fPoolSize=0;
	
	pool->fPoolSem=create_sem(1,"semaphore_pool_sem");
	set_sem_owner (pool->fPoolSem,B_SYSTEM_TEAM);
}

extern void 
SemaphorePoolDestroy(struct SemaphorePool *pool)
{
	int32 i;
	
	for (i=0;i<pool->fPoolCount;i++)
		delete_sem (pool->fPool[i]);

	free (pool->fPool);
	
	delete_sem (pool->fPoolSem);
}

extern sem_id 
SemaphorePoolGet(struct SemaphorePool *pool)
{
	sem_id sem;
	
	while (acquire_sem(pool->fPoolSem)==B_INTERRUPTED)
	{
	}
	
	if (pool->fPoolCount==0)
	{
		sem=create_sem (0,"pending_call");
		
		while (release_sem(pool->fPoolSem)==B_INTERRUPTED)
		{
		}
		
		return sem;
	}

	sem=pool->fPool[pool->fPoolCount-1];
	pool->fPoolCount--;

	while (release_sem(pool->fPoolSem)==B_INTERRUPTED)
	{
	}
	
	return sem;
}

extern void 
SemaphorePoolPut(struct SemaphorePool *pool, sem_id sem)
{
	while (acquire_sem(pool->fPoolSem)==B_INTERRUPTED)
	{
	}

	if (pool->fPoolCount+1>pool->fPoolSize)
	{
		pool->fPoolSize+=8;
		pool->fPool=(sem_id *)realloc(pool->fPool,pool->fPoolSize*sizeof(sem_id));
	}

	pool->fPool[pool->fPoolCount]=sem;
	pool->fPoolCount++;
	
	while (release_sem(pool->fPoolSem)==B_INTERRUPTED)
	{
	}
}