static ConnCacheEntry * add_connection(int32_t cell, uint32_t host, uint16_t port, uint16_t service, int (*probe)(struct rx_connection *), CredCacheEntry *ce) { ConnCacheEntry *e; struct rx_securityClass *securityobj; int securityindex; nnpfs_pag_t cred; if (ce) { securityindex = ce->securityindex; cred = ce->cred; switch (ce->type) { #ifdef KERBEROS case CRED_KRB4 : { struct cred_rxkad *cred = (struct cred_rxkad *)ce->cred_data; securityobj = rxkad_NewClientSecurityObject(conn_rxkad_level, cred->ct.HandShakeKey, cred->ct.AuthHandle, cred->ticket_len, cred->ticket); break; } #endif case CRED_NONE : securityobj = rxnull_NewClientSecurityObject (); break; default : errx(1, "Unknown credentials type %d\n", ce->type); } } else { securityobj = rxnull_NewClientSecurityObject (); securityindex = 0; cred = 0; } e = new_connection (cell, host, port, service, cred, securityindex, probe, securityobj); hashtabadd (connhtab, (void *)e); ++nactive_connections; return e; }
struct rx_securityClass * get_sc(char *cellname) { #if 0 char realm[REALM_SZ]; CREDENTIALS c; #endif return rxnull_NewClientSecurityObject(); #if 0 ucstring(realm, cellname, REALM_SZ); if (krb_get_cred("afs", "", realm, &c)) { if (get_ad_tkt("afs", "", realm, DEFAULT_TKT_LIFE)) { return NULL; } else { if (krb_get_cred("afs", "", realm, &c)) { return NULL; } } } return rxkad_NewClientSecurityObject(rxkad_clear, c.session, c.kvno, c.ticket_st.length, c.ticket_st.dat); #endif }
/** * Pick a security object to use for a connection to a given server, * by a given user * * @param[in] conn * The AFS connection for which the security object is required * @param[out] secLevel * The security level of the returned object * * @return * An rx security object. This function is guaranteed to return * an object, although that object may be rxnull (with a secLevel * of 0) */ static struct rx_securityClass * afs_pickSecurityObject(struct afs_conn *conn, int *secLevel) { struct rx_securityClass *secObj = NULL; union tokenUnion *token; /* Do we have tokens ? */ if (conn->parent->user->states & UHasTokens) { token = afs_FindToken(conn->parent->user->tokens, RX_SECIDX_KAD); if (token) { *secLevel = RX_SECIDX_KAD; /* kerberos tickets on channel 2 */ secObj = rxkad_NewClientSecurityObject( cryptall ? rxkad_crypt : rxkad_clear, (struct ktc_encryptionKey *) token->rxkad.clearToken.HandShakeKey, token->rxkad.clearToken.AuthHandle, token->rxkad.ticketLen, token->rxkad.ticket); /* We're going to use this token, so populate the viced */ conn->parent->user->viceId = token->rxkad.clearToken.ViceId; } } if (secObj == NULL) { *secLevel = 0; secObj = rxnull_NewClientSecurityObject(); } return secObj; }
static int notify_client (struct ropa_client *c, AFSCBFids *fids, AFSCBs *cbs) { #ifdef NO_CALLBACKS return 0; #else int i, ret; if (c->conn) { ret = RXAFSCB_CallBack (c->conn, fids, cbs); if (ret == 0) return ret; } for (i = 0; i < c->numberOfInterfaces ; i++) { uint16_t port = c->port; DIAGNOSTIC_CHECK_ADDR(&c->addr[i]); c->conn = rx_NewConnection (c->addr[i].addr_in, port, CM_SERVICE_ID, rxnull_NewClientSecurityObject(), 0); mlog_log (MDEBROPA, "notify_client: notifying %x", c->addr[i].addr_in); ret = RXAFSCB_CallBack (c->conn, fids, cbs); if (ret) rx_DestroyConnection (c->conn); else break; /* XXX warn */ } return ret; #endif }
afs_int32 pxclient_Initialize(int auth, afs_int32 serverAddr) { afs_int32 code; rx_securityIndex scIndex; struct rx_securityClass *sc; code = rx_Init(htons(2115) /*0 */ ); if (code) { fprintf(stderr, "pxclient_Initialize: Could not initialize rx.\n"); return code; } scIndex = RX_SECIDX_NULL; rx_SetRxDeadTime(50); sc = rxnull_NewClientSecurityObject(); serverconns[0] = rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex); code = ubik_ClientInit(serverconns, &cstruct); if (code) { fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n"); return code; } return 0; }
static int _GetNullSecurityObject(struct afscp_cell *cell) { cell->security = (struct rx_securityClass *)rxnull_NewClientSecurityObject(); cell->scindex = RX_SECIDX_NULL; return 0; }
/*! * Pick a security class to use for an outgoing connection * * This function selects an RX security class to use for an outgoing * connection, based on the set of security flags provided. * * @param[in] dir * The configuration directory structure for this cell. If NULL, * no classes requiring local configuration will be returned. * @param[in] flags * A set of flags to determine the properties of the security class which * is selected * - AFSCONF_SECOPTS_NOAUTH - return an anonymous secirty class * - AFSCONF_SECOPTS_LOCALAUTH - use classes which have local key * material available. * - AFSCONF_SECOPTS_ALWAYSENCRYPT - use classes in encrypting, rather * than authentication or integrity modes. * - AFSCONF_SECOPTS_FALLBACK_NULL - if no suitable class can be found, * then fallback to the rxnull security class. * @param[in] info * The cell information structure for the current cell. If this is NULL, * then use a version locally obtained using the cellName. * @param[in] cellName * The cellName to use when obtaining cell information (may be NULL if * info is specified) * @param[out] sc * The selected security class * @param[out] scIndex * The index of the selected security class * @param[out] expires * The expiry time of the tokens used to construct the class. Will be * NEVER_DATE if the class has an unlimited lifetime. If NULL, the * function won't store the expiry date. * * @return * Returns 0 on success, or a com_err error code on failure. */ afs_int32 afsconf_PickClientSecObj(struct afsconf_dir *dir, afsconf_secflags flags, struct afsconf_cell *info, char *cellName, struct rx_securityClass **sc, afs_int32 *scIndex, time_t *expires) { struct afsconf_cell localInfo; afs_int32 code = 0; *sc = NULL; *scIndex = RX_SECIDX_NULL; if (expires) expires = 0; if ( !(flags & AFSCONF_SECOPTS_NOAUTH) ) { if (!dir) return AFSCONF_NOCELLDB; if (flags & AFSCONF_SECOPTS_LOCALAUTH) { code = afsconf_GetLatestKey(dir, 0, 0); if (code) goto out; if (flags & AFSCONF_SECOPTS_ALWAYSENCRYPT) code = afsconf_ClientAuthSecure(dir, sc, scIndex); else code = afsconf_ClientAuth(dir, sc, scIndex); if (code) goto out; if (expires) *expires = NEVERDATE; } else { if (info == NULL) { code = afsconf_GetCellInfo(dir, cellName, NULL, &localInfo); if (code) goto out; info = &localInfo; } code = afsconf_ClientAuthToken(info, flags, sc, scIndex, expires); if (code && !(flags & AFSCONF_SECOPTS_FALLBACK_NULL)) goto out; /* If we didn't get a token, we'll just run anonymously */ code = 0; } } if (*sc == NULL) { *sc = rxnull_NewClientSecurityObject(); *scIndex = RX_SECIDX_NULL; if (expires) *expires = NEVERDATE; } out: return code; }
/* return a null security object if nothing else can be done */ static afs_int32 QuickAuth(struct rx_securityClass **astr, afs_int32 *aindex) { register struct rx_securityClass *tc; tc = rxnull_NewClientSecurityObject(); *astr = tc; *aindex = RX_SECIDX_NULL; return 0; }
int udbLocalInit(void) { afs_uint32 serverList[MAXSERVERS]; char hostname[256]; char *args[3]; int i; afs_int32 code; /* get our host name */ gethostname(hostname, sizeof(hostname)); /* strcpy(hostname, "hops"); */ args[0] = ""; args[1] = "-servers"; args[2] = hostname; code = ubik_ParseClientList(3, args, serverList); if (code) { afs_com_err(whoami, code, "; udbLocalInit: parsing ubik server list"); return (-1); } udbHandle.uh_scIndex = RX_SECIDX_NULL; udbHandle.uh_secobj = (struct rx_securityClass *) rxnull_NewClientSecurityObject(); for (i = 0; serverList[i] != 0; i++) { udbHandle.uh_serverConn[i] = rx_NewConnection(serverList[i], htons(AFSCONF_BUDBPORT), BUDB_SERVICE, udbHandle.uh_secobj, udbHandle.uh_scIndex); if (udbHandle.uh_serverConn[i] == 0) { afs_com_err(whoami, 0, "connection %d failed", i); continue; } } udbHandle.uh_serverConn[i] = 0; code = ubik_ClientInit(udbHandle.uh_serverConn, &udbHandle.uh_client); if (code) { afs_com_err(whoami, code, "; in ubik_ClientInit"); return (code); } code = ubik_BUDB_GetInstanceId(udbHandle.uh_client, 0, &udbHandle.uh_instanceId); if (code) { afs_com_err(whoami, code, "; Can't estblish instance Id"); return (code); } /* abort: */ return (0); }
static void get_sec(int serverp, struct rx_securityClass **sec, int *secureindex) { if (serverp) { *sec = rxnull_NewServerSecurityObject(); *secureindex = 1; } else { *sec = rxnull_NewClientSecurityObject(); *secureindex = 0; } }
int main(int argc, char **argv) { struct rx_securityClass *rxsc; struct rx_connection *tconn; afs_int32 code; rx_Init(0); rxsc = rxnull_NewClientSecurityObject(); tconn = rx_NewConnection(htonl(0x7f000001), htons(BC_MESSAGEPORT), 1, rxsc, 0); code = BC_Print(tconn, 1, 2, argv[1]); printf("Done, code %d\n", code); exit(0); }
afs_int32 pxclient_Initialize(int auth, afs_int32 serverAddr) { afs_int32 code; afs_int32 scIndex; struct rx_securityClass *sc; code = rx_Init(htons(2115) /*0 */ ); if (code) { fprintf(stderr, "pxclient_Initialize: Could not initialize rx.\n"); return code; } scIndex = 0; rx_SetRxDeadTime(50); switch (scIndex) { case 0: sc = rxnull_NewClientSecurityObject(); break; #ifdef notdef /* security */ case 1: sc = rxvab_NewClientSecurityObject(&ttoken.sessionKey, ttoken.ticket, 0); break; case 2: sc = rxkad_NewClientSecurityObject(rxkad_clear, &ttoken.sessionKey, ttoken.kvno, ttoken.ticketLen, ttoken.ticket); #endif /* notdef */ } serverconns[0] = rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex); code = ubik_ClientInit(serverconns, &cstruct); if (code) { fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n"); return code; } return 0; }
/** * Pick a security object to use for a connection to a given server, * by a given user * * @param[in] conn * The AFS connection for which the security object is required * @param[out] secLevel * The security level of the returned object * * @return * An rx security object. This function is guaranteed to return * an object, although that object may be rxnull (with a secLevel * of 0) */ static struct rx_securityClass * afs_pickSecurityObject(struct afs_conn *conn, int *secLevel) { struct rx_securityClass *secObj = NULL; /* Do we have tokens ? */ if (conn->user->vid != UNDEFVID) { *secLevel = 2; /* kerberos tickets on channel 2 */ secObj = rxkad_NewClientSecurityObject( cryptall ? rxkad_crypt : rxkad_clear, (struct ktc_encryptionKey *)conn->user->ct.HandShakeKey, conn->user->ct.AuthHandle, conn->user->stLen, conn->user->stp); } if (secObj == NULL) { *secLevel = 0; secObj = rxnull_NewClientSecurityObject(); } return secObj; }
static int CommandProc(struct cmd_syndesc *as, void *arock) { char *hostName, *portName, *times; afs_int32 hostAddr; register afs_int32 i, j, code; short port; int int32p; time_t now, then, diff, newtime; struct hostent *th; struct rx_connection *tconn; struct rx_securityClass *sc; struct ubik_debug udebug; struct ubik_sdebug usdebug; int oldServer = 0; /* are we talking to a pre 3.5 server? */ afs_int32 isClone = 0; int32p = (as->parms[2].items ? 1 : 0); if (as->parms[0].items) hostName = as->parms[0].items->data; else hostName = NULL; if (as->parms[1].items) portName = as->parms[1].items->data; else portName = NULL; /* lookup host */ if (hostName) { th = hostutil_GetHostByName(hostName); if (!th) { printf("udebug: host %s not found in host table\n", hostName); exit(1); } memcpy(&hostAddr, th->h_addr, sizeof(afs_int32)); } else hostAddr = htonl(0x7f000001); /* IP localhost */ if (!portName) port = htons(3000); /* default */ else { port = PortNumber(portName); if (port < 0) port = PortName(portName); if (port < 0) { printf("udebug: can't resolve port name %s\n", portName); exit(1); } port = htons(port); } rx_Init(0); sc = rxnull_NewClientSecurityObject(); tconn = rx_NewConnection(hostAddr, port, VOTE_SERVICE_ID, sc, 0); /* now do the main call */ code = VOTE_XDebug(tconn, &udebug, &isClone); if (code) code = VOTE_Debug(tconn, &udebug); if (code == RXGEN_OPCODE) { oldServer = 1; /* talking to a pre 3.5 server */ memset(&udebug, 0, sizeof(udebug)); code = VOTE_DebugOld(tconn, &udebug); } if (code) { printf("return code %d from VOTE_Debug\n", code); exit(0); } now = time(0); then = udebug.now; /* now print the main info */ times = ctime(&then); times[24] = 0; if (!oldServer) { printf("Host's addresses are: "); for (j = 0; udebug.interfaceAddr[j] && (j < UBIK_MAX_INTERFACE_ADDR); j++) printf("%s ", afs_inet_ntoa(htonl(udebug.interfaceAddr[j]))); printf("\n"); } printf("Host's %s time is %s\n", afs_inet_ntoa(hostAddr), times); times = ctime(&now); times[24] = 0; diff = now - udebug.now; printf("Local time is %s (time differential %d secs)\n", times, (int)diff); if (abs((int)diff) >= MAXSKEW) printf("****clock may be bad\n"); /* UBIK skips the voting if 1 server - so we fudge it here */ if (udebug.amSyncSite && (udebug.nServers == 1)) { udebug.lastYesHost = hostAddr; udebug.lastYesTime = udebug.now; udebug.lastYesState = 1; udebug.lastYesClaim = udebug.now; udebug.syncVersion.epoch = udebug.localVersion.epoch; udebug.syncVersion.counter = udebug.localVersion.counter; } /* sockaddr is always in net-order */ if (udebug.lastYesHost == 0xffffffff) { printf("Last yes vote not cast yet \n"); } else { diff = udebug.now - udebug.lastYesTime; printf("Last yes vote for %s was %d secs ago (%ssync site); \n", afs_inet_ntoa(udebug.lastYesHost), (int)diff, ((udebug.lastYesState) ? "" : "not ")); diff = udebug.now - udebug.lastYesClaim; newtime = now - diff; times = ctime(&newtime); times[24] = 0; printf("Last vote started %d secs ago (at %s)\n", (int)diff, times); } printf("Local db version is %d.%d\n", udebug.localVersion.epoch, udebug.localVersion.counter); if (udebug.amSyncSite) { if (udebug.syncSiteUntil == 0x7fffffff) { printf("I am sync site forever (%d server%s)\n", udebug.nServers, ((udebug.nServers > 1) ? "s" : "")); } else { diff = udebug.syncSiteUntil - udebug.now; newtime = now + diff; times = ctime(&newtime); times[24] = 0; printf ("I am sync site until %d secs from now (at %s) (%d server%s)\n", (int)diff, times, udebug.nServers, ((udebug.nServers > 1) ? "s" : "")); } printf("Recovery state %x\n", udebug.recoveryState); if (udebug.activeWrite) { printf("I am currently managing write trans %d.%d\n", udebug.epochTime, udebug.tidCounter); } } else { if (isClone) printf("I am a clone and never can become sync site\n"); else printf("I am not sync site\n"); diff = udebug.now - udebug.lowestTime; printf("Lowest host %s was set %d secs ago\n", afs_inet_ntoa(htonl(udebug.lowestHost)), (int)diff); diff = udebug.now - udebug.syncTime; printf("Sync host %s was set %d secs ago\n", afs_inet_ntoa(htonl(udebug.syncHost)), (int)diff); } printf("Sync site's db version is %d.%d\n", udebug.syncVersion.epoch, udebug.syncVersion.counter); printf("%d locked pages, %d of them for write\n", udebug.lockedPages, udebug.writeLockedPages); if (udebug.anyReadLocks) printf("There are read locks held\n"); if (udebug.anyWriteLocks) printf("There are write locks held\n"); if (udebug.currentTrans) { if (udebug.writeTrans) printf("There is an active write transaction\n"); else printf("There is at least one active read transaction\n"); printf("Transaction tid is %d.%d\n", udebug.syncTid.epoch, udebug.syncTid.counter); } if (udebug.epochTime) { diff = udebug.now - udebug.epochTime; newtime = now - diff; times = ctime(&newtime); times[24] = 0; printf ("Last time a new db version was labelled was:\n\t %d secs ago (at %s)\n", (int)diff, times); } if (int32p || udebug.amSyncSite) { /* now do the subcalls */ for (i = 0;; i++) { isClone = 0; code = VOTE_XSDebug(tconn, i, &usdebug, &isClone); if (code < 0) { if (oldServer) { /* pre 3.5 server */ memset(&usdebug, 0, sizeof(usdebug)); code = VOTE_SDebugOld(tconn, i, &usdebug); } else code = VOTE_SDebug(tconn, i, &usdebug); } if (code > 0) break; /* done */ if (code < 0) { printf("error code %d from VOTE_SDebug\n", code); break; } /* otherwise print the structure */ printf("\nServer (%s", afs_inet_ntoa(htonl(usdebug.addr))); for (j = 0; ((usdebug.altAddr[j]) && (j < UBIK_MAX_INTERFACE_ADDR - 1)); j++) printf(" %s", afs_inet_ntoa(htonl(usdebug.altAddr[j]))); printf("): (db %d.%d)", usdebug.remoteVersion.epoch, usdebug.remoteVersion.counter); if (isClone) printf(" is only a clone!"); printf("\n"); if (usdebug.lastVoteTime == 0) { printf(" last vote never rcvd \n"); } else { diff = udebug.now - usdebug.lastVoteTime; newtime = now - diff; times = ctime(&newtime); times[24] = 0; printf(" last vote rcvd %d secs ago (at %s),\n", (int)diff, times); } if (usdebug.lastBeaconSent == 0) { printf(" last beacon never sent \n"); } else { diff = udebug.now - usdebug.lastBeaconSent; newtime = now - diff; times = ctime(&newtime); times[24] = 0; printf (" last beacon sent %d secs ago (at %s), last vote was %s\n", (int)diff, times, ((usdebug.lastVote) ? "yes" : "no")); } printf(" dbcurrent=%d, up=%d beaconSince=%d\n", usdebug.currentDB, usdebug.up, usdebug.beaconSinceDown); } } return (0); }
afs_int32 pr_Initialize(IN afs_int32 secLevel, IN const char *confDir, IN char *cell) { afs_int32 code; struct rx_connection *serverconns[MAXSERVERS]; struct rx_securityClass *sc = NULL; static struct afsconf_dir *tdir = (struct afsconf_dir *)NULL; /* only do this once */ static char tconfDir[100] = ""; static char tcell[64] = ""; afs_int32 scIndex; afs_int32 secFlags; static struct afsconf_cell info; afs_int32 i; #if !defined(UKERNEL) char cellstr[64]; #endif afs_int32 gottdir = 0; afs_int32 refresh = 0; initialize_PT_error_table(); initialize_RXK_error_table(); initialize_ACFG_error_table(); initialize_KTC_error_table(); #if defined(UKERNEL) if (!cell) { cell = afs_LclCellName; } #else /* defined(UKERNEL) */ if (!cell) { if (!tdir) tdir = afsconf_Open(confDir); if (!tdir) { if (confDir && strcmp(confDir, "")) fprintf(stderr, "%s: Could not open configuration directory: %s.\n", whoami, confDir); else fprintf(stderr, "%s: No configuration directory specified.\n", whoami); return -1; } gottdir = 1; code = afsconf_GetLocalCell(tdir, cellstr, sizeof(cellstr)); if (code) { fprintf(stderr, "libprot: Could not get local cell. [%d]\n", code); return code; } cell = cellstr; } #endif /* defined(UKERNEL) */ if (tdir == NULL || strcmp(confDir, tconfDir) || strcmp(cell, tcell)) { /* * force re-evaluation. we either don't have an afsconf_dir, * the directory has changed or the cell has changed. */ if (tdir && !gottdir) { afsconf_Close(tdir); tdir = (struct afsconf_dir *)NULL; } pruclient = (struct ubik_client *)NULL; refresh = 1; } if (refresh) { strncpy(tconfDir, confDir, sizeof(tconfDir)); strncpy(tcell, cell, sizeof(tcell)); #if defined(UKERNEL) tdir = afs_cdir; #else /* defined(UKERNEL) */ if (!gottdir) tdir = afsconf_Open(confDir); if (!tdir) { if (confDir && strcmp(confDir, "")) fprintf(stderr, "libprot: Could not open configuration directory: %s.\n", confDir); else fprintf(stderr, "libprot: No configuration directory specified.\n"); return -1; } #endif /* defined(UKERNEL) */ code = afsconf_GetCellInfo(tdir, cell, "afsprot", &info); if (code) { fprintf(stderr, "libprot: Could not locate cell %s in %s/%s\n", cell, confDir, AFSDIR_CELLSERVDB_FILE); return code; } } /* If we already have a client and it is at the security level we * want, don't get a new one. Unless the security level is 2 in * which case we will get one (and re-read the key file). */ if (pruclient && (lastLevel == secLevel) && (secLevel != 2)) { return 0; } code = rx_Init(0); if (code) { fprintf(stderr, "libprot: Could not initialize rx.\n"); return code; } /* Most callers use secLevel==1, however, the fileserver uses secLevel==2 * to force use of the KeyFile. secLevel == 0 implies -noauth was * specified. */ if (secLevel == 2) { code = afsconf_GetLatestKey(tdir, 0, 0); if (code) { afs_com_err(whoami, code, "(getting key from local KeyFile)\n"); } else { /* If secLevel is two assume we're on a file server and use * ClientAuthSecure if possible. */ code = afsconf_ClientAuthSecure(tdir, &sc, &scIndex); if (code) afs_com_err(whoami, code, "(calling client secure)\n"); } } else if (secLevel > 0) { secFlags = 0; if (secLevel > 1) secFlags |= AFSCONF_SECOPTS_ALWAYSENCRYPT; code = afsconf_ClientAuthToken(&info, secFlags, &sc, &scIndex, NULL); if (code) { afs_com_err(whoami, code, "(getting token)"); if (secLevel > 1) return code; } } if (sc == NULL) { sc = rxnull_NewClientSecurityObject(); scIndex = RX_SECIDX_NULL; } if ((scIndex == RX_SECIDX_NULL) && (secLevel != 0)) fprintf(stderr, "%s: Could not get afs tokens, running unauthenticated\n", whoami); memset(serverconns, 0, sizeof(serverconns)); /* terminate list!!! */ for (i = 0; i < info.numServers; i++) serverconns[i] = rx_NewConnection(info.hostAddr[i].sin_addr.s_addr, info.hostAddr[i].sin_port, PRSRV, sc, scIndex); code = ubik_ClientInit(serverconns, &pruclient); if (code) { afs_com_err(whoami, code, "ubik client init failed."); return code; } lastLevel = scIndex; code = rxs_Release(sc); return code; }
static struct ropa_client * client_query (uint32_t host, uint16_t port) { struct ropa_client *c, *c_new; int ret; c = client_query_notalkback(host, port); if (c == NULL) { interfaceAddr remote; struct rx_connection *conn = NULL; c = obtain_client(); assert (c->state == ROPAC_FREE && c->li == NULL); c->state = ROPAC_LOOKUP_U; c->flags |= ROPAF_LOOKUP; client_init (c, host, port, NULL, NULL); conn = rx_NewConnection (host, port, CM_SERVICE_ID, rxnull_NewClientSecurityObject(), 0); if (conn == NULL) { free(c); return NULL; } retry: switch (c->state) { case ROPAC_DEAD: c->li = listaddtail (lru_clients, c); ret = ENETDOWN; break; case ROPAC_LOOKUP_U: ret = RXAFSCB_WhoAreYou (conn, &remote); if (ret == RXGEN_OPCODE) { c->state = ROPAC_LOOKUP; goto retry; } else if (ret == RX_CALL_DEAD) { c->state = ROPAC_DEAD; goto retry; } else { struct ropa_client ckey; ckey.uuid = remote.uuid; c_new = hashtabsearch (ht_clients_uuid, &ckey); if (c_new == NULL) { client_init (c, host, port, &remote.uuid, NULL); ret = RXAFSCB_InitCallBackState3(conn, &server_uuid); } else { client_update_interfaces (c_new, host, port, &remote); disconnect_client (c); c = c_new; listdel(lru_clients, c->li); c->li = NULL; } } break; case ROPAC_LOOKUP: { afsUUID uuid; ret = RXAFSCB_InitCallBackState(conn); if (ret == RX_CALL_DEAD) { c->state = ROPAC_DEAD; goto retry; } uuid_init_simple (&uuid, host); client_init (c, host, port, &uuid, NULL); break; } default: exit(-1); } rx_DestroyConnection (conn); if ((c->flags & ROPAF_WAITING) != 0) LWP_NoYieldSignal (c); c->flags &= ~(ROPAF_LOOKUP|ROPAF_WAITING); if (ret) { assert (c->li != NULL); return NULL; } assert (c->li == NULL); c->li = listaddhead (lru_clients, c); } else { /* c != NULL */ if ((c->flags & ROPAF_LOOKUP) != 0) { c->flags |= ROPAF_WAITING; LWP_WaitProcess (c); } assert (c->li != NULL); } return c; }
int xstat_fs_Init(int a_numServers, struct sockaddr_in *a_socketArray, int a_ProbeFreqInSecs, int (*a_ProbeHandler) (void), int a_flags, int a_numCollections, afs_int32 * a_collIDP) { static char rn[] = "xstat_fs_Init"; /*Routine name */ afs_int32 code; /*Return value */ static struct rx_securityClass *CBsecobj; /*Callback security object */ struct rx_securityClass *secobj; /*Client security object */ struct rx_service *rxsrv_afsserver; /*Server for AFS */ int arg_errfound; /*Argument error found? */ int curr_srv; /*Current server idx */ struct xstat_fs_ConnectionInfo *curr_conn; /*Ptr to current conn */ char *hostNameFound; /*Ptr to returned host name */ int conn_err; /*Connection error? */ int collIDBytes; /*Num bytes in coll ID array */ char hoststr[16]; /* * If we've already been called, snicker at the bozo, gently * remind him of his doubtful heritage, and return success. */ if (xstat_fs_initflag) { fprintf(stderr, "[%s] Called multiple times!\n", rn); return (0); } else xstat_fs_initflag = 1; /* * Check the parameters for bogosities. */ arg_errfound = 0; if (a_numServers <= 0) { fprintf(stderr, "[%s] Illegal number of servers: %d\n", rn, a_numServers); arg_errfound = 1; } if (a_socketArray == (struct sockaddr_in *)0) { fprintf(stderr, "[%s] Null server socket array argument\n", rn); arg_errfound = 1; } if (a_ProbeFreqInSecs <= 0) { fprintf(stderr, "[%s] Illegal probe frequency: %d\n", rn, a_ProbeFreqInSecs); arg_errfound = 1; } if (a_ProbeHandler == (int (*)())0) { fprintf(stderr, "[%s] Null probe handler function argument\n", rn); arg_errfound = 1; } if (a_numCollections <= 0) { fprintf(stderr, "[%s] Illegal collection count argument: %d\n", rn, a_numServers); arg_errfound = 1; } if (a_collIDP == NULL) { fprintf(stderr, "[%s] Null collection ID array argument\n", rn); arg_errfound = 1; } if (arg_errfound) return (-1); /* * Record our passed-in info. */ xstat_fs_debug = (a_flags & XSTAT_FS_INITFLAG_DEBUGGING); xstat_fs_oneShot = (a_flags & XSTAT_FS_INITFLAG_ONE_SHOT); xstat_fs_numServers = a_numServers; xstat_fs_Handler = a_ProbeHandler; xstat_fs_ProbeFreqInSecs = a_ProbeFreqInSecs; xstat_fs_numCollections = a_numCollections; collIDBytes = xstat_fs_numCollections * sizeof(afs_int32); xstat_fs_collIDP = malloc(collIDBytes); memcpy(xstat_fs_collIDP, a_collIDP, collIDBytes); if (xstat_fs_debug) { printf("[%s] Asking for %d collection(s): ", rn, xstat_fs_numCollections); for (curr_srv = 0; curr_srv < xstat_fs_numCollections; curr_srv++) printf("%d ", *(xstat_fs_collIDP + curr_srv)); printf("\n"); } /* * Get ready in case we have to do a cleanup - basically, zero * everything out. */ code = xstat_fs_CleanupInit(); if (code) return (code); /* * Allocate the necessary data structures and initialize everything * else. */ xstat_fs_ConnInfo = malloc(a_numServers * sizeof(struct xstat_fs_ConnectionInfo)); if (xstat_fs_ConnInfo == (struct xstat_fs_ConnectionInfo *)0) { fprintf(stderr, "[%s] Can't allocate %d connection info structs (%" AFS_SIZET_FMT " bytes)\n", rn, a_numServers, (a_numServers * sizeof(struct xstat_fs_ConnectionInfo))); return (-1); /*No cleanup needs to be done yet */ } /* * Initialize the Rx subsystem, just in case nobody's done it. */ if (xstat_fs_debug) printf("[%s] Initializing Rx\n", rn); code = rx_Init(0); if (code) { fprintf(stderr, "[%s] Fatal error in rx_Init()\n", rn); return (-1); } if (xstat_fs_debug) printf("[%s] Rx initialized\n", rn); /* * Create a null Rx server security object, to be used by the * Callback listener. */ CBsecobj = (struct rx_securityClass *) rxnull_NewServerSecurityObject(); if (CBsecobj == (struct rx_securityClass *)0) { fprintf(stderr, "[%s] Can't create callback listener's security object.\n", rn); xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (xstat_fs_debug) printf("[%s] Callback server security object created\n", rn); /* * Create a null Rx client security object, to be used by the * probe LWP. */ secobj = rxnull_NewClientSecurityObject(); if (secobj == (struct rx_securityClass *)0) { fprintf(stderr, "[%s] Can't create probe LWP client security object.\n", rn); xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (xstat_fs_debug) printf("[%s] Probe LWP client security object created\n", rn); curr_conn = xstat_fs_ConnInfo; conn_err = 0; for (curr_srv = 0; curr_srv < a_numServers; curr_srv++) { /* * Copy in the socket info for the current server, resolve its * printable name if possible. */ if (xstat_fs_debug) { char hoststr[16]; printf("[%s] Copying in the following socket info:\n", rn); printf("[%s] IP addr %s, port %d\n", rn, afs_inet_ntoa_r((a_socketArray + curr_srv)->sin_addr.s_addr,hoststr), ntohs((a_socketArray + curr_srv)->sin_port)); } memcpy(&(curr_conn->skt), a_socketArray + curr_srv, sizeof(struct sockaddr_in)); hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr); if (hostNameFound == NULL) { fprintf(stderr, "[%s] Can't map Internet address %s to a string name\n", rn, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr)); curr_conn->hostName[0] = '\0'; } else { strcpy(curr_conn->hostName, hostNameFound); if (xstat_fs_debug) printf("[%s] Host name for server index %d is %s\n", rn, curr_srv, curr_conn->hostName); } /* * Make an Rx connection to the current server. */ if (xstat_fs_debug) printf ("[%s] Connecting to srv idx %d, IP addr %s, port %d, service 1\n", rn, curr_srv, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr), ntohs(curr_conn->skt.sin_port)); curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */ curr_conn->skt.sin_port, /*Server port */ 1, /*AFS service # */ secobj, /*Security obj */ 0); /*# of above */ if (curr_conn->rxconn == (struct rx_connection *)0) { fprintf(stderr, "[%s] Can't create Rx connection to server '%s' (%s)\n", rn, curr_conn->hostName, afs_inet_ntoa_r(curr_conn->skt.sin_addr.s_addr,hoststr)); conn_err = 1; } if (xstat_fs_debug) printf("[%s] New connection at %" AFS_PTR_FMT "\n", rn, curr_conn->rxconn); /* * Bump the current xstat_fs connection to set up. */ curr_conn++; } /*for curr_srv */ /* * Create the AFS callback service (listener). */ if (xstat_fs_debug) printf("[%s] Creating AFS callback listener\n", rn); rxsrv_afsserver = rx_NewService(0, /*Use default port */ 1, /*Service ID */ "afs", /*Service name */ &CBsecobj, /*Ptr to security object(s) */ 1, /*# of security objects */ RXAFSCB_ExecuteRequest); /*Dispatcher */ if (rxsrv_afsserver == (struct rx_service *)0) { fprintf(stderr, "[%s] Can't create callback Rx service/listener\n", rn); xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (xstat_fs_debug) printf("[%s] Callback listener created\n", rn); /* * Start up the AFS callback service. */ if (xstat_fs_debug) printf("[%s] Starting up callback listener.\n", rn); rx_StartServer(0); /*Don't donate yourself to LWP pool */ /* * Start up the probe LWP. */ if (xstat_fs_debug) printf("[%s] Creating the probe LWP\n", rn); code = LWP_CreateProcess(xstat_fs_LWP, /*Function to start up */ LWP_STACK_SIZE, /*Stack size in bytes */ 1, /*Priority */ (void *)0, /*Parameters */ "xstat_fs Worker", /*Name to use */ &probeLWP_ID); /*Returned LWP process ID */ if (code) { fprintf(stderr, "[%s] Can't create xstat_fs LWP! Error is %d\n", rn, code); xstat_fs_Cleanup(1); /*Delete already-malloc'ed areas */ return (code); } if (xstat_fs_debug) printf("[%s] Probe LWP process structure located at %" AFS_PTR_FMT "\n", rn, probeLWP_ID); /* * Return the final results. */ if (conn_err) return (-2); else return (0); }
int fsprobe_Init(int a_numServers, struct sockaddr_in *a_socketArray, int a_ProbeFreqInSecs, int (*a_ProbeHandler)(void), int a_debug) { /*fsprobe_Init */ static char rn[] = "fsprobe_Init"; /*Routine name */ register afs_int32 code; /*Return value */ static struct rx_securityClass *CBsecobj; /*Callback security object */ struct rx_securityClass *secobj; /*Client security object */ struct rx_service *rxsrv_afsserver; /*Server for AFS */ int arg_errfound; /*Argument error found? */ int curr_srv; /*Current server idx */ struct fsprobe_ConnectionInfo *curr_conn; /*Ptr to current conn */ char *hostNameFound; /*Ptr to returned host name */ int conn_err; /*Connection error? */ int PortToUse; /*Callback port to use */ /* * If we've already been called, snicker at the bozo, gently * remind him of his doubtful heritage, and return success. */ if (fsprobe_initflag) { fprintf(stderr, "[%s] Called multiple times!\n", rn); return (0); } else fsprobe_initflag = 1; /* * Check the parameters for bogosities. */ arg_errfound = 0; if (a_numServers <= 0) { fprintf(stderr, "[%s] Illegal number of servers: %d\n", rn, a_numServers); arg_errfound = 1; } if (a_socketArray == (struct sockaddr_in *)0) { fprintf(stderr, "[%s] Null server socket array argument\n", rn); arg_errfound = 1; } if (a_ProbeFreqInSecs <= 0) { fprintf(stderr, "[%s] Illegal probe frequency: %d\n", rn, a_ProbeFreqInSecs); arg_errfound = 1; } if (a_ProbeHandler == (int (*)())0) { fprintf(stderr, "[%s] Null probe handler function argument\n", rn); arg_errfound = 1; } if (arg_errfound) return (-1); /* * Record our passed-in info. */ fsprobe_debug = a_debug; fsprobe_numServers = a_numServers; fsprobe_Handler = a_ProbeHandler; fsprobe_ProbeFreqInSecs = a_ProbeFreqInSecs; /* * Get ready in case we have to do a cleanup - basically, zero * everything out. */ fsprobe_CleanupInit(); /* * Allocate the necessary data structures and initialize everything * else. */ fsprobe_ConnInfo = (struct fsprobe_ConnectionInfo *) malloc(a_numServers * sizeof(struct fsprobe_ConnectionInfo)); if (fsprobe_ConnInfo == (struct fsprobe_ConnectionInfo *)0) { fprintf(stderr, "[%s] Can't allocate %d connection info structs (%"AFS_SIZET_FMT" bytes)\n", rn, a_numServers, (a_numServers * sizeof(struct fsprobe_ConnectionInfo))); return (-1); /*No cleanup needs to be done yet */ } #if 0 else fprintf(stderr, "[%s] fsprobe_ConnInfo allocated (%d bytes)\n", rn, a_numServers * sizeof(struct fsprobe_ConnectionInfo)); #endif /* 0 */ fsprobe_statsBytes = a_numServers * sizeof(struct ProbeViceStatistics); fsprobe_Results.stats = (struct ProbeViceStatistics *) malloc(fsprobe_statsBytes); if (fsprobe_Results.stats == NULL) { fprintf(stderr, "[%s] Can't allocate %d statistics structs (%d bytes)\n", rn, a_numServers, fsprobe_statsBytes); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } else if (fsprobe_debug) fprintf(stderr, "[%s] fsprobe_Results.stats allocated (%d bytes)\n", rn, fsprobe_statsBytes); fsprobe_probeOKBytes = a_numServers * sizeof(int); fsprobe_Results.probeOK = (int *)malloc(fsprobe_probeOKBytes); if (fsprobe_Results.probeOK == (int *)0) { fprintf(stderr, "[%s] Can't allocate %d probeOK array entries (%d bytes)\n", rn, a_numServers, fsprobe_probeOKBytes); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } else if (fsprobe_debug) fprintf(stderr, "[%s] fsprobe_Results.probeOK allocated (%d bytes)\n", rn, fsprobe_probeOKBytes); fsprobe_Results.probeNum = 0; fsprobe_Results.probeTime = 0; memset(fsprobe_Results.stats, 0, (a_numServers * sizeof(struct ProbeViceStatistics))); /* * Initialize the Rx subsystem, just in case nobody's done it. */ if (fsprobe_debug) fprintf(stderr, "[%s] Initializing Rx\n", rn); PortToUse = FSPROBE_CBPORT; do { code = rx_Init(htons(PortToUse)); if (code) { if (code == RX_ADDRINUSE) { if (fsprobe_debug) fprintf(stderr, "[%s] Callback port %d in use, advancing\n", rn, PortToUse); PortToUse++; } else { fprintf(stderr, "[%s] Fatal error in rx_Init()\n", rn); return (-1); } } } while (code); if (fsprobe_debug) fprintf(stderr, "[%s] Rx initialized on port %d\n", rn, PortToUse); /* * Create a null Rx server security object, to be used by the * Callback listener. */ CBsecobj = rxnull_NewServerSecurityObject(); if (CBsecobj == (struct rx_securityClass *)0) { fprintf(stderr, "[%s] Can't create null security object for the callback listener.\n", rn); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (fsprobe_debug) fprintf(stderr, "[%s] Callback server security object created\n", rn); /* * Create a null Rx client security object, to be used by the * probe LWP. */ secobj = rxnull_NewClientSecurityObject(); if (secobj == (struct rx_securityClass *)0) { fprintf(stderr, "[%s] Can't create client security object for probe LWP.\n", rn); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (fsprobe_debug) fprintf(stderr, "[%s] Probe LWP client security object created\n", rn); curr_conn = fsprobe_ConnInfo; conn_err = 0; for (curr_srv = 0; curr_srv < a_numServers; curr_srv++) { /* * Copy in the socket info for the current server, resolve its * printable name if possible. */ if (fsprobe_debug) { fprintf(stderr, "[%s] Copying in the following socket info:\n", rn); fprintf(stderr, "[%s] IP addr 0x%x, port %d\n", rn, (a_socketArray + curr_srv)->sin_addr.s_addr, (a_socketArray + curr_srv)->sin_port); } memcpy(&(curr_conn->skt), a_socketArray + curr_srv, sizeof(struct sockaddr_in)); hostNameFound = hostutil_GetNameByINet(curr_conn->skt.sin_addr.s_addr); if (hostNameFound == NULL) { fprintf(stderr, "[%s] Can't map Internet address %u to a string name\n", rn, curr_conn->skt.sin_addr.s_addr); curr_conn->hostName[0] = '\0'; } else { strcpy(curr_conn->hostName, hostNameFound); if (fsprobe_debug) fprintf(stderr, "[%s] Host name for server index %d is %s\n", rn, curr_srv, curr_conn->hostName); } /* * Make an Rx connection to the current server. */ if (fsprobe_debug) fprintf(stderr, "[%s] Connecting to srv idx %d, IP addr 0x%x, port %d, service 1\n", rn, curr_srv, curr_conn->skt.sin_addr.s_addr, curr_conn->skt.sin_port); curr_conn->rxconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */ curr_conn->skt.sin_port, /*Server port */ 1, /*AFS service num */ secobj, /*Security object */ 0); /*Number of above */ if (curr_conn->rxconn == (struct rx_connection *)0) { fprintf(stderr, "[%s] Can't create Rx connection to server %s (%u)\n", rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr); conn_err = 1; } if (fsprobe_debug) fprintf(stderr, "[%s] New connection at %p\n", rn, curr_conn->rxconn); /* * Make an Rx connection to the current volume server. */ if (fsprobe_debug) fprintf(stderr, "[%s] Connecting to srv idx %d, IP addr 0x%x, port %d, service 1\n", rn, curr_srv, curr_conn->skt.sin_addr.s_addr, htons(7005)); curr_conn->rxVolconn = rx_NewConnection(curr_conn->skt.sin_addr.s_addr, /*Server addr */ htons(AFSCONF_VOLUMEPORT), /*Volume Server port */ VOLSERVICE_ID, /*AFS service num */ secobj, /*Security object */ 0); /*Number of above */ if (curr_conn->rxVolconn == (struct rx_connection *)0) { fprintf(stderr, "[%s] Can't create Rx connection to volume server %s (%u)\n", rn, curr_conn->hostName, curr_conn->skt.sin_addr.s_addr); conn_err = 1; } else { int i, cnt; memset(&curr_conn->partList, 0, sizeof(struct partList)); curr_conn->partCnt = 0; i = XListPartitions(curr_conn->rxVolconn, &curr_conn->partList, &cnt); if (!i) { curr_conn->partCnt = cnt; } } if (fsprobe_debug) fprintf(stderr, "[%s] New connection at %p\n", rn, curr_conn->rxVolconn); /* * Bump the current fsprobe connection to set up. */ curr_conn++; } /*for curr_srv */ /* * Create the AFS callback service (listener). */ if (fsprobe_debug) fprintf(stderr, "[%s] Creating AFS callback listener\n", rn); rxsrv_afsserver = rx_NewService(0, /*Use default port */ 1, /*Service ID */ "afs", /*Service name */ &CBsecobj, /*Ptr to security object(s) */ 1, /*Number of security objects */ RXAFSCB_ExecuteRequest); /*Dispatcher */ if (rxsrv_afsserver == (struct rx_service *)0) { fprintf(stderr, "[%s] Can't create callback Rx service/listener\n", rn); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (-1); } if (fsprobe_debug) fprintf(stderr, "[%s] Callback listener created\n", rn); /* * Start up the AFS callback service. */ if (fsprobe_debug) fprintf(stderr, "[%s] Starting up callback listener.\n", rn); rx_StartServer(0 /*Don't donate yourself to LWP pool */ ); /* * Start up the probe LWP. */ if (fsprobe_debug) fprintf(stderr, "[%s] Creating the probe LWP\n", rn); code = LWP_CreateProcess(fsprobe_LWP, /*Function to start up */ LWP_STACK_SIZE, /*Stack size in bytes */ 1, /*Priority */ (void *)0, /*Parameters */ "fsprobe Worker", /*Name to use */ &probeLWP_ID); /*Returned LWP process ID */ if (code) { fprintf(stderr, "[%s] Can't create fsprobe LWP! Error is %d\n", rn, code); fsprobe_Cleanup(1); /*Delete already-malloc'ed areas */ return (code); } if (fsprobe_debug) fprintf(stderr, "[%s] Probe LWP process structure located at %p\n", rn, probeLWP_ID); #if 0 /* * Do I need to do this? */ if (fsprobe_debug) fprintf(stderr, "[%s] Calling osi_Wakeup()\n", rn); osi_Wakeup(&rxsrv_afsserver); /*Wake up anyone waiting for it */ #endif /* 0 */ /* * Return the final results. */ if (conn_err) return (-2); else return (0); } /*fsprobe_Init */
long rxkst_StartClient(struct clientParms *parms) { long code; long host; long scIndex; struct rx_securityClass *sc; whoami = parms->whoami; /* set this global variable */ host = GetServer(parms->server); if (parms->authentication >= 0) { long kvno = 0; char ticket[MAXKTCTICKETLEN]; int ticketLen; struct ktc_encryptionKey Ksession; if (parms->useTokens) code = GetToken(&kvno, &Ksession, &ticketLen, ticket, parms->cell); else code = GetTicket(&kvno, &Ksession, &ticketLen, ticket, parms->cell); if (code) return code; /* next, we have ticket, kvno and session key, authenticate the conn */ sc = (struct rx_securityClass *) rxkad_NewClientSecurityObject(parms->authentication, &Ksession, kvno, ticketLen, ticket); assert(sc); scIndex = RX_SECIDX_KAD; } else { /* unauthenticated connection */ sc = rxnull_NewClientSecurityObject(); assert(sc); scIndex = RX_SECIDX_NULL; } code = 0; if (!code && parms->callTest) { code = RunCallTest(parms, host, sc, scIndex); } if (!code && parms->hijackTest) { code = RunHijackTest(parms, host, sc, scIndex); } if (!code && (parms->printTiming || parms->fastCalls || parms->slowCalls || parms->copiousCalls)) { struct rx_connection *conn; conn = rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc, scIndex); if (conn) { code = RepeatLoadTest(parms, conn); rx_DestroyConnection(conn); } else code = RXKST_NEWCONNFAILED; } if (!code && parms->stopServer) { struct rx_connection *conn; conn = rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc, scIndex); if (conn) { code = RXKST_Kill(conn); if (code) { afs_com_err(whoami, code, "trying to stop server"); } rx_DestroyConnection(conn); } else code = RXKST_NEWCONNFAILED; } if (parms->printStats) { rx_PrintStats(stdout); #if 0 /* use rxdebug style iteration here */ rx_PrintPeerStats(stdout, rx_PeerOf(conn)); #endif } rxs_Release(sc); rx_Finalize(); if (code) { afs_com_err(parms->whoami, code, "test fails"); exit(13); } else { printf("Test Okay\n"); if (!parms->noExit) exit(0); } return 0; }
int main(int argc, char **argv) { char *hostname; struct hostent *hostent; afs_uint32 host; int logstdout = 0; struct rx_connection *conn; struct rx_call *call; struct rx_peer *peer; int err = 0; int nCalls = 1, nBytes = 1; int bufferSize = 4000000; char *buffer; char *sendFile = 0; int setFD = 0; int jumbo = 0; #if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) setlinebuf(stdout); rxi_syscallp = test_syscall; #endif argv++; argc--; while (argc && **argv == '-') { if (strcmp(*argv, "-silent") == 0) print = 0; if (strcmp(*argv, "-jumbo") == 0) jumbo = 1; else if (strcmp(*argv, "-nc") == 0) nCalls = atoi(*++argv), argc--; else if (strcmp(*argv, "-nb") == 0) nBytes = atoi(*++argv), argc--; else if (strcmp(*argv, "-np") == 0) rx_nPackets = atoi(*++argv), argc--; else if (!strcmp(*argv, "-nsf")) rxi_nSendFrags = atoi(*++argv), argc--; else if (!strcmp(*argv, "-nrf")) rxi_nRecvFrags = atoi(*++argv), argc--; else if (strcmp(*argv, "-twind") == 0) rx_initSendWindow = atoi(*++argv), argc--; else if (strcmp(*argv, "-rwind") == 0) rx_initReceiveWindow = atoi(*++argv), argc--; else if (strcmp(*argv, "-rxlog") == 0) rxlog = 1; else if (strcmp(*argv, "-logstdout") == 0) logstdout = 1; else if (strcmp(*argv, "-eventlog") == 0) eventlog = 1; else if (strcmp(*argv, "-drop") == 0) { #ifdef RXDEBUG rx_intentionallyDroppedPacketsPer100 = atoi(*++argv), argc--; #else fprintf(stderr, "ERROR: Compiled without RXDEBUG\n"); #endif } else if (strcmp(*argv, "-burst") == 0) { burst = atoi(*++argv), argc--; burstTime.sec = atoi(*++argv), argc--; burstTime.usec = atoi(*++argv), argc--; } else if (strcmp(*argv, "-retry") == 0) { retryTime.sec = atoi(*++argv), argc--; retryTime.usec = atoi(*++argv), argc--; } else if (strcmp(*argv, "-timeout") == 0) timeout = atoi(*++argv), argc--; else if (strcmp(*argv, "-fill") == 0) fillPackets++; else if (strcmp(*argv, "-file") == 0) sendFile = *++argv, argc--; else if (strcmp(*argv, "-timereadvs") == 0) timeReadvs = 1; else if (strcmp(*argv, "-wait") == 0) { /* Wait time between calls--to test lastack code */ waitTime.sec = atoi(*++argv), argc--; waitTime.usec = atoi(*++argv), argc--; } else if (strcmp(*argv, "-compute") == 0) { /* Simulated "compute" time for each call--to test acknowledgement protocol. This is simulated by doing an iomgr_select: imperfect, admittedly. */ computeTime.sec = atoi(*++argv), argc--; computeTime.usec = atoi(*++argv), argc--; } else if (strcmp(*argv, "-fd") == 0) { /* Open at least this many fd's. */ setFD = atoi(*++argv), argc--; } else { err = 1; break; } argv++, argc--; } if (err || argc != 1) Quit("usage: rx_ctest [-silent] [-rxlog] [-eventlog] [-nc NCALLS] [-np NPACKETS] hostname"); hostname = *argv++, argc--; if (rxlog || eventlog) { if (logstdout) debugFile = stdout; else debugFile = fopen("rx_ctest.db", "w"); if (debugFile == NULL) Quit("Couldn't open rx_ctest.db"); if (rxlog) rx_debugFile = debugFile; if (eventlog) rxevent_debugFile = debugFile; } signal(SIGINT, intSignal); /*Changed to sigquit since dbx is broken right now */ #ifndef AFS_NT40_ENV signal(SIGQUIT, quitSignal); #endif #ifdef AFS_NT40_ENV if (afs_winsockInit() < 0) { printf("Can't initialize winsock.\n"); exit(1); } rx_EnableHotThread(); #endif rx_SetUdpBufSize(256 * 1024); if (!jumbo) rx_SetNoJumbo(); hostent = gethostbyname(hostname); if (!hostent) Abort("host %s not found", hostname); if (hostent->h_length != 4) Abort("host address is disagreeable length (%d)", hostent->h_length); memcpy((char *)&host, hostent->h_addr, sizeof(host)); if (setFD > 0) OpenFD(setFD); if (rx_Init(0) != 0) { printf("RX failed to initialize, exiting.\n"); exit(2); } if (setFD > 0) { printf("rx_socket=%d\n", rx_socket); } printf("Using %d packet buffers\n", rx_nPackets); conn = rx_NewConnection(host, htons(2500), 3, rxnull_NewClientSecurityObject(), 0); if (!conn) Abort("unable to make a new connection"); /* Set initial parameters. This is (currently) not the approved interface */ peer = rx_PeerOf(conn); if (burst) peer->burstSize = peer->burst = burst; if (!clock_IsZero(&burstTime)) peer->burstWait = burstTime; if (!clock_IsZero(&retryTime)) peer->rtt = _8THMSEC(&retryTime); if (sendFile) SendFile(sendFile, conn); else { buffer = (char *)osi_Alloc(bufferSize); while (nCalls--) { struct clock startTime; struct timeval t; int nbytes; int nSent; int bytesSent = 0; int bytesRead = 0; call = rx_NewCall(conn); if (!call) Abort("unable to make a new call"); clock_GetTime(&startTime); for (bytesSent = 0; bytesSent < nBytes; bytesSent += nSent) { int tryCount; tryCount = (bufferSize > nBytes - bytesSent) ? nBytes - bytesSent : bufferSize; nSent = rx_Write(call, buffer, tryCount); if (nSent == 0) break; } for (bytesRead = 0; (nbytes = rx_Read(call, buffer, bufferSize)); bytesRead += nbytes) { }; if (print) printf("Received %d characters in response\n", bytesRead); err = rx_EndCall(call, 0); if (err) printf("Error %d returned from rpc call\n", err); else { struct clock totalTime; float elapsedTime; clock_GetTime(&totalTime); clock_Sub(&totalTime, &startTime); elapsedTime = clock_Float(&totalTime); fprintf(stderr, "Sent %d bytes in %0.3f seconds: %0.0f bytes per second\n", bytesSent, elapsedTime, bytesSent / elapsedTime); } if (!clock_IsZero(&computeTime)) { t.tv_sec = computeTime.sec; t.tv_usec = computeTime.usec; if (select(0, 0, 0, 0, &t) != 0) Quit("Select didn't return 0"); } if (!clock_IsZero(&waitTime)) { struct timeval t; t.tv_sec = waitTime.sec; t.tv_usec = waitTime.usec; #ifdef AFS_PTHREAD_ENV select(0, 0, 0, 0, &t); #else IOMGR_Sleep(t.tv_sec); #endif } if (debugFile) rx_PrintPeerStats(debugFile, rx_PeerOf(conn)); rx_PrintPeerStats(stdout, rx_PeerOf(conn)); } } Quit("testclient: done!\n"); return 0; }
int main(int argc, char **argv) { char scell[MAXCELLCHARS], dcell[MAXCELLCHARS]; afs_uint32 ssrv, dsrv; char *databuffer, *srcf = NULL, *destd = NULL, *destf = NULL, *destpath = NULL; struct stat statbuf; struct AFSStoreStatus sst; struct AFSFetchStatus fst, dfst; struct AFSVolSync vs; struct AFSCallBack scb, dcb; struct AFSFid sf, dd, df; int filesz = 0; int ch, blksize, bytesremaining, bytes; struct timeval start, finish; struct timezone tz; struct rx_securityClass *ssc = 0, *dsc = 0; int sscindex, dscindex; struct rx_connection *sconn = NULL, *dconn = NULL; struct rx_call *scall = NULL, *dcall = NULL; int code = 0, fetchcode, storecode, printcallerrs = 0; int slcl = 0, dlcl = 0, unlock = 0; int sfd = 0, dfd = 0, unauth = 0; struct AFSCBFids theFids; struct AFSCBs theCBs; blksize = 8 * 1024; while ((ch = getopt(argc, argv, "iouUb:")) != -1) { switch (ch) { case 'b': blksize = atoi(optarg); break; case 'i': slcl = 1; break; case 'o': dlcl = 1; break; case 'u': unauth = 1; break; case 'U': unlock = 1; break; default: printf("Unknown option '%c'\n", ch); exit(1); } } if (argc - optind + unlock < 2) { fprintf(stderr, "Usage: afscp [-i|-o]] [-b xfersz] [-u] [-U] source [dest]\n"); fprintf(stderr, " -b Set block size\n"); fprintf(stderr, " -i Source is local (copy into AFS)\n"); fprintf(stderr, " -o Dest is local (copy out of AFS)\n"); fprintf(stderr, " -u Run unauthenticated\n"); fprintf(stderr, " -U Send an unlock request for source. (dest path not required)\n"); fprintf(stderr, "source and dest can be paths or specified as:\n"); fprintf(stderr, " @afs:cellname:servername:volume:vnode:uniq\n"); exit(1); } srcf = argv[optind++]; if (!unlock) { destpath = argv[optind++]; destd = strdup(destpath); if (!destd) { perror("strdup"); exit(1); } if ((destf = strrchr(destd, '/'))) { *destf++ = 0; } else { destf = destd; destd = "."; } } else if (slcl) { fprintf(stderr, "-i and -U cannot be used together\n"); } if (!slcl && statfile(srcf, scell, &ssrv, &sf)) { fprintf(stderr, "Cannot get attributes of %s\n", srcf); exit(1); } if (!unlock && !dlcl && statfile(destd, dcell, &dsrv, &dd)) { fprintf(stderr, "Cannot get attributes of %s\n", destd); exit(1); } if ((databuffer = malloc(blksize)) == NULL) { perror("malloc"); exit(1); } if (do_rx_Init()) exit(1); if (start_cb_server()) { printf("Cannot start callback service\n"); goto Fail_rx; } if (!slcl) { sscindex = scindex_RXKAD; if (unauth || (ssc = get_sc(scell)) == NULL) { ssc = rxnull_NewClientSecurityObject(); sscindex = scindex_NULL; /*printf("Cannot get authentication for cell %s; running unauthenticated\n", scell); */ } sscindex = scindex_NULL; if ((sconn = rx_NewConnection(ssrv, htons(AFSCONF_FILEPORT), 1, ssc, sscindex)) == NULL) { struct in_addr s; s.s_addr = ssrv; printf("Cannot initialize rx connection to source server (%s)\n", inet_ntoa(s)); goto Fail_sc; } } if (!dlcl && !unlock) { if (!slcl && ssrv == dsrv) { dconn = sconn; dsc = NULL; } else { if (slcl || strcmp(scell, dcell)) { dscindex = scindex_RXKAD; if (unauth || (dsc = get_sc(dcell)) == NULL) { dsc = rxnull_NewClientSecurityObject(); dscindex = scindex_NULL; /*printf("Cannot get authentication for cell %s; running unauthenticated\n", dcell); */ } dscindex = scindex_NULL; } else { dsc = ssc; dscindex = sscindex; } if ((dconn = rx_NewConnection(dsrv, htons(AFSCONF_FILEPORT), 1, dsc, dscindex)) == NULL) { struct in_addr s; s.s_addr = dsrv; printf ("Cannot initialize rx connection to dest server (%s)\n", inet_ntoa(s)); goto Fail_sconn; } } } memset(&sst, 0, sizeof(struct AFSStoreStatus)); if (dlcl && !unlock) { dfd = open(destpath, O_RDWR | O_CREAT | O_EXCL, 0666); if (dfd < 0 && errno == EEXIST) { printf("%s already exists, overwriting\n", destpath); dfd = open(destpath, O_RDWR | O_TRUNC, 0666); if (dfd < 0) { fprintf(stderr, "Cannot open %s (%s)\n", destpath, afs_error_message(errno)); goto Fail_dconn; } } else if (dfd < 0) { fprintf(stderr, "Cannot open %s (%s)\n", destpath, afs_error_message(errno)); goto Fail_dconn; } } else if (!unlock) { if ((code = RXAFS_CreateFile(dconn, &dd, destf, &sst, &df, &fst, &dfst, &dcb, &vs))) { if (code == EEXIST) { printf("%s already exits, overwriting\n", destpath); if (statfile(destpath, dcell, &dsrv, &df)) fprintf(stderr, "Cannot get attributes of %s\n", destpath); else code = 0; } else { printf("Cannot create %s (%s)\n", destpath, afs_error_message(code)); if (code) goto Fail_dconn; } } } if (slcl) { sfd = open(srcf, O_RDONLY, 0); if (sfd < 0) { fprintf(stderr, "Cannot open %s (%s)\n", srcf, afs_error_message(errno)); goto Fail_dconn; } if (fstat(sfd, &statbuf) < 0) { fprintf(stderr, "Cannot stat %s (%s)\n", srcf, afs_error_message(errno)); close(sfd); goto Fail_dconn; } } else { if ((code = RXAFS_FetchStatus(sconn, &sf, &fst, &scb, &vs))) { printf("Cannot fetchstatus of %d.%d (%s)\n", sf.Volume, sf.Vnode, afs_error_message(code)); goto Fail_dconn; } } if (slcl) { filesz = statbuf.st_size; } else { filesz = fst.Length; } printcallerrs = 0; fetchcode = 0; storecode = 0; if (!slcl && !unlock) scall = rx_NewCall(sconn); if (!dlcl && !unlock) dcall = rx_NewCall(dconn); gettimeofday(&start, &tz); if (unlock) { if (fst.lockCount) { printf("Sending 1 unlock for %s (%d locks)\n", srcf, fst.lockCount); if ((code = RXAFS_ReleaseLock(sconn, &sf, &vs))) { printf("Unable to unlock %s (%s)\n", srcf, afs_error_message(code)); } } else { printf("No locks for %s\n", srcf); } fetchcode = code; goto Finish; } if (!slcl) { if ((code = StartRXAFS_FetchData(scall, &sf, 0, filesz))) { printf("Unable to fetch data from %s (%s)\n", srcf, afs_error_message(code)); goto Fail_call; } } if (!dlcl) { if (slcl) { sst.Mask = AFS_SETMODTIME | AFS_SETMODE; sst.ClientModTime = statbuf.st_mtime; sst.UnixModeBits = statbuf.st_mode & ~(S_IFMT | S_ISUID | S_ISGID); } else { sst.Mask = AFS_SETMODTIME | AFS_SETMODE; sst.ClientModTime = fst.ClientModTime; sst.UnixModeBits = fst.UnixModeBits & ~(S_IFMT | S_ISUID | S_ISGID); } if ((code = StartRXAFS_StoreData(dcall, &df, &sst, 0, filesz, filesz))) { printf("Unable to store data to %s (%s)\n", destpath, afs_error_message(code)); goto Fail_call; } } if (slcl) { bytesremaining = statbuf.st_size; } else { rx_Read(scall, (char *)&bytesremaining, sizeof(afs_int32)); bytesremaining = ntohl(bytesremaining); } while (bytesremaining > 0) { /*printf("%d bytes remaining\n",bytesremaining); */ if (slcl) { if ((bytes = read(sfd, databuffer, min(blksize, bytesremaining))) <= 0) { fetchcode = errno; break; } } else { if ((bytes = rx_Read(scall, databuffer, min(blksize, bytesremaining))) <= 0) break; } if (dlcl) { if (write(dfd, databuffer, bytes) != bytes) { storecode = errno; break; } } else { if (rx_Write(dcall, databuffer, bytes) != bytes) break; } bytesremaining -= bytes; /*printf("%d bytes copied\n",bytes); */ } if (bytesremaining > 0) { printf("Some network error occured while copying data\n"); goto Fail_call; } if (!slcl) fetchcode = EndRXAFS_FetchData(scall, &fst, &scb, &vs); if (!dlcl) storecode = EndRXAFS_StoreData(dcall, &fst, &vs); printcallerrs = 1; Fail_call: if (slcl) { if (close(sfd) && !fetchcode) fetchcode = errno; } else { fetchcode = rx_EndCall(scall, fetchcode); } if (fetchcode && printcallerrs) printf("Error returned from fetch: %s\n", afs_error_message(fetchcode)); if (dlcl) { if (close(dfd) && !storecode) storecode = errno; } else if (!unlock) { storecode = rx_EndCall(dcall, storecode); } if (storecode && printcallerrs) printf("Error returned from store: %s\n", afs_error_message(storecode)); Finish: gettimeofday(&finish, &tz); if (!slcl) { theFids.AFSCBFids_len = 1; theFids.AFSCBFids_val = &sf; theCBs.AFSCBs_len = 1; theCBs.AFSCBs_val = &scb; scb.CallBackType = CB_DROPPED; if ((code = RXAFS_GiveUpCallBacks(sconn, &theFids, &theCBs))) printf("Could not give up source callback: %s\n", afs_error_message(code)); } if (!dlcl) { theFids.AFSCBFids_len = 1; theFids.AFSCBFids_val = &df; theCBs.AFSCBs_len = 1; theCBs.AFSCBs_val = &dcb; dcb.CallBackType = CB_DROPPED; if ((code = RXAFS_GiveUpCallBacks(dconn, &theFids, &theCBs))) printf("Could not give up target callback: %s\n", afs_error_message(code)); } if (code == 0) code = storecode; if (code == 0) code = fetchcode; Fail_dconn: if (!dlcl && !unlock && (slcl || dconn != sconn)) rx_DestroyConnection(dconn); Fail_sconn: if (!slcl) rx_DestroyConnection(sconn); Fail_sc: if (dsc && dsc != ssc) RXS_Close(dsc); if (ssc) RXS_Close(ssc); Fail_rx: rx_Finalize(); free(databuffer); if (printcallerrs && !unlock) { double rate, size, time; if (finish.tv_sec == start.tv_sec) { printf("Copied %d bytes in %d microseconds\n", filesz, (int)(finish.tv_usec - start.tv_usec)); } else { printf("Copied %d bytes in %d seconds\n", filesz, (int)(finish.tv_sec - start.tv_sec)); } size = filesz / 1024.0; time = finish.tv_sec - start.tv_sec + (finish.tv_usec - start.tv_usec) / 1e+06; rate = size / time; printf("Transfer rate %g Kbytes/sec\n", rate); } exit(code != 0); }
int main(int argc, char **argv) { register afs_int32 code; struct ubik_client *cstruct = 0; afs_uint32 serverList[MAXSERVERS]; struct rx_connection *serverconns[MAXSERVERS]; struct rx_securityClass *sc; register afs_int32 i; afs_int32 temp; if (argc == 1) { printf ("uclient: usage is 'uclient -servers ... [-try] [-get] [-inc] [-minc] [-trunc]\n"); exit(0); } #ifdef AFS_NT40_ENV /* initialize winsock */ if (afs_winsockInit() < 0) return -1; #endif /* first parse '-servers <server-1> <server-2> ... <server-n>' from command line */ code = ubik_ParseClientList(argc, argv, serverList); if (code) { printf("could not parse server list, code %d\n", code); exit(1); } rx_Init(0); sc = rxnull_NewClientSecurityObject(); for (i = 0; i < MAXSERVERS; i++) { if (serverList[i]) { serverconns[i] = rx_NewConnection(serverList[i], htons(3000), USER_SERVICE_ID, sc, 0); } else { serverconns[i] = (struct rx_connection *)0; break; } } /* next, pass list of server rx_connections (in serverconns), and * a place to put the returned client structure that we'll use in * all of our rpc calls (via ubik_Calll) */ code = ubik_ClientInit(serverconns, &cstruct); /* check code from init */ if (code) { printf("ubik client init failed with code %d\n", code); exit(1); } /* parse command line for our own operations */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-inc")) { /* use ubik_Call to do the work, finding an up server and handling * the job of finding a sync site, if need be */ code = ubik_SAMPLE_Inc(cstruct, 0); printf("return code is %d\n", code); } else if (!strcmp(argv[i], "-try")) { code = ubik_SAMPLE_Test(cstruct, 0); printf("return code is %d\n", code); } else if (!strcmp(argv[i], "-qget")) { code = ubik_SAMPLE_QGet(cstruct, 0, &temp); printf("got quick value %d (code %d)\n", temp, code); } else if (!strcmp(argv[i], "-get")) { code = ubik_SAMPLE_Get(cstruct, 0, &temp); printf("got value %d (code %d)\n", temp, code); } else if (!strcmp(argv[i], "-trunc")) { code = ubik_SAMPLE_Trun(cstruct, 0); printf("return code is %d\n", code); } else if (!strcmp(argv[i], "-minc")) { afs_int32 temp; struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; printf("ubik_client: Running minc...\n"); while (1) { temp = 0; code = ubik_SAMPLE_Get(cstruct, 0, &temp); if (code != 0) { printf("SAMPLE_Get #1 failed with code %ld\n", afs_printable_int32_ld(code)); } else { printf("SAMPLE_Get #1 succeeded, got value %ld\n", afs_printable_int32_ld(temp)); } temp = 0; code = ubik_SAMPLE_Inc(cstruct, 0); if (code != 0) { printf("SAMPLE_Inc #1 failed with code %ld\n", afs_printable_int32_ld(code)); } else { printf("SAMPLE_Inc #1 succeeded, incremented integer\n"); } temp = 0; code = ubik_SAMPLE_Get(cstruct, 0, &temp); if (code != 0) { printf("SAMPLE_Get #2 failed with code %ld\n", afs_printable_int32_ld(code)); } else { printf("SAMPLE_Get #2 succeeded, got value %ld\n", afs_printable_int32_ld(temp)); } temp = 0; code = ubik_SAMPLE_Inc(cstruct, 0); if (code != 0) printf("SAMPLE_Inc #2 failed with code %ld\n", afs_printable_int32_ld(code)); else printf("SAMPLE_Inc #2 succeeded, incremented integer\n"); tv.tv_sec = 1; tv.tv_usec = 0; #ifdef AFS_PTHREAD_ENV select(0, 0, 0, 0, &tv); #else IOMGR_Select(0, 0, 0, 0, &tv); #endif printf("Repeating the SAMPLE operations again...\n"); } } else if (!strcmp(argv[i], "-mget")) { afs_int32 temp; struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; while (1) { code = ubik_SAMPLE_Get(cstruct, 0, &temp); printf("got value %d (code %d)\n", temp, code); code = ubik_SAMPLE_Inc(cstruct, 0); printf("update return code is %d\n", code); code = ubik_SAMPLE_Get(cstruct, 0, &temp); printf("got value %d (code %d)\n", temp, code); code = ubik_SAMPLE_Get(cstruct, 0, &temp); printf("got value %d (code %d)\n", temp, code); tv.tv_sec = 1; tv.tv_usec = 0; #ifdef AFS_PTHREAD_ENV select(0, 0, 0, 0, &tv); #else IOMGR_Select(0, 0, 0, 0, &tv); #endif } } } return 0; }
afs_int32 init_fs_channel(rpc_test_request_ctx **octx, char *cb_if, char *listen_addr_s, char *prefix, char *fs_addr_s, afs_uint32 flags) { char cmd[512]; rpc_test_request_ctx *ctx; afs_int32 code = 0; #ifdef AFS_NT40_ENV afs_int32 sslen = sizeof(struct sockaddr); #endif ctx = *octx = (rpc_test_request_ctx *) malloc(sizeof(rpc_test_request_ctx)); memset(ctx, 0, sizeof(rpc_test_request_ctx)); /* initialize a local mutex */ code = pthread_mutex_init(&ctx->mtx, &rpc_test_params.mtx_attrs); /* lock package before rx setup--which has global deps, atm */ pthread_mutex_lock(&rpc_test_params.mtx); ctx->cno = rpc_test_params.next_cno++; ctx->flags = flags; /* afscbint (server) */ sprintf(ctx->cb_svc_name, "cb_%d", ctx->cno); sprintf(ctx->cb_if_s, cb_if); sprintf(ctx->cb_listen_addr_s, listen_addr_s); sprintf(ctx->cb_prefix_s, prefix); sprintf(ctx->fs_addr_s, fs_addr_s); #if defined(RPC_TEST_ADD_ADDRESSES) #if defined(AFS_LINUX26_ENV) sprintf(cmd, "ip addr add %s/%s dev %s label %s", listen_addr_s, prefix, cb_if, cb_if); code = system(cmd); #endif #endif /* RPC_TEST_ADD_ADDRESSES */ /* lock this */ pthread_mutex_lock(&ctx->mtx); /* set up rx */ ctx->cb_port = rpc_test_params.cb_next_port++; ctx->cb_listen_addr.numberOfInterfaces = 1; #ifdef AFS_NT40_ENV code = WSAStringToAddressA(listen_addr_s, AF_INET, NULL, (struct sockaddr*) &(ctx->cb_listen_addr), &sslen); #else code = inet_pton(AF_INET, listen_addr_s, (void*) &(ctx->cb_listen_addr.addr_in[0])); #endif code = init_callback_service(ctx /* LOCKED, && rpc_test_params->mtx LOCKED */); /* fsint (client) */ #ifdef AFS_NT40_ENV code = WSAStringToAddressA(fs_addr_s, AF_INET, NULL, (struct sockaddr*) &(ctx->fs_addr.addr_in[0]), &sslen); #else code = inet_pton(AF_INET, fs_addr_s, (void*) &(ctx->fs_addr.addr_in[0])); #endif ctx->sc = rxnull_NewClientSecurityObject(); ctx->sc_index = RX_SECIDX_NULL; ctx->conn = rx_NewConnection(ctx->fs_addr.addr_in[0], (int) htons(fs_port), 1, ctx->sc, ctx->sc_index); /* unlock this */ pthread_mutex_unlock(&ctx->mtx); out: return (code); } /* init_fs_channel */
void afspag_Init(afs_int32 nfs_server_addr) { struct clientcred ccred; struct rmtbulk idata, odata; afs_int32 code, err, addr, obuf; int i; afs_uuid_create(&afs_cb_interface.uuid); AFS_GLOCK(); afs_InitStats(); rx_Init(htons(7001)); AFS_STATCNT(afs_ResourceInit); AFS_RWLOCK_INIT(&afs_xuser, "afs_xuser"); AFS_RWLOCK_INIT(&afs_xpagcell, "afs_xpagcell"); AFS_RWLOCK_INIT(&afs_xpagsys, "afs_xpagsys"); AFS_RWLOCK_INIT(&afs_icl_lock, "afs_icl_lock"); afs_resourceinit_flag = 1; afs_nfs_server_addr = nfs_server_addr; for (i = 0; i < MAXNUMSYSNAMES; i++) { afs_sysnamelist[i] = afs_osi_Alloc(MAXSYSNAME); osi_Assert(afs_sysnamelist[i] != NULL); } afs_sysname = afs_sysnamelist[0]; strcpy(afs_sysname, SYS_NAME); afs_sysnamecount = 1; afs_sysnamegen++; srv_secobj = rxnull_NewServerSecurityObject(); stats_svc = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", &srv_secobj, 1, RXSTATS_ExecuteRequest); pagcb_svc = rx_NewService(0, PAGCB_SERVICEID, "pagcb", &srv_secobj, 1, PAGCB_ExecuteRequest); rx_StartServer(0); clt_secobj = rxnull_NewClientSecurityObject(); rmtsys_conn = rx_NewConnection(nfs_server_addr, htons(7009), RMTSYS_SERVICEID, clt_secobj, 0); #ifdef RXK_LISTENER_ENV afs_start_thread(rxk_Listener, "Rx Listener"); #endif afs_start_thread((void *)(void *)rx_ServerProc, "Rx Server Thread"); afs_start_thread(afs_rxevent_daemon, "Rx Event Daemon"); afs_start_thread(afs_Daemon, "AFS PAG Daemon"); afs_icl_InitLogs(); AFS_GUNLOCK(); /* If it's reachable, tell the translator to nuke our creds. * We should be more agressive about making sure this gets done, * even if the translator is unreachable when we boot. */ addr = obuf = err = 0; idata.rmtbulk_len = sizeof(addr); idata.rmtbulk_val = (char *)&addr; odata.rmtbulk_len = sizeof(obuf); odata.rmtbulk_val = (char *)&obuf; memset(&ccred, 0, sizeof(ccred)); code = RMTSYS_Pioctl(rmtsys_conn, &ccred, NIL_PATHP, 0x4F01, 0, &idata, &odata, &err); } /*afs_ResourceInit */