static int
PrintInterfaces(struct rx_connection *aconn)
{
Capabilities caps;
struct interfaceAddr addr;
#ifdef AFS_NT40_ENV
char * p;
#else
char uuidstr[128];
#endif
int i, code;
char hoststr[16];
caps.Capabilities_val = NULL;
caps.Capabilities_len = 0;
code = RXAFSCB_TellMeAboutYourself(aconn, &addr, &caps);
if (code == RXGEN_OPCODE)
code = RXAFSCB_WhoAreYou(aconn, &addr);
if (code) {
printf("cmdebug: error checking interfaces: %s\n",
afs_error_message(code));
return 0;
}
#ifdef AFS_NT40_ENV
UuidToString((UUID *)&addr.uuid, &p);
printf("UUID: %s\n",p);
RpcStringFree(&p);
#else
afsUUID_to_string(&addr.uuid, uuidstr, sizeof(uuidstr));
printf("UUID: %s\n",uuidstr);
#endif
printf("Host interfaces:\n");
for (i = 0; i < addr.numberOfInterfaces; i++) {
printf("%s", afs_inet_ntoa_r(htonl(addr.addr_in[i]), hoststr));
if (addr.subnetmask[i])
printf(", netmask %s", afs_inet_ntoa_r(htonl(addr.subnetmask[i]), hoststr));
if (addr.mtu[i])
printf(", MTU %d", addr.mtu[i]);
printf("\n");
}
if (caps.Capabilities_val) {
printf("Capabilities:\n");
if (caps.Capabilities_val[0] & CAPABILITY_ERRORTRANS) {
printf("Error Translation\n");
}
printf("\n");
}
if (caps.Capabilities_val)
free(caps.Capabilities_val);
caps.Capabilities_val = NULL;
caps.Capabilities_len = 0;
return 0;
}
static void
dump_hdr(void)
{
char uuid_str[40];
afs_uint32 hi, lo;
if (get_hdr())
return;
DPFOFF(map);
DPFSO0("fs_state_header");
DPFSO1("stamp");
DPFX2("magic", hdrs.hdr.stamp.magic);
DPFV2("version", "u", hdrs.hdr.stamp.version);
DPFSC1;
DPFT1("timestamp", hdrs.hdr.timestamp);
DPFV1("sys_name", "u", hdrs.hdr.sys_name);
afsUUID_to_string(&hdrs.hdr.server_uuid, uuid_str, sizeof(uuid_str));
DPFS1("server_uuid", uuid_str);
DPFV1("valid", "d", hdrs.hdr.valid);
DPFV1("endianness", "d", hdrs.hdr.endianness);
DPFV1("stats_detailed", "d", hdrs.hdr.stats_detailed);
SplitInt64(hdrs.hdr.h_offset, hi, lo);
DPFSO1("h_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
SplitInt64(hdrs.hdr.cb_offset, hi, lo);
DPFSO1("cb_offset");
DPFV2("hi", "u", hi);
DPFV2("lo", "u", lo);
DPFSC1;
DPFS1("server_version_string", hdrs.hdr.server_version_string);
DPFSC0;
if (hdrs.hdr.stamp.magic != FS_STATE_MAGIC) {
fprintf(stderr, "* magic check failed\n");
}
if (hdrs.hdr.stamp.version != FS_STATE_VERSION) {
fprintf(stderr, "* version check failed\n");
}
}
static void
dump_he_interfaces(void)
{
char temp_str[40];
struct Interface * ifp;
int len, i;
char hoststr[16];
if (!he_cursor.hdr.interfaces)
return;
len = sizeof(struct Interface) + ((he_cursor.hdr.interfaces-1)*sizeof(struct AddrPort));
ifp = malloc(len);
assert(ifp != NULL);
memcpy(ifp, he_cursor.ifp, len);
DPFSO0("Interface");
DPFV1("numberOfInterfaces", "u", ifp->numberOfInterfaces);
afsUUID_to_string(&ifp->uuid, temp_str, sizeof(temp_str));
DPFS1("uuid", temp_str);
for (i = 0; i < he_cursor.hdr.interfaces; i++) {
snprintf(temp_str, sizeof(temp_str), "interface[%d]", i);
DPFSO1(temp_str);
DPFS2("addr", afs_inet_ntoa_r(ifp->interface[i].addr, hoststr));
DPFV2("port", "u", ifp->interface[i].port);
DPFSC1;
}
DPFSC0;
if (he_cursor.hdr.interfaces != ifp->numberOfInterfaces) {
fprintf(stderr, "* interface count mismatch between header and Interface struct\n");
}
free(ifp);
}
/* 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;
}
