/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * rusers_simple.c
 * These are the "easy to use" interfaces to rusers.
 *
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2018, Joyent, Inc.
 */

#include <string.h>
#include <rpc/rpc.h>
#include <rpcsvc/rusers.h>
#include <stdlib.h>

int
rusers3(host, uap)
	char *host;
	utmp_array *uap;
{
	struct utmpidlearr up;

	if (rpc_call(host, RUSERSPROG, RUSERSVERS_3, RUSERSPROC_NAMES,
			xdr_void, (char *) NULL,
			xdr_utmp_array, (char *) uap, (char *) NULL) != 0) {
		/*
		 * If version 3 isn't available, try version 2.  We'll have to
		 * convert a utmpidlearr structure into a utmp_array.
		 */
		up.uia_cnt = 0;
		up.uia_arr = NULL;
		if (rusers(host, &up) != 0)
			return (-1);
		else {
			int i;
			struct ru_utmp forsize;
			rusers_utmp *rutp;

			uap->utmp_array_val = (rusers_utmp *)malloc(up.uia_cnt
				* sizeof (rusers_utmp));
			if (uap->utmp_array_val == NULL) {
				xdr_free(xdr_utmpidlearr, (char *)&up);
				return (-1);
			}
			uap->utmp_array_len = up.uia_cnt;
			for (rutp = uap->utmp_array_val, i = 0;
				i < up.uia_cnt; rutp++, i++) {
				rutp->ut_line = (char *)malloc(sizeof
					(forsize.ut_line)+1);
				rutp->ut_user = (char *)malloc(sizeof
					(forsize.ut_name)+1);
				rutp->ut_host = (char *)malloc(sizeof
					(forsize.ut_host)+1);
				if (rutp->ut_line == NULL ||
					rutp->ut_user == NULL ||
					rutp->ut_host == NULL) {

                                        while (--rutp >= uap->utmp_array_val) {
						free(rutp->ut_line);
						free(rutp->ut_user);
						free(rutp->ut_host);
					}
					free(uap->utmp_array_val);
					xdr_free(xdr_utmpidlearr, (char *)&up);
					return (-1);
				}
				(void) strncpy(rutp->ut_line,
					up.uia_arr[i]->ui_utmp.ut_line,
					sizeof (forsize.ut_line)+1);
				(void) strncpy(rutp->ut_user,
					up.uia_arr[i]->ui_utmp.ut_name,
					sizeof (forsize.ut_name)+1);
				(void) strncpy(rutp->ut_host,
					up.uia_arr[i]->ui_utmp.ut_host,
					sizeof (forsize.ut_host)+1);
				rutp->ut_idle = up.uia_arr[i]->ui_idle;
				rutp->ut_time = up.uia_arr[i]->ui_utmp.ut_time;
				rutp->ut_type = RUSERS_USER_PROCESS;
							/* assume this */
			}
			xdr_free(xdr_utmpidlearr, (char *)&up);
		}
	}
	return (0);
}

int
rnusers(host)
	char *host;
{
	int nusers;

	if (rpc_call(host, RUSERSPROG, RUSERSVERS_3, RUSERSPROC_NUM,
			xdr_void, (char *) NULL,
			xdr_u_int, (char *) &nusers, (char *) NULL) != 0) {
		if (rpc_call(host, RUSERSPROG, RUSERSVERS_IDLE, RUSERSPROC_NUM,
			xdr_void, (char *) NULL,
			xdr_u_int, (char *) &nusers, (char *) NULL) != 0)
			return (-1);
	}
	return (nusers);
}

enum clnt_stat
rusers(host, up)
	char *host;
	struct utmpidlearr *up;
{
	return (rpc_call(host, RUSERSPROG, RUSERSVERS_IDLE, RUSERSPROC_NAMES,
			xdr_void, (char *) NULL,
			xdr_utmpidlearr, (char *) up, (char *) NULL));
}