dce_sinfo.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_sinfo.c on Mon Dec 21 14:44:53 1998
****************************************/
#include <values.h>
#include "dce_agent.h"

PSINFO
NewSinfo (int order, u_long addr)
{
  PSINFO p = (PSINFO) malloc (sizeof (SINFO));
  if (!p)
    return NULL;
  p->order = order;
  p->addr = addr;
  p->load = 0;
  p->status = 1;
  p->time = 2 * TIMEOUT_IAMALIVE + 1;
  return p;
}

void
DecTime (void *pt)
{
  PSINFO p = (PSINFO) pt;
  if (p->time >= 0)
    p->time -= TIMEOUT_IAMALIVE;
  else
    p->status = 0;
}
void
dce_agent_dcetime ()
{
  TravelList (Agent.pListServer, DecTime);
}

int _MaxOrder;
void
MaXOrder (void *pt)
{
  PSINFO p = (PSINFO) pt;
  if (_MaxOrder < p->order)
    _MaxOrder = p->order;
}

int
dce_agent_find_maxorder ()
{
  _MaxOrder = 0;
  TravelList (Agent.pListServer, MaXOrder);
  return _MaxOrder;
}
double _load;
PSINFO _ps;

void
MinLoad (void *pt)
{
  PSINFO p = (PSINFO) pt;
  if ((_load <= p->load) || (p->status == 0))
    return;
  _load = p->load;
  _ps = p;
}

u_long
dce_agent_findminload ()
{
  _load = MAXDOUBLE;
  _ps = NULL;
  TravelList (Agent.pListServer, MinLoad);
  if (_ps)
    return _ps->addr;
  return -1;
}
int
cmpsinfo (void *p1, void *p2)
{
  PSINFO p = (PSINFO) p1;
  u_long *pu = (u_long *) p2;
  if (*pu == p->addr)
    {
      p->load = msg.load;
      p->status = 1;
      p->time = 2 * TIMEOUT_IAMALIVE + 1;
      return 1;
    }
  return 0;
}
void
dce_agent_update_newmsg ()
{
  PSINFO p;
  void **pr = ItemLookup (Agent.pListServer, (void *) &msg.saddr, cmpsinfo);
  if (pr)
    {
      free (pr);
      return;
    }
  p = NewSinfo (msg.order, msg.saddr);
  if (!p)
    return;
  p->load = msg.load;
  InsertList (Agent.pListServer, (void *) p);
}
int _n;
void
writesinfosock (void *p)
{
  write (_n, (void *) &Agent.Msg, sizeof (MSG));
  write (_n, p, sizeof (SINFO));
}
void
dce_agent_writesinfosock (int n)
{
  _n = n;
  TravelList (Agent.pListServer, writesinfosock);
}
int
cmppp (void *p1, void *p2)
{
  PSINFO p = (PSINFO) p1;
  u_long *pu = (u_long *) p2;
  if (*pu == p->addr)
    return 1;
  return 0;

}
int
dce_agent_findserverinlist (u_long u)
{
  void **pr = ItemLookup (Agent.pListServer, (void *) &u, cmppp);
  if (!pr)
    return 0;
  free (pr);
  return 1;
}

void
dce_agent_delete_server (u_long u)
{
  DeleteItem (Agent.pListServer, (void *) &u, cmppp, NULL);
}

void
cmppalive (void *pt)
{
  PSINFO p = (PSINFO) pt;
  if (p->status == 1)
    _MaxOrder++;

}
int
dce_agent_findhowserveralive ()
{
  _MaxOrder = 0;
  TravelList (Agent.pListServer, cmppalive);
  return _MaxOrder;

}

void
writeuserinfo (void *p)
{
  long *pl = (long *) p;
  Agent.Msg.lextra = *pl;
  write (_n, (void *) &Agent.Msg, sizeof (MSG));
}

void
dce_agent_writeuserlist (int n)
{
  _n = n;
  TravelList (Agent.pUserList, writeuserinfo);
}

void
userbroadcast (void *p)
{
  long *pl = (long *) p;
  Agent.Msg.lextra = *pl;
  dce_agent_mcastsend ((char *) &Agent.Msg, sizeof (MSG));
}

void
dce_agent_userbroadcast ()
{
  TravelList (Agent.pUserList, userbroadcast);
}

void
writeservice (void *pt)
{
  PSERVICEINFO p = (PSERVICEINFO) pt;
  Agent.Msg.pid = p->num;
  Agent.Msg.nextra = p->param;
  strcpy (Agent.Msg.sername, p->sername);
  write (_n, (void *) &Agent.Msg, sizeof (MSG));
}

void
dce_agent_writeservicelist (int n)
{
  _n = n;
  TravelList (Agent.pService, writeservice);
}

void
servicebroadcast (void *pt)
{
  PSERVICEINFO p = (PSERVICEINFO) pt;
  Agent.Msg.nextra = p->param;
  strcpy (Agent.Msg.sername, p->sername);
  dce_agent_mcastsend ((char *) &Agent.Msg, sizeof (MSG));
}
void
dce_agent_servicebroadcast ()
{
  TravelList (Agent.pService, servicebroadcast);
}

void
writeuserservice (void *p)
{
  write (_n, (void *) &Agent.Msg, sizeof (MSG));
  write (_n, p, sizeof (USERSERVICE));
}

void
dce_agent_writecuruserservice (int n)
{
  _n = n;
  TravelList (Agent.pCurUserService, writeuserservice);
}

void
userservicebroadcast (void *pt)
{
  PUSERSERVICE p = (PUSERSERVICE) pt;
  msg.type = DCE_MSG_ALL_REPLY_ALL_USERSERVICE;
  msg.who = UNKNOWN;
  msg.pid = p->pid;
  msg.saddr = p->serveraddr;
  msg.uid = p->uid;
  msg.nextra = p->sernum;
  msg.aaddr = p->clientaddr;
  msg.lextra = p->tStart;
  msg.lextra1 = p->tEnd;
  msg.sport = p->time;
  dce_agent_mcastsend ((char *) &msg, sizeof (MSG));
}
void
dce_agent_userservicebroadcast ()
{
  TravelList (Agent.pCurUserService, userservicebroadcast);
}