dce_list.c

Ho Chi Minh City University of Technology Computer Science Department Distributed Computing E

/***************************************
Ho Chi Minh City University of Technology
    Computer Science Department 
Distributed Computing Environment (DCE)
Written by Nguyen Van Noi -59406114
File dce_list.c on Tue Dec 15 15:49:05 1998
****************************************/
#include <stdlib.h>
#include "dce_list.h"
#include "dce_def.h"

PLIST
NewItem (void *pVoid)
{
  PLIST p = (PLIST) malloc (sizeof (List_t));
  if (!p)
    return NULL;
  p->pData = pVoid;
  p->pLink = NULL;
  return p;
}

PLIST
NewList ()
{
  return NewItem (NULL);
}

int
CountList (PLIST plist)
{
  PLIST p = plist->pLink;
  int count = 0;
  while (p)
    {
      p = p->pLink;
      count++;
    }
  return count;
}

void
InsertList (PLIST plist, void *pVoid)
{
  PLIST p = NewItem (pVoid);
  p->pLink = plist->pLink;
  plist->pLink = p;
}

void
DeleteItem (PLIST plist, void *pKey, int (*EQUAL) (void *, void *), void (*FREE) (void *))
{
  PLIST p1 = plist, p2 = plist->pLink;
  while (p2)
    {
      if (EQUAL (p2->pData, pKey))
	{
	  p1->pLink = p2->pLink;
	  if (FREE)
	    FREE (p2->pData);
	  else
	    free (p2->pData);
	  free (p2);
	  p2 = p1->pLink;
	  continue;
	}
      p1 = p2;
      p2 = p2->pLink;
    }
}

void **
ItemLookup (PLIST plist, void *pKey, int (*EQUAL) (void *, void *))
{
  PLIST p = plist->pLink;
  int count = 0;
  void **result;
  while (p)
    {
      if (EQUAL (p->pData, pKey))
	count++;
      p = p->pLink;
    }
  if (!count)
    return NULL;
  result = (void **) calloc (count + 1, sizeof (void *));
  p = plist->pLink;
  count = 0;
  while (p)
    {
      if (EQUAL (p->pData, pKey))
	result[count++] = p->pData;
      p = p->pLink;
    }
  result[count] = NULL;
  return result;
}


void
FreeList (PLIST plist, void (*FREE) (void *))
{
  PLIST p1 = plist;
  while (p1)
    {
      plist = p1->pLink;
      if (FREE)
	FREE (p1->pData);
      else
	free (p1->pData);
      free (p1);
      p1 = plist;
    }
}

int
AddItem (PLIST plist, void *pKey, int (*EQUAL) (void *, void *))
{
  PLIST p = plist->pLink;
  while (p)
    {
      if (EQUAL (p->pData, pKey))
	return 0;
      p = p->pLink;
    }
  InsertList (plist, pKey);
  return 1;
}

void
TravelList (PLIST plist, void (*TRAVEL) (void *))
{
  PLIST p = plist->pLink;
  while (p)
    {
      TRAVEL (p->pData);
      p = p->pLink;
    }
}

/************************************/

int
cmplong (void *p1, void *p2)
{
  long *pi1 = (long *) p1;
  long *pi2 = (long *) p2;
  return (*pi1 == *pi2);
}

int
FindUid (PLIST plist, long uid)
{
  void **pr = ItemLookup (plist, (void *) &uid, cmplong);
  if (!pr)
    return 0;
  free (pr);
  return 1;
}

void
AddUid (PLIST plist, long uid)
{
  long *p;
  if (FindUid (plist, uid))
    return;
  p = (long *) malloc (sizeof (long));
  if (!p)
    return;
  *p = uid;
  InsertList (plist, (void *) p);
}

void
DelUid (PLIST plist, long uid)
{
  DeleteItem (plist, (void *) &uid, cmplong, NULL);
}

/************************************/
PSERVICEINFO
NewService (int param, char *s)
{
  static int _num;
  PSERVICEINFO p = (PSERVICEINFO) malloc (sizeof (SERVICEINFO));
  if (!p)
    return NULL;
  p->num = _num++;
  p->param = param;
  strcpy (p->sername, s);
  return p;
}

int
cmpsrv (void *p1, void *p2)
{
  PSERVICEINFO p = (PSERVICEINFO) p1;
  if (strcmp (p->sername, (char *) p2) == 0)
    return 1;
  return 0;
}

PSERVICEINFO
FindService (PLIST plist, char *s)
{
  PSERVICEINFO p;
  void **pr = ItemLookup (plist, (void *) s, cmpsrv);
  if (!pr)
    return NULL;
  p = (PSERVICEINFO) pr[0];
  free (pr);
  return p;
}
void
AddService (PLIST plist, int param, char *s)
{
  PSERVICEINFO p;
  if (FindService (plist, s))
    return;
  p = NewService (param, s);
  if (!p)
    return;
  InsertList (plist, (void *) p);
}

int
cmpsrvnum (void *p1, void *p2)
{
  int *pi = (int *) p2;
  PSERVICEINFO p = (PSERVICEINFO) p1;
  return (p->num == *pi);
}

PSERVICEINFO
FindServicenum (PLIST plist, int num)
{
  PSERVICEINFO p;
  void **pr = ItemLookup (plist, (void *) &num, cmpsrvnum);
  if (!pr)
    return NULL;
  p = (PSERVICEINFO) pr[0];
  free (pr);
  return p;
}

/************************************/
PUSERSERVICE
NewUserService (int pid, u_long serveraddr, uid_t uid,
		int sernum, u_long clientaddr, time_t time)
{
  PUSERSERVICE p = (PUSERSERVICE) malloc (sizeof (USERSERVICE));
  if (!p)
    return NULL;
  p->pid = pid;
  p->serveraddr = serveraddr;
  p->uid = uid;
  p->sernum = sernum;
  p->clientaddr = clientaddr;
  p->tEnd = 0;
  p->tStart = time;
  p->time = 2 * TIMEOUT_IAMALIVE + 1;
  p->status = 1;
  return p;
}

int _pid;
int
cmpuserservice (void *p1, void *p2)
{
  PUSERSERVICE p = (PUSERSERVICE) p1;
  u_long *pu = (u_long *) p2;
  return ((p->pid == _pid) && (p->serveraddr == *pu));
}

PUSERSERVICE
FindUserService (PLIST plist, int pid, u_long serveraddr)
{
  PUSERSERVICE p;
  void **pr;
  _pid = pid;
  if (!(pr = ItemLookup (plist, (void *) &serveraddr, cmpuserservice)))
    return NULL;
  p = (PUSERSERVICE) pr[0];
  free (pr);
  return p;
}
void
dcetimeuserservice (void *pt)
{
  PUSERSERVICE p = (PUSERSERVICE) pt;
  if (p->time > 0)
    p->time -= TIMEOUT_IAMALIVE;
  else
    p->status = 0;
}

void
DecTimeUserService (PLIST plist)
{
  TravelList (plist, dcetimeuserservice);
}