sys/kern/kern_xxx.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1989, 1993
   3  *      The Regents of the University of California.  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  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)kern_xxx.c  8.2 (Berkeley) 11/14/93
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_compat.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/sysproto.h>
  40 #include <sys/kernel.h>
  41 #include <sys/priv.h>
  42 #include <sys/proc.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/utsname.h>
  47 #include <sys/vimage.h>
  48
  49
  50 #if defined(COMPAT_43)
  51
  52 #ifndef _SYS_SYSPROTO_H_
  53 struct gethostname_args {
  54         char    *hostname;
  55         u_int   len;
  56 };
  57 #endif
  58 /* ARGSUSED */
  59 int
  60 ogethostname(td, uap)
  61         struct thread *td;
  62         struct gethostname_args *uap;
  63 {
  64         int name[2];
  65         int error;
  66         size_t len = uap->len;
  67
  68         name[0] = CTL_KERN;
  69         name[1] = KERN_HOSTNAME;
  70         mtx_lock(&Giant);
  71         error = userland_sysctl(td, name, 2, uap->hostname, &len,
  72             1, 0, 0, 0, 0);
  73         mtx_unlock(&Giant);
  74         return(error);
  75 }
  76
  77 #ifndef _SYS_SYSPROTO_H_
  78 struct sethostname_args {
  79         char    *hostname;
  80         u_int   len;
  81 };
  82 #endif
  83 /* ARGSUSED */
  84 int
  85 osethostname(td, uap)
  86         struct thread *td;
  87         register struct sethostname_args *uap;
  88 {
  89         int name[2];
  90         int error;
  91
  92         name[0] = CTL_KERN;
  93         name[1] = KERN_HOSTNAME;
  94         mtx_lock(&Giant);
  95         error = userland_sysctl(td, name, 2, 0, 0, 0, uap->hostname,
  96             uap->len, 0, 0);
  97         mtx_unlock(&Giant);
  98         return (error);
  99 }
 100
 101 #ifndef _SYS_SYSPROTO_H_
 102 struct ogethostid_args {
 103         int     dummy;
 104 };
 105 #endif
 106 /* ARGSUSED */
 107 int
 108 ogethostid(td, uap)
 109         struct thread *td;
 110         struct ogethostid_args *uap;
 111 {
 112
 113         *(long *)(td->td_retval) = hostid;
 114         return (0);
 115 }
 116 #endif /* COMPAT_43 */
 117
 118 #ifdef COMPAT_43
 119 #ifndef _SYS_SYSPROTO_H_
 120 struct osethostid_args {
 121         long    hostid;
 122 };
 123 #endif
 124 /* ARGSUSED */
 125 int
 126 osethostid(td, uap)
 127         struct thread *td;
 128         struct osethostid_args *uap;
 129 {
 130         int error;
 131
 132         error = priv_check(td, PRIV_SETHOSTID);
 133         if (error)
 134                 return (error);
 135         mtx_lock(&Giant);
 136         hostid = uap->hostid;
 137         mtx_unlock(&Giant);
 138         return (0);
 139 }
 140
 141 int
 142 oquota(td, uap)
 143         struct thread *td;
 144         struct oquota_args *uap;
 145 {
 146
 147         return (ENOSYS);
 148 }
 149 #endif /* COMPAT_43 */
 150
 151 /*
 152  * This is the FreeBSD-1.1 compatable uname(2) interface.  These days it is
 153  * done in libc as a wrapper around a bunch of sysctl's.  This must maintain
 154  * the old 1.1 binary ABI.
 155  */
 156 #if SYS_NMLN != 32
 157 #error "FreeBSD-1.1 uname syscall has been broken"
 158 #endif
 159 #ifndef _SYS_SYSPROTO_H_
 160 struct uname_args {
 161         struct utsname  *name;
 162 };
 163 #endif
 164 /* ARGSUSED */
 165 int
 166 uname(td, uap)
 167         struct thread *td;
 168         struct uname_args *uap;
 169 {
 170         int name[2], error;
 171         size_t len;
 172         char *s, *us;
 173
 174         name[0] = CTL_KERN;
 175         name[1] = KERN_OSTYPE;
 176         len = sizeof (uap->name->sysname);
 177         mtx_lock(&Giant);
 178         error = userland_sysctl(td, name, 2, uap->name->sysname, &len,
 179                 1, 0, 0, 0, 0);
 180         if (error)
 181                 goto done2;
 182         subyte( uap->name->sysname + sizeof(uap->name->sysname) - 1, 0);
 183
 184         name[1] = KERN_HOSTNAME;
 185         len = sizeof uap->name->nodename;
 186         error = userland_sysctl(td, name, 2, uap->name->nodename, &len,
 187                 1, 0, 0, 0, 0);
 188         if (error)
 189                 goto done2;
 190         subyte( uap->name->nodename + sizeof(uap->name->nodename) - 1, 0);
 191
 192         name[1] = KERN_OSRELEASE;
 193         len = sizeof uap->name->release;
 194         error = userland_sysctl(td, name, 2, uap->name->release, &len,
 195                 1, 0, 0, 0, 0);
 196         if (error)
 197                 goto done2;
 198         subyte( uap->name->release + sizeof(uap->name->release) - 1, 0);
 199
 200 /*
 201         name = KERN_VERSION;
 202         len = sizeof uap->name->version;
 203         error = userland_sysctl(td, name, 2, uap->name->version, &len,
 204                 1, 0, 0, 0, 0);
 205         if (error)
 206                 goto done2;
 207         subyte( uap->name->version + sizeof(uap->name->version) - 1, 0);
 208 */
 209
 210 /*
 211  * this stupid hackery to make the version field look like FreeBSD 1.1
 212  */
 213         for(s = version; *s && *s != '#'; s++);
 214
 215         for(us = uap->name->version; *s && *s != ':'; s++) {
 216                 error = subyte( us++, *s);
 217                 if (error)
 218                         goto done2;
 219         }
 220         error = subyte( us++, 0);
 221         if (error)
 222                 goto done2;
 223
 224         name[0] = CTL_HW;
 225         name[1] = HW_MACHINE;
 226         len = sizeof uap->name->machine;
 227         error = userland_sysctl(td, name, 2, uap->name->machine, &len,
 228                 1, 0, 0, 0, 0);
 229         if (error)
 230                 goto done2;
 231         subyte( uap->name->machine + sizeof(uap->name->machine) - 1, 0);
 232 done2:
 233         mtx_unlock(&Giant);
 234         return (error);
 235 }
 236
 237 #ifndef _SYS_SYSPROTO_H_
 238 struct getdomainname_args {
 239         char    *domainname;
 240         int     len;
 241 };
 242 #endif
 243 /* ARGSUSED */
 244 int
 245 getdomainname(td, uap)
 246         struct thread *td;
 247         struct getdomainname_args *uap;
 248 {
 249         char tmpdomainname[MAXHOSTNAMELEN];
 250         int domainnamelen;
 251
 252         mtx_lock(&hostname_mtx);
 253         bcopy(V_domainname, tmpdomainname, sizeof(tmpdomainname));
 254         mtx_unlock(&hostname_mtx);
 255
 256         domainnamelen = strlen(tmpdomainname) + 1;
 257         if ((u_int)uap->len > domainnamelen)
 258                 uap->len = domainnamelen;
 259         return (copyout(tmpdomainname, uap->domainname, uap->len));
 260 }
 261
 262 #ifndef _SYS_SYSPROTO_H_
 263 struct setdomainname_args {
 264         char    *domainname;
 265         int     len;
 266 };
 267 #endif
 268 /* ARGSUSED */
 269 int
 270 setdomainname(td, uap)
 271         struct thread *td;
 272         struct setdomainname_args *uap;
 273 {
 274         char tmpdomainname[MAXHOSTNAMELEN];
 275         int error, domainnamelen;
 276
 277         error = priv_check(td, PRIV_SETDOMAINNAME);
 278         if (error)
 279                 return (error);
 280         if ((u_int)uap->len > sizeof(tmpdomainname) - 1)
 281                 return (EINVAL);
 282         domainnamelen = uap->len;
 283         error = copyin(uap->domainname, tmpdomainname, uap->len);
 284         if (error == 0) {
 285                 tmpdomainname[domainnamelen] = 0;
 286                 mtx_lock(&hostname_mtx);
 287                 bcopy(tmpdomainname, V_domainname, sizeof(domainname));
 288                 mtx_unlock(&hostname_mtx);
 289         }
 290         return (error);
 291 }