Formerly host.c.~3~

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;
+}