[unix-history] / sys / kern / kern_xxx.c

/*
 * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	from: @(#)kern_xxx.c	7.17 (Berkeley) 4/20/91
 *	$Id: kern_xxx.c,v 1.4 1993/10/16 15:24:35 rgrimes Exp $
 */

#include "param.h"
#include "systm.h"
#include "kernel.h"
#include "proc.h"
#include "reboot.h"
#include "utsname.h"

/* ARGSUSED */
gethostid(p, uap, retval)
	struct proc *p;
	void *uap;
	long *retval;
{

	*retval = hostid;
	return (0);
}

struct sethostid_args {
	long	hostid;
};

/* ARGSUSED */
sethostid(p, uap, retval)
	struct proc *p;
	struct sethostid_args *uap;
	int *retval;
{
	int error;

	if (error = suser(p->p_ucred, &p->p_acflag))
		return (error);
	hostid = uap->hostid;
	return (0);
}

struct gethostname_args {
	char	*hostname;
	u_int	len;
};

/* ARGSUSED */
gethostname(p, uap, retval)
	struct proc *p;
	struct gethostname_args *uap;
	int *retval;
{

	if (uap->len > hostnamelen + 1)
		uap->len = hostnamelen + 1;
	return (copyout((caddr_t)hostname, (caddr_t)uap->hostname, uap->len));
}

struct sethostname_args {
	char	*hostname;
	u_int	len;
};

/* ARGSUSED */
sethostname(p, uap, retval)
	struct proc *p;
	register struct sethostname_args *uap;
	int *retval;
{
	int error;

	if (error = suser(p->p_ucred, &p->p_acflag))
		return (error);
	if (uap->len > sizeof (hostname) - 1)
		return (EINVAL);
	hostnamelen = uap->len;
	error = copyin((caddr_t)uap->hostname, hostname, uap->len);
	hostname[hostnamelen] = 0;
	return (error);
}

struct getdomainname_args {
        char    *domainname;
        u_int   len;
};

/* ARGSUSED */
int
getdomainname(p, uap, retval)
        struct proc *p;
        struct getdomainname_args *uap;
        int *retval;
{
	if (uap->len > domainnamelen + 1)
		uap->len = domainnamelen + 1;
	return (copyout((caddr_t)domainname, (caddr_t)uap->domainname, uap->len));
}

struct setdomainname_args {
        char    *domainname;
        u_int   len;
};

/* ARGSUSED */
int
setdomainname(p, uap, retval)
        struct proc *p;
        struct setdomainname_args *uap;
        int *retval;
{
        int error;

        if (error = suser(p->p_ucred, &p->p_acflag))
                return (error);
        if (uap->len > sizeof (domainname) - 1)
                return EINVAL;
        domainnamelen = uap->len;
        error = copyin((caddr_t)uap->domainname, domainname, uap->len);
        domainname[domainnamelen] = 0;
        return (error);
}

struct uname_args {
        struct utsname  *name;
};

/* ARGSUSED */
int
uname(p, uap, retval)
	struct proc *p;
	struct uname_args *uap;
	int *retval;
{
	bcopy(hostname, utsname.nodename, sizeof(utsname.nodename));
	utsname.nodename[sizeof(utsname.nodename)-1] = '\0';
	return (copyout((caddr_t)&utsname, (caddr_t)uap->name,
		sizeof(struct utsname)));
}

struct reboot_args {
	int	opt;
};

/* ARGSUSED */
reboot(p, uap, retval)
	struct proc *p;
	struct reboot_args *uap;
	int *retval;
{
	int error;

	if (error = suser(p->p_ucred, &p->p_acflag))
		return (error);
	boot(uap->opt);
	return (0);
}

#ifdef COMPAT_43
oquota()
{

	return (ENOSYS);
}
#endif
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1982, 1986, 1989 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*
78ed81a3	33	* from: @(#)kern_xxx.c 7.17 (Berkeley) 4/20/91
78ed81a3	34	* $Id: kern_xxx.c,v 1.4 1993/10/16 15:24:35 rgrimes Exp $
15637ed4 RG	35	*/
	36
	37	#include "param.h"
	38	#include "systm.h"
	39	#include "kernel.h"
	40	#include "proc.h"
	41	#include "reboot.h"
78ed81a3	42	#include "utsname.h"
15637ed4 RG	43
	44	/* ARGSUSED */
	45	gethostid(p, uap, retval)
	46	struct proc *p;
	47	void *uap;
	48	long *retval;
	49	{
	50
	51	*retval = hostid;
	52	return (0);
	53	}
	54
78ed81a3	55	struct sethostid_args {
	56	long hostid;
	57	};
	58
15637ed4 RG	59	/* ARGSUSED */
	60	sethostid(p, uap, retval)
	61	struct proc *p;
78ed81a3	62	struct sethostid_args *uap;
15637ed4 RG	63	int *retval;
	64	{
	65	int error;
	66
	67	if (error = suser(p->p_ucred, &p->p_acflag))
	68	return (error);
	69	hostid = uap->hostid;
	70	return (0);
	71	}
	72
78ed81a3	73	struct gethostname_args {
	74	char *hostname;
	75	u_int len;
	76	};
	77
15637ed4 RG	78	/* ARGSUSED */
	79	gethostname(p, uap, retval)
	80	struct proc *p;
78ed81a3	81	struct gethostname_args *uap;
15637ed4 RG	82	int *retval;
	83	{
	84
	85	if (uap->len > hostnamelen + 1)
	86	uap->len = hostnamelen + 1;
	87	return (copyout((caddr_t)hostname, (caddr_t)uap->hostname, uap->len));
	88	}
	89
78ed81a3	90	struct sethostname_args {
	91	char *hostname;
	92	u_int len;
	93	};
	94
15637ed4 RG	95	/* ARGSUSED */
	96	sethostname(p, uap, retval)
	97	struct proc *p;
78ed81a3	98	register struct sethostname_args *uap;
15637ed4 RG	99	int *retval;
	100	{
	101	int error;
	102
	103	if (error = suser(p->p_ucred, &p->p_acflag))
	104	return (error);
	105	if (uap->len > sizeof (hostname) - 1)
	106	return (EINVAL);
	107	hostnamelen = uap->len;
	108	error = copyin((caddr_t)uap->hostname, hostname, uap->len);
	109	hostname[hostnamelen] = 0;
	110	return (error);
	111	}
	112
78ed81a3	113	struct getdomainname_args {
	114	char *domainname;
	115	u_int len;
	116	};
	117
	118	/* ARGSUSED */
	119	int
	120	getdomainname(p, uap, retval)
	121	struct proc *p;
	122	struct getdomainname_args *uap;
	123	int *retval;
	124	{
	125	if (uap->len > domainnamelen + 1)
	126	uap->len = domainnamelen + 1;
	127	return (copyout((caddr_t)domainname, (caddr_t)uap->domainname, uap->len));
	128	}
	129
	130	struct setdomainname_args {
	131	char *domainname;
	132	u_int len;
	133	};
	134
	135	/* ARGSUSED */
	136	int
	137	setdomainname(p, uap, retval)
	138	struct proc *p;
	139	struct setdomainname_args *uap;
	140	int *retval;
	141	{
	142	int error;
	143
	144	if (error = suser(p->p_ucred, &p->p_acflag))
	145	return (error);
	146	if (uap->len > sizeof (domainname) - 1)
	147	return EINVAL;
	148	domainnamelen = uap->len;
	149	error = copyin((caddr_t)uap->domainname, domainname, uap->len);
	150	domainname[domainnamelen] = 0;
	151	return (error);
	152	}
	153
	154	struct uname_args {
	155	struct utsname *name;
	156	};
	157
	158	/* ARGSUSED */
	159	int
	160	uname(p, uap, retval)
	161	struct proc *p;
	162	struct uname_args *uap;
	163	int *retval;
	164	{
	165	bcopy(hostname, utsname.nodename, sizeof(utsname.nodename));
	166	utsname.nodename[sizeof(utsname.nodename)-1] = '\0';
	167	return (copyout((caddr_t)&utsname, (caddr_t)uap->name,
	168	sizeof(struct utsname)));
	169	}
	170
	171	struct reboot_args {
	172	int opt;
	173	};
	174
15637ed4 RG	175	/* ARGSUSED */
	176	reboot(p, uap, retval)
	177	struct proc *p;
78ed81a3	178	struct reboot_args *uap;
15637ed4 RG	179	int *retval;
	180	{
	181	int error;
	182
	183	if (error = suser(p->p_ucred, &p->p_acflag))
	184	return (error);
	185	boot(uap->opt);
	186	return (0);
	187	}
	188
	189	#ifdef COMPAT_43
	190	oquota()
	191	{
	192
	193	return (ENOSYS);
	194	}
	195	#endif