1 files changed, 119 insertions, 52 deletions

diff --git a/src/w32.c b/src/w32.c
index a7fd59366d6..243948c0a03 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -289,9 +289,9 @@ init_user_info ()
 
   /* Ensure HOME and SHELL are defined. */
   if (getenv ("HOME") == NULL)
-    putenv ("HOME=c:/");
+    abort ();
   if (getenv ("SHELL") == NULL)
-    putenv (os_subtype == OS_WIN95 ? "SHELL=command" : "SHELL=cmd");
+    abort ();
 
   /* Set dir and shell from environment variables. */
   strcpy (the_passwd.pw_dir, getenv ("HOME"));
@@ -692,52 +692,96 @@ init_environment (char ** argv)
                      Qnil)),
        "While setting TMPDIR: ");
 
-  /* Check for environment variables and use registry if they don't exist */
+  /* Check for environment variables and use registry settings if they
+     don't exist.  Fallback on default values where applicable.  */
   {
     int i;
     LPBYTE lpval;
     DWORD dwType;
 
-    static char * env_vars[] = 
-    {
-      "HOME",
-      "PRELOAD_WINSOCK",
-      "emacs_dir",
-      "EMACSLOADPATH",
-      "SHELL",
-      "CMDPROXY",
-      "EMACSDATA",
-      "EMACSPATH",
-      "EMACSLOCKDIR",
+    static struct env_entry
+    {
+      char * name;
+      char * def_value;
+    } env_vars[] = 
+    {
+      {"HOME", "C:/"},
+      {"PRELOAD_WINSOCK", NULL},
+      {"emacs_dir", "C:/emacs"},
+      {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
+      {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
+      {"EMACSDATA", "%emacs_dir%/etc"},
+      {"EMACSPATH", "%emacs_dir%/bin"},
+      {"EMACSLOCKDIR", "%emacs_dir%/lock"},
       /* We no longer set INFOPATH because Info-default-directory-list
-         is then ignored.  We use a hook in winnt.el instead.  */
-      /*      "INFOPATH", */
-      "EMACSDOC",
-      "TERM",
+         is then ignored.  */
+      /*  {"INFOPATH", "%emacs_dir%/info"},  */
+      {"EMACSDOC", "%emacs_dir%/etc"},
+      {"TERM", "cmd"}
     };
 
+#define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
+
+    /* Treat emacs_dir specially: set it unconditionally based on our
+       location, if it appears that we are running from the bin subdir
+       of a standard installation.  */
+    {
+      char *p;
+      char modname[MAX_PATH];
+
+      if (!GetModuleFileName (NULL, modname, MAX_PATH))
+        abort ();
+      if ((p = strrchr (modname, '\\')) == NULL)
+        abort ();
+      *p = 0;
+
+      if ((p = strrchr (modname, '\\')) && stricmp (p, "\\bin") == 0)
+        {
+          char buf[SET_ENV_BUF_SIZE];
+
+          *p = 0;
+          for (p = modname; *p; p++)
+            if (*p == '\\') *p = '/';
+                  
+          _snprintf (buf, sizeof(buf)-1, "emacs_dir=%s", modname);
+          putenv (strdup (buf));
+        }
+    }
+
     for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++) 
       {
-        if (!getenv (env_vars[i])
-            && (lpval = w32_get_resource (env_vars[i], &dwType)) != NULL)
+        if (!getenv (env_vars[i].name))
           {
-            if (dwType == REG_EXPAND_SZ)
-              {
-                char buf1[500], buf2[500];
+            int dont_free = 0;
 
-                ExpandEnvironmentStrings ((LPSTR) lpval, buf1, 500);
-                _snprintf (buf2, 499, "%s=%s", env_vars[i], buf1);
-                putenv (strdup (buf2));
+            if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL)
+              {
+                lpval = env_vars[i].def_value;
+                dwType = REG_EXPAND_SZ;
+                dont_free = 1;
               }
-            else if (dwType == REG_SZ)
+
+            if (lpval)
               {
-                char buf[500];
+                if (dwType == REG_EXPAND_SZ)
+                  {
+                    char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
+
+                    ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof(buf1));
+                    _snprintf (buf2, sizeof(buf2)-1, "%s=%s", env_vars[i].name, buf1);
+                    putenv (strdup (buf2));
+                  }
+                else if (dwType == REG_SZ)
+                  {
+                    char buf[SET_ENV_BUF_SIZE];
                   
-                _snprintf (buf, 499, "%s=%s", env_vars[i], lpval);
-                putenv (strdup (buf));
-              }
+                    _snprintf (buf, sizeof(buf)-1, "%s=%s", env_vars[i].name, lpval);
+                    putenv (strdup (buf));
+                  }
 
-            xfree (lpval);
+                if (!dont_free)
+                  xfree (lpval);
+              }
           }
       }
   }
@@ -1149,6 +1193,13 @@ map_w32_filename (const char * name, const char ** pPath)
   char * path;
   const char * save_name = name;
 
+  if (strlen (name) >= MAX_PATH)
+    {
+      /* Return a filename which will cause callers to fail.  */
+      strcpy (shortname, "?");
+      return shortname;
+    }
+
   if (is_fat_volume (name, &path)) /* truncate to 8.3 */
     {
       register int left = 8;    /* maximum number of chars in part */
@@ -2548,35 +2599,51 @@ sys_socket(int af, int type, int protocol)
           _set_osfhnd (fd, s);
           /* setmode (fd, _O_BINARY); */
 #else
-          /* Make a non-inheritable copy of the socket handle. */
+          /* Make a non-inheritable copy of the socket handle.  Note
+             that it is possible that sockets aren't actually kernel
+             handles, which appears to be the case on Windows 9x when
+             the MS Proxy winsock client is installed.  */
           {
-            HANDLE parent;
-            HANDLE new_s = INVALID_HANDLE_VALUE;
-
-            parent = GetCurrentProcess ();
-
             /* Apparently there is a bug in NT 3.51 with some service
                packs, which prevents using DuplicateHandle to make a
                socket handle non-inheritable (causes WSACleanup to
                hang).  The work-around is to use SetHandleInformation
                instead if it is available and implemented. */
-            if (!pfn_SetHandleInformation
-                || !pfn_SetHandleInformation ((HANDLE) s,
-                                              HANDLE_FLAG_INHERIT,
-                                              0))
+            if (pfn_SetHandleInformation)
+              {
+                pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
+              }
+            else
               {
-                DuplicateHandle (parent,
-                                 (HANDLE) s,
-                                 parent,
-                                 &new_s,
-                                 0,
-                                 FALSE,
-                                 DUPLICATE_SAME_ACCESS);
-                pfn_closesocket (s);
-                s = (SOCKET) new_s;
+                HANDLE parent = GetCurrentProcess ();
+                HANDLE new_s = INVALID_HANDLE_VALUE;
+
+                if (DuplicateHandle (parent,
+                                     (HANDLE) s,
+                                     parent,
+                                     &new_s,
+                                     0,
+                                     FALSE,
+                                     DUPLICATE_SAME_ACCESS))
+                  {
+                    /* It is possible that DuplicateHandle succeeds even
+                       though the socket wasn't really a kernel handle,
+                       because a real handle has the same value.  So
+                       test whether the new handle really is a socket.  */
+                    long nonblocking = 0;
+                    if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
+                      {
+                        pfn_closesocket (s);
+                        s = (SOCKET) new_s;
+                      }
+                    else
+                      {
+                        CloseHandle (new_s);
+                      }
+                  } 
               }
-            fd_info[fd].hnd = (HANDLE) s;
           }
+          fd_info[fd].hnd = (HANDLE) s;
 #endif
 
           /* set our own internal flags */