int main(int argn, char *argc[])
{
//Program parameters : argc[1] : HostName or Host IP
// argc[2] : Server Program Number
// other arguments depend on test case
//run_mode can switch into stand alone program or program launch by shell script
//1 : stand alone, debug mode, more screen information
//0 : launch by shell script as test case, only one printf -> result status
int run_mode = 0;
int test_status = 1; //Default test result set to FAILED
int progNum = atoi(argc[2]);
AUTH *authSys = NULL;
uid_t uid;
gid_t gid, *aup_gids;
int len;
//Initialization
uid = geteuid();
gid = getegid();
len = getgroups(NGRPS, aup_gids);
//Call routine
authSys = authsys_create(argc[1], uid, gid, len, aup_gids);
//If we are here, macro call was successful
test_status = ((AUTH *)authSys != NULL) ? 0 : 1;
//This last printf gives the result status to the tests suite
//normally should be 0: test has passed or 1: test has failed
printf("%d\n", test_status);
return test_status;
}
CLIENT *
getkwarnd_handle(void)
{
void *localhandle;
struct netconfig *nconf;
struct netconfig *tpconf;
struct timeval wait_time;
struct utsname u;
static char *hostname;
static bool_t first_time = TRUE;
/*
* Total timeout (in seconds) talking to kwarnd.
*/
#define TOTAL_TIMEOUT 5
if (kwarn_clnt)
return (kwarn_clnt);
if (!(localhandle = setnetconfig()))
return (NULL);
tpconf = NULL;
if (first_time == TRUE) {
if (uname(&u) == -1) {
(void) endnetconfig(localhandle);
return ((CLIENT *)NULL);
}
if ((hostname = strdup(u.nodename)) == (char *)NULL) {
(void) endnetconfig(localhandle);
return ((CLIENT *)NULL);
}
first_time = FALSE;
}
while (nconf = getnetconfig(localhandle)) {
if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
if (nconf->nc_semantics == NC_TPI_COTS_ORD) {
kwarn_clnt = clnt_tp_create(hostname,
KWARNPROG, KWARNVERS, nconf);
if (kwarn_clnt) {
dprt("got COTS_ORD\n");
break;
}
} else {
tpconf = nconf;
}
}
}
if ((kwarn_clnt == NULL) && (tpconf)) {
/* Now, try the connection-oriented loopback transport */
kwarn_clnt = clnt_tp_create(hostname, KWARNPROG, KWARNVERS,
tpconf);
#ifdef DEBUG
if (kwarn_clnt) {
dprt("got COTS\n");
}
#endif /* DEBUG */
}
(void) endnetconfig(localhandle);
/*
* This bit of code uses an as yet unimplemented argument to
* clnt_control(). CLSET_SVC_PRIV specifies that the underlying
* loopback transport should be checked to ensure it is
* connected to a process running as root. If so, the clnt_control()
* call returns TRUE. If not, it returns FALSE.
*/
#ifdef CLSET_SVC_PRIV
if (clnt_control(kwarn_clnt, CLSET_SVC_PRIV, NULL) != TRUE) {
clnt_destroy(kwarn_clnt);
kwarn_clnt = NULL;
return (NULL);
{
#endif
if (kwarn_clnt == NULL)
return (NULL);
kwarn_clnt->cl_auth = authsys_create("", getuid(), 0, 0, NULL);
if (kwarn_clnt->cl_auth == NULL) {
clnt_destroy(kwarn_clnt);
kwarn_clnt = NULL;
return (NULL);
}
wait_time.tv_sec = TOTAL_TIMEOUT;
wait_time.tv_usec = 0;
(void) clnt_control(kwarn_clnt, CLSET_TIMEOUT, (char *)&wait_time);
return (kwarn_clnt);
}
void
resetkwarnd_handle(void)
{
auth_destroy(kwarn_clnt->cl_auth);
clnt_destroy(kwarn_clnt);
kwarn_clnt = NULL;
}
/*
* Keep the handle cached. This call may be made quite often.
*/
static CLIENT *
getkeyserv_handle(int vers)
{
void *localhandle;
struct netconfig *nconf;
struct netconfig *tpconf;
struct key_call_private *kcp = key_call_private_main;
struct timeval wait_time;
struct utsname u;
int main_thread;
int fd;
static thread_key_t key_call_key;
#define TOTAL_TIMEOUT 30 /* total timeout talking to keyserver */
#define TOTAL_TRIES 5 /* Number of tries */
if ((main_thread = thr_main())) {
kcp = key_call_private_main;
} else {
if (key_call_key == 0) {
mutex_lock(&tsd_lock);
if (key_call_key == 0)
thr_keycreate(&key_call_key, key_call_destroy);
mutex_unlock(&tsd_lock);
}
kcp = (struct key_call_private *)thr_getspecific(key_call_key);
}
if (kcp == NULL) {
kcp = (struct key_call_private *)malloc(sizeof (*kcp));
if (kcp == NULL) {
return (NULL);
}
if (main_thread)
key_call_private_main = kcp;
else
thr_setspecific(key_call_key, (void *) kcp);
kcp->client = NULL;
}
/* if pid has changed, destroy client and rebuild */
if (kcp->client != NULL && kcp->pid != getpid()) {
clnt_destroy(kcp->client);
kcp->client = NULL;
}
if (kcp->client != NULL) {
/* if uid has changed, build client handle again */
if (kcp->uid != geteuid()) {
kcp->uid = geteuid();
auth_destroy(kcp->client->cl_auth);
kcp->client->cl_auth =
authsys_create("", kcp->uid, 0, 0, NULL);
if (kcp->client->cl_auth == NULL) {
clnt_destroy(kcp->client);
kcp->client = NULL;
return (NULL);
}
}
/* Change the version number to the new one */
clnt_control(kcp->client, CLSET_VERS, (void *)&vers);
return (kcp->client);
}
if (!(localhandle = setnetconfig())) {
return (NULL);
}
tpconf = NULL;
if (uname(&u) == -1)
{
endnetconfig(localhandle);
return (NULL);
}
while ((nconf = getnetconfig(localhandle)) != NULL) {
if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
/*
* We use COTS_ORD here so that the caller can
* find out immediately if the server is dead.
*/
if (nconf->nc_semantics == NC_TPI_COTS_ORD) {
kcp->client = clnt_tp_create(u.nodename,
KEY_PROG, vers, nconf);
if (kcp->client)
break;
} else {
tpconf = nconf;
}
}
}
if ((kcp->client == NULL) && (tpconf))
/* Now, try the CLTS or COTS loopback transport */
kcp->client = clnt_tp_create(u.nodename,
KEY_PROG, vers, tpconf);
endnetconfig(localhandle);
if (kcp->client == NULL) {
return (NULL);
}
kcp->uid = geteuid();
kcp->pid = getpid();
kcp->client->cl_auth = authsys_create("", kcp->uid, 0, 0, NULL);
if (kcp->client->cl_auth == NULL) {
clnt_destroy(kcp->client);
kcp->client = NULL;
return (NULL);
}
wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES;
wait_time.tv_usec = 0;
clnt_control(kcp->client, CLSET_RETRY_TIMEOUT,
(char *)&wait_time);
if (clnt_control(kcp->client, CLGET_FD, (char *)&fd))
_fcntl(fd, F_SETFD, 1); /* make it "close on exec" */
return (kcp->client);
}
