END_TEST
void *add_and_lookup_stuff(void *parm)
{
int i = 0;
while((i < 1000) || (everybody_started == false))
{
struct addrinfo *pAddr = (struct addrinfo *)calloc(1,sizeof(addrinfo));
struct sockaddr_in *pINetAddr;
const char *word = getRandomWord((unsigned int *)parm);
i++;
if(NULL == get_cached_addrinfo(word))
{
pAddr->ai_addr = (struct sockaddr *)calloc(1,sizeof(struct sockaddr_in));
pAddr->ai_family = AF_INET;
pINetAddr = (struct sockaddr_in *)pAddr->ai_addr;
pAddr->ai_canonname = strdup(word);
pINetAddr->sin_addr.s_addr = rand_r((unsigned int *)parm);
pAddr = insert_addr_name_info(pAddr,pAddr->ai_canonname);
}
else
{
freeaddrinfo(pAddr);
pAddr = get_cached_addrinfo_full(word);
}
fail_unless((pAddr != NULL));
if(pAddr != NULL)
{
char *p1;
char *p2;
struct sockaddr_in *p3;
struct addrinfo *p4;
pINetAddr = (struct sockaddr_in *)pAddr->ai_addr;
p1 = get_cached_nameinfo(pINetAddr);
p2 = get_cached_fullhostname(word,pINetAddr);
p3 = get_cached_addrinfo(word);
p4 = get_cached_addrinfo_full(word);
fail_unless(((p1 != NULL)&&(p2 != NULL)&&(p3 != NULL)&&(p4 != NULL)));
}
else
{
}
}
return NULL;
}
int get_addr_info(
char *name,
struct sockaddr_in *sa_info,
int retry)
{
int rc = PBSE_NONE;
int cntr = 0;
struct addrinfo *addr_info;
struct addrinfo hints;
struct timeval start_time;
struct timeval end_time;
struct sockaddr_in *cached_sai;
/* retrieve from cache if possible */
if ((cached_sai = get_cached_addrinfo(name)) != NULL)
{
memcpy(sa_info, cached_sai, sizeof(struct sockaddr_in));
return(PBSE_NONE);
}
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = PF_INET;
while (cntr < retry)
{
gettimeofday(&start_time, 0);
if ((rc = getaddrinfo(name, NULL, &hints, &addr_info)) != 0)
{
gettimeofday(&end_time, 0);
rc = PBSE_BADHOST;
}
else
{
sa_info->sin_addr = ((struct sockaddr_in *)addr_info->ai_addr)->sin_addr;
sa_info->sin_family = addr_info->ai_family;
insert_addr_name_info(name, addr_info->ai_canonname, sa_info);
freeaddrinfo(addr_info);
gettimeofday(&end_time, 0);
rc = PBSE_NONE;
break;
}
cntr++;
}
return(rc);
} /* END get_addr_info() */
int authenticate_user(
struct batch_request *preq, /* I */
struct credential *pcred,
char **autherr) /* O */
{
int rc;
char uath[PBS_MAXUSER + PBS_MAXHOSTNAME + 1];
time_t time_now = time(NULL);
char error_msg[1024];
bool acl_enabled = false;
#ifdef MUNGE_AUTH
if (strncmp(preq->rq_user, pcred->username, PBS_MAXUSER))
{
/* extra check for munge */
struct array_strings *my_acl = NULL;
char uh[PBS_MAXUSER + PBS_MAXHOSTNAME + 2];
sprintf(uh, "%s@%s", preq->rq_user, pcred->hostname);
get_svr_attr_arst(SRV_ATR_authusers, &my_acl);
if ((acl_check_my_array_string(my_acl, uh, ACL_User_Host)) == 0)
{
*autherr = strdup("User not in authorized user list.");
sprintf(error_msg, "%s Requested user %s: requested from host %s",
*autherr, preq->rq_user, preq->rq_host);
log_event(PBSEVENT_ADMIN, PBS_EVENTCLASS_SERVER, __func__, error_msg);
return(PBSE_BADCRED);
}
}
#else
if (strncmp(preq->rq_user, pcred->username, PBS_MAXUSER))
{
*autherr = strdup("Users do not match");
sprintf(error_msg, "%s: Requested user %s: credential user %s: requested from host %s",
*autherr, preq->rq_user, pcred->username, preq->rq_host);
log_event(PBSEVENT_ADMIN, PBS_EVENTCLASS_SERVER, __func__, error_msg);
return(PBSE_BADCRED);
}
#endif
if (strncmp(preq->rq_host, pcred->hostname, PBS_MAXHOSTNAME))
{
struct sockaddr_in *sai1;
struct sockaddr_in *sai2;
struct addrinfo *addr_info1 = NULL;
struct addrinfo *addr_info2 = NULL;
sai1 = get_cached_addrinfo(preq->rq_host);
sai2 = get_cached_addrinfo(pcred->hostname);
if ((sai1 == NULL) &&
(pbs_getaddrinfo(preq->rq_host, NULL, &addr_info1) == PBSE_NONE))
{
sai1 = (struct sockaddr_in *)addr_info1->ai_addr;
}
if ((sai2 == NULL) &&
(pbs_getaddrinfo(pcred->hostname, NULL, &addr_info2) == PBSE_NONE))
{
sai2 = (struct sockaddr_in *)addr_info2->ai_addr;
}
if ((sai1 == NULL) ||
(sai2 == NULL) ||
(memcmp(sai1, sai2, sizeof(struct sockaddr_in))))
{
*autherr = strdup("Hosts do not match");
sprintf(error_msg, "%s: Requested host %s: credential host: %s",
*autherr, preq->rq_host, pcred->hostname);
log_event(PBSEVENT_ADMIN, PBS_EVENTCLASS_SERVER, __func__, error_msg);
return(PBSE_BADCRED);
}
}
if (pcred->timestamp)
{
long lifetime = 0;
if (get_svr_attr_l(SRV_ATR_CredentialLifetime, &lifetime) == PBSE_NONE)
{
/* use configured value if set */
}
else
{
/* if not use the default */
lifetime = CREDENTIAL_LIFETIME;
}
/* negative values mean that credentials have an infinite lifetime */
if (lifetime > -1)
{
if ((pcred->timestamp - CREDENTIAL_TIME_DELTA > time_now) ||
(pcred->timestamp + lifetime < time_now))
{
return(PBSE_EXPIRED);
}
}
}
/* If Server's Acl_User enabled, check if user in list */
get_svr_attr_b(SRV_ATR_AclUserEnabled, &acl_enabled);
if (acl_enabled)
{
struct array_strings *acl_users = NULL;
snprintf(uath, sizeof(uath), "%s@%s", preq->rq_user, preq->rq_host);
get_svr_attr_arst(SRV_ATR_AclUsers, &acl_users);
if (acl_check_my_array_string(acl_users, uath, ACL_User) == 0)
{
int my_err;
pbs_net_t connect_addr = get_hostaddr(&my_err, preq->rq_host);
pbs_net_t server_addr = get_hostaddr(&my_err, server_host);
#ifdef __CYGWIN__
if ((!IamAdminByName(preq->rq_user)) ||
(connect_addr != server_addr))
{
return(PBSE_PERM);
}
#else /* __CYGWIN__ */
#ifdef PBS_ROOT_ALWAYS_ADMIN
if ((strcmp(preq->rq_user, PBS_DEFAULT_ADMIN) != 0) ||
(connect_addr != server_addr))
{
return(PBSE_PERM);
}
#else /* PBS_ROOT_ALWAYS_ADMIN */
return(PBSE_PERM);
#endif /* PBS_ROOT_ALWAYS_ADMIN */
#endif /* __CYGWIN__ */
}
}
/* A site stub for additional checking */
rc = site_allow_u(preq->rq_user, preq->rq_host);
return(rc);
} /* END authenticate_user() */
