static afs_int32
ListServers(void)
{
afs_int32 code;
int i;
struct VLCallBack vlcb;
struct VLCallBack spare3;
bulkaddrs addrs, m_addrs;
afs_uint32 ip;
afs_int32 base, index;
afsUUID m_uuid;
afs_int32 m_uniq = 0;
afs_int32 m_nentries;
char hoststr[16];
ListAddrByAttributes m_attrs;
memset(&addrs, 0, sizeof(addrs));
memset(&spare3, 0, sizeof(spare3));
code =
ubik_VL_GetAddrs(client, 0, 0, 0, &vlcb,
&server_count, &addrs);
if (code) {
printf("Fatal error: could not get list of file servers\n");
return 1;
}
for (i = 0; i < server_count; ++i) {
ip = addrs.bulkaddrs_val[i];
if (((ip & 0xff000000) == 0xff000000) && (ip & 0xffff)) {
base = (ip >> 16) & 0xff;
index = ip & 0xffff;
/* server is a multihomed host; query the vldb for its addresses,
* and just pick the first one */
if ((base >= 0) && (base <= VL_MAX_ADDREXTBLKS) && (index >= 1)
&& (index <= VL_MHSRV_PERBLK)) {
m_attrs.Mask = VLADDR_INDEX;
m_attrs.index = (base * VL_MHSRV_PERBLK) + index;
m_nentries = 0;
m_addrs.bulkaddrs_val = 0;
m_addrs.bulkaddrs_len = 0;
code = ubik_VL_GetAddrsU(client, 0, &m_attrs, &m_uuid, &m_uniq,
&m_nentries, &m_addrs);
if (code || m_addrs.bulkaddrs_len == 0) {
printf("Error getting multihomed addresses for server "
"%s (index %ld)\n",
afs_inet_ntoa_r(m_addrs.bulkaddrs_val[0], hoststr),
afs_printable_int32_ld(m_attrs.index));
server_id[i] = 0;
} else {
server_id[i] = htonl(m_addrs.bulkaddrs_val[0]);
}
}
} else {
int
VLDB_IsSameAddrs(afs_uint32 serv1, afs_uint32 serv2, afs_int32 *errorp)
{
int code;
ListAddrByAttributes attrs;
bulkaddrs addrs;
afs_uint32 *addrp, i, j, f1, f2;
afs_int32 unique, nentries;
afsUUID uuid;
static int initcache = 0;
*errorp = 0;
if (serv1 == serv2)
return 1;
if (newvlserver == vltype_old || newvlserver == vltype_new) {
return 0;
}
if (!initcache) {
for (i = 0; i < GETADDRUCACHESIZE; i++) {
cacheips[i].server = cacheips[i].count = 0;
}
initcache = 1;
}
/* See if it's cached */
for (i = 0; i < GETADDRUCACHESIZE; i++) {
f1 = f2 = 0;
for (j = 0; j < cacheips[i].count; j++) {
if (serv1 == cacheips[i].addrs[j])
f1 = 1;
else if (serv2 == cacheips[i].addrs[j])
f2 = 1;
if (f1 && f2)
return 1;
}
if (f1 || f2)
return 0;
if (cacheips[i].server == serv1)
return 0;
}
memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_IPADDR;
attrs.ipaddr = serv1;
memset(&addrs, 0, sizeof(addrs));
memset(&uuid, 0, sizeof(uuid));
code =
ubik_VL_GetAddrsU(cstruct, 0, &attrs, &uuid, &unique, &nentries,
&addrs);
if (newvlserver == vltype_unknown) {
if (code == RXGEN_OPCODE) {
return 0;
} else if (!code) {
newvlserver = vltype_uuid;
}
}
if (code == VL_NOENT)
return 0;
if (code) {
*errorp = code;
return 0;
}
code = 0;
if (nentries > GETADDRUCACHESIZE)
nentries = GETADDRUCACHESIZE; /* safety check; should not happen */
if (++cacheip_index >= GETADDRUCACHESIZE)
cacheip_index = 0;
cacheips[cacheip_index].server = serv1;
cacheips[cacheip_index].count = nentries;
addrp = addrs.bulkaddrs_val;
for (i = 0; i < nentries; i++, addrp++) {
cacheips[cacheip_index].addrs[i] = *addrp;
if (serv2 == *addrp) {
code = 1;
}
}
return code;
}
/* takes server in host byte order */
struct afscp_server *
afscp_ServerByAddr(struct afscp_cell *thecell, afs_uint32 addr)
{
/* implement uniquifiers? */
int i, j;
struct afscp_server **newlist;
struct afscp_server **newall;
struct afscp_server *ret = NULL;
afsUUID uuid;
bulkaddrs addrs;
struct ListAddrByAttributes attrs;
afs_int32 nentries, code, uniq;
if (thecell == NULL)
return ret; /* cannot continue without thecell */
for (i = 0; i < thecell->nservers; i++) {
ret = thecell->fsservers[i];
for (j = 0; j < ret->naddrs; j++)
if (ret->addrs[j] == htonl(addr)) {
return ret;
}
}
if (thecell->nservers >= thecell->srvsalloced) {
if (thecell->srvsalloced)
thecell->srvsalloced = thecell->srvsalloced * 2;
else
thecell->srvsalloced = 4;
newlist = realloc(thecell->fsservers,
thecell->srvsalloced * sizeof(struct afscp_server));
if (newlist == NULL) {
return NULL;
}
thecell->fsservers = newlist;
}
ret = malloc(sizeof(struct afscp_server));
if (ret == NULL) {
return NULL;
}
memset(ret, 0, sizeof(struct afscp_server));
thecell->fsservers[thecell->nservers] = ret;
ret->cell = thecell->id;
memset(&uuid, 0, sizeof(uuid));
memset(&addrs, 0, sizeof(addrs));
memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_IPADDR;
attrs.ipaddr = addr;
code = ubik_VL_GetAddrsU(thecell->vlservers, 0, &attrs, &uuid,
&uniq, &nentries, &addrs);
if (code != 0) {
memset(&ret->id, 0, sizeof(uuid));
ret->naddrs = 1;
ret->addrs[0] = htonl(addr);
ret->conns[0] = rx_NewConnection(ret->addrs[0],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
} else {
char s[512];
afsUUID_to_string(&uuid, s, 511);
afs_dprintf(("GetServerByAddr 0x%x -> uuid %s\n", addr, s));
if (nentries > AFS_MAXHOSTS) {
nentries = AFS_MAXHOSTS;
/* XXX I don't want to do *that* much dynamic allocation */
abort();
}
memmove(&ret->id, &uuid, sizeof(afsUUID));
ret->naddrs = nentries;
for (i = 0; i < nentries; i++) {
ret->addrs[i] = htonl(addrs.bulkaddrs_val[i]);
ret->conns[i] = rx_NewConnection(ret->addrs[i],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
}
_xdr_free(_xdr_bulkaddrs, &addrs);
}
thecell->nservers++;
if (afscp_nservers >= afscp_srvsalloced) {
if (afscp_srvsalloced)
afscp_srvsalloced = afscp_srvsalloced * 2;
else
afscp_srvsalloced = 4;
newall = realloc(allservers,
afscp_srvsalloced * sizeof(struct afscp_server *));
if (newall == NULL) {
return ret;
}
allservers = newall;
}
ret->index = afscp_nservers;
allservers[afscp_nservers++] = ret;
return ret;
}
/* takes server in host byte order */
struct afscp_server *
afscp_ServerById(struct afscp_cell *thecell, afsUUID * u)
{
/* impliment uniquifiers? */
int i, code;
struct afscp_server **newlist;
struct afscp_server **newall;
struct afscp_server *ret = NULL;
afsUUID tmp;
bulkaddrs addrs;
struct ListAddrByAttributes attrs;
afs_int32 nentries, uniq;
char s[512];
afsUUID_to_string(u, s, 511);
afs_dprintf(("GetServerByID %s\n", s));
for (i = 0; i < thecell->nservers; i++) {
if (afs_uuid_equal(&thecell->fsservers[i]->id, u)) {
return thecell->fsservers[i];
}
}
if (thecell->nservers >= thecell->srvsalloced) {
if (thecell->srvsalloced)
thecell->srvsalloced = thecell->srvsalloced * 2;
else
thecell->srvsalloced = 4;
newlist = realloc(thecell->fsservers,
thecell->srvsalloced *
sizeof(struct afscp_server *));
if (newlist == NULL) {
return NULL;
}
thecell->fsservers = newlist;
}
ret = malloc(sizeof(struct afscp_server));
if (ret == NULL) {
return NULL;
}
memset(ret, 0, sizeof(struct afscp_server));
thecell->fsservers[thecell->nservers] = ret;
memmove(&ret->id, u, sizeof(afsUUID));
ret->cell = thecell->id;
memset(&tmp, 0, sizeof(tmp));
memset(&addrs, 0, sizeof(addrs));
memset(&attrs, 0, sizeof(attrs));
attrs.Mask = VLADDR_UUID;
memmove(&attrs.uuid, u, sizeof(afsUUID));
code = ubik_VL_GetAddrsU(thecell->vlservers, 0, &attrs, &tmp,
&uniq, &nentries, &addrs);
if (code != 0) {
return NULL;
}
if (nentries > AFS_MAXHOSTS) {
nentries = AFS_MAXHOSTS;
/* XXX I don't want to do *that* much dynamic allocation */
abort();
}
ret->naddrs = nentries;
for (i = 0; i < nentries; i++) {
ret->addrs[i] = htonl(addrs.bulkaddrs_val[i]);
ret->conns[i] = rx_NewConnection(ret->addrs[i],
htons(AFSCONF_FILEPORT),
1, thecell->security,
thecell->scindex);
}
_xdr_free(_xdr_bulkaddrs, &addrs);
thecell->nservers++;
if (afscp_nservers >= afscp_srvsalloced) {
if (afscp_srvsalloced)
afscp_srvsalloced = afscp_srvsalloced * 2;
else
afscp_srvsalloced = 4;
newall = realloc(allservers,
afscp_srvsalloced * sizeof(struct afscp_server *));
if (newall == NULL) {
return ret;
}
allservers = newall;
}
ret->index = afscp_nservers;
allservers[afscp_nservers++] = ret;
return ret;
}
