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 } 292