summaryrefslogtreecommitdiff
path: root/proc/host.c
diff options
context:
space:
mode:
Diffstat (limited to 'proc/host.c')
-rw-r--r--proc/host.c251
1 files changed, 251 insertions, 0 deletions
diff --git a/proc/host.c b/proc/host.c
index 0f5919c2..7486d400 100644
--- a/proc/host.c
+++ b/proc/host.c
@@ -28,6 +28,9 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <string.h>
#include <hurd/exec.h>
+#define HURD_VERSION_DEFINE
+#include <hurd/version.h>
+
#include "proc.h"
#include "proc_S.h"
@@ -37,6 +40,18 @@ static int hostnamelen;
static mach_port_t *std_port_array;
static int *std_int_array;
static int n_std_ports, n_std_ints;
+static struct utsname uname_info;
+static char *machversion;
+
+struct server_version
+{
+ char *name,
+ char *version,
+ char *release,
+} *server_versions;
+int nserver_versions, server_version_nalloc;
+
+
struct execdata_notify
{
@@ -72,6 +87,7 @@ S_proc_sethostname (struct proc *p,
char *newhostname,
u_int newhostnamelen)
{
+ int len;
if (! check_uid (p, 0))
return EPERM;
@@ -84,6 +100,12 @@ S_proc_sethostname (struct proc *p,
bcopy (newhostname, hostname, newhostnamelen);
hostname[newhostnamelen] = '\0';
+ len = newhostnamelen + 1;
+ if (len > sizeof uname_info.nodename)
+ len = sizeof uname_info.nodename;
+ bcopy (hostname, uname_info.nodename, len);
+ uname_info.nodename[sizeof uname_info.nodename] = '\0';
+
return 0;
}
@@ -205,3 +227,232 @@ S_proc_execdata_notify (struct proc *p,
return 0;
}
+/* Version information handling.
+
+ A server registers its name, and version with
+ startup_register_version. Each release of the Hurd is defined by
+ some set of versions for the programs making up the Hurd (found in
+ <hurd/version.h>). If the server being being registered matches its
+ entry in that file, then the register request is ignored.
+
+ These are then element of `struct utsname', returned by uname. The
+ release is compared against `hurd_release', as compiled into init.
+ If it matches, it is omitted. A typical version string for the
+ system might be:
+
+ "GNU Hurd Version 0.0 [Mach 3.0 VERSION(MK75)] auth 2.6"
+ Which indicates that the Hurd servers are all from Hurd 0.0 except
+ for auth, which is auth version 2.6.
+
+ The version for the Hurd itself comes from <hurd/hurd_types.h> and
+ is compiled into proc. */
+
+kern_return_t
+S_proc_register_version (startup_t server,
+ mach_port_t credential,
+ const char *name,
+ const char *release,
+ const char *version)
+{
+ int i, j;
+
+ if (credential != host_priv)
+ /* Must be privileged to register for uname. */
+ return EPERM;
+
+ for (i = 0; i < nserver_versions; i++)
+ if (!strcmp (name, server_versions[i].name))
+ {
+ /* Change this entry */
+ free (server_versions[i].version);
+ free (server_versions[i].release);
+ server_versions[i].version = malloc (strlen (version) + 1);
+ server_versions[i].release = malloc (strlen (version) + 1);
+ strcpy (server_versions[i].version, version);
+ strcpy (server_versions[i].release, release);
+ break;
+ }
+ if (i == nserver_versions)
+ {
+ /* Didn't find it; extend. */
+ if (nserver_versions == versalloc)
+ {
+ server_version_nalloc *= 2;
+ server_versions
+ = realloc (server_versions,
+ sizeof (struct server_version) * server_version_nalloc);
+ }
+ server_versions[nserver_versions].name = malloc (strlen (name) + 1);
+ server_versions[nserver_versions].version = malloc (strlen (version)
+ + 1);
+ server_versions[nserver_versions].release = malloc (strlen (release)
+ + 1);
+ strcpy (server_versions[nserver_versions].name, name);
+ strcpy (server_versions[nserver_versions].version, version);
+ strcpy (server_versions[nserver_versions].release, release);
+ nserver_versions++;
+ }
+
+ rebuild_uname ();
+ mach_port_deallocate (mach_task_self (), credential);
+ return 0;
+}
+
+/* Rebuild the uname version string. */
+static void
+rebuild_uname ()
+{
+ int i, j;
+ int nmatches, greatestmatch;
+ char *hurdrelease;
+ struct hurd_version *runninghurd;
+ char *p = uname_info.version;
+ char *end = &uname_info.version[sizeof uname_info.version];
+
+ /* Tell if the SERVER was distributed in HURD. */
+ inline int version_matches (struct server_version *server,
+ struct hurd_version *hurd)
+ {
+ int i;
+ if (strcmp (server->release, hurd->hurdrelease))
+ return 0;
+ for (i = 0; i < hurd->nservers, i++)
+ if (!strcmp (server->name, hurd->vers[i].name)
+ && !strcmp (server->version, hurd->vers[i].version))
+ return 1;
+ return 0;
+ }
+
+ /* Add STR to uname_info.version. */
+ inline void addstr (char *string)
+ {
+ if (p < end)
+ {
+ size_t len = strlen (string);
+ if (end - 1 - p < len)
+ memcpy (p, string, len);
+ p += len;
+ }
+ }
+
+ /* Look through the hurd_versions array and find the spec which matches
+ the most releases of our versions; this will define the release. */
+ greatestmatch = 0;
+ for (i = 0; i < nhurd_versions; i++)
+ {
+ nmatches = 0;
+ for (j = 0; j < nserver_versions; j++)
+ if (!strcmp (hurd_versions[i].hurdrelease, server_versions[j].release))
+ nmatches++;
+ if (nmatches >= greatestmatch)
+ {
+ greatestmatch = nmatches;
+ hurdrelease = hurd_versions[i].hurdrelease;
+ }
+ }
+
+ /* Now try and figure out which of the hurd versions that is this release
+ we should deem the version; again, base it on which has the greatest
+ number of matches among running servers. */
+ greatestmatch = 0;
+ for (i = 0; i < nhurd_versions; i++)
+ {
+ if (strcmp (hurd_versions[i].hurdrelease, hurdrelease))
+ continue;
+ nmatches = 0;
+ for (j = 0; j < nserver_versions; j++)
+ if (version_matches (&server_versions[j], &hurd_versions[i]))
+ nmatches++;
+ if (nmatches >= greatestmatch)
+ {
+ greatestmatch = nmatches;
+ runninghurd = &hurd_versions[i];
+ }
+ }
+
+ /* Now build the uname strings. The uname "release" looks like this:
+ GNU Hurd Release N.NN (kernel-version)
+ */
+ sprintf (uname_info.release, "GNU Hurd Release %s (%s)",
+ runninghurd->hurdrelease, machversion);
+
+ /* The uname "version" looks like this:
+ GNU Hurd Release N.NN, Version N.NN (kernel-version)
+ followed by a spec for each server that does not match the one
+ in runninghurd in the form "(ufs N.NN)" or the form
+ "(ufs N.NN [M.MM])"; N.NN is the version of the server and M.MM
+ is the Hurd release it expects. */
+ addstr ("GNU Hurd Release ");
+ addstr (runninghurd->hurdrelease);
+ addstr (", Version ");
+ addstr (runninghurd->hurdversion);
+ addstr (" (");
+ addstr (machversion);
+ addstr (")");
+
+ for (i = 0; i < nserver_versions; i++)
+ if (!version_matches (&server_versions[i], runninghurd))
+ {
+ addstr ("; (");
+ addstr (server_versions[i].name);
+ addstr (" ");
+ addstr (server_versions[i].version);
+ if (!strcmp (server_versions[i].release, runninghurd->hurdrelease))
+ {
+ addstr (" [");
+ addstr (server_versions[i].release);
+ addstr ("]");
+ }
+ addstr (")");
+ }
+
+ *p = '\0'; /* Null terminate uname_info.version */
+}
+
+
+void
+initialize_version_info (void)
+{
+ kernel_version_t kernel_version;
+ char *p;
+ struct host_basic_info info;
+ size_t n = sizeof info;
+
+ /* Fill in fixed slots sysname and machine. */
+ strcpy (uname_info.sysname, "GNU");
+
+ host_info (mach_host_self (), HOST_BASIC_INFO, &info, &n);
+ sprintf (uname_info.machine, "%s %s",
+ mach_cpu_types[info.cpu_type],
+ mach_cpu_subtypes[info.cpu_type][info.cpu_subtype]);
+
+ /* Construct machversion for use in release and version strings. */
+ host_kernel_version (mach_host_self (), kernel_version);
+ p = index (kernel_version, ':');
+ if (p)
+ *p = '\0';
+ strcpy (machversion, kernel_version);
+
+ /* Notice our own version and initialize server version varables. */
+ server_versions = malloc (sizeof (struct server_version) * 10);
+ server_versions_nalloc = 10;
+ nserver_versions = 1;
+ server_versions->name = malloc (sizeof OUR_SERVER_NAME);
+ server_versions->release = malloc (sizeof HURD_RELEASE);
+ server_versions->version = malloc (sizeof OUR_VERSION);
+ strcpy (server_versions->name, OUR_SERVER_NAME);
+ strcpy (server_versions->release, HURD_RELEASE);
+ strcpy (server_versions->version, OUR_VERSION);
+
+ rebuild_uname ();
+
+ uname_info.nodename[0] = '\0';
+}
+
+kern_return_t
+S_proc_uname (process_t process,
+ struct utsanme *uname)
+{
+ *uname = uname_info;
+ return 0;
+}