ChangeLogTag: Thu Jan 29 18:14:20 2004 Jeff Parsons <j.parsons@vanderbilt.edu>

2 files changed, 211 insertions, 1 deletions

diff --git a/TAO/ChangeLog b/TAO/ChangeLog
index 86644008fa8..f6c94079ca6 100644
--- a/TAO/ChangeLog
+++ b/TAO/ChangeLog
@@ -1,3 +1,12 @@
+Thu Jan 29 18:14:20 2004  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * TAO_IDL/util/utl_global.cpp:
+        
+          When executing validate_included_idl_files() on a non-windows
+          platform, the system function realpath() is called. Denny
+          Kolb <kolb@g2ss.com> has submitted a version for use on LynxOS,
+          which does not have a native version of this function.
+
 Thu Jan 29 15:33:16 2004  Jeff Parsons <j.parsons@vanderbilt.edu>
 
         * tao/TypeCodeFactory/TypeCodeFactory_i.cpp:
diff --git a/TAO/TAO_IDL/util/utl_global.cpp b/TAO/TAO_IDL/util/utl_global.cpp
index 7d22ee5c3ad..332c0c99690 100644
--- a/TAO/TAO_IDL/util/utl_global.cpp
+++ b/TAO/TAO_IDL/util/utl_global.cpp
@@ -711,7 +711,208 @@ IDL_GlobalData::n_included_idl_files (size_t n)
   this->n_included_idl_files_ = n;
 }
 
-// Validate the included idl files, somefiles might have been
+// We need 'realpath' in validate_included_idl_files() below, if
+// we are on a non_Windows platform. This has been submitted by
+// by Denny Kolb <kolb@g2ss.com> for folks who are working on
+// LynxOS and are not cross-compiling the IDL compiler.
+
+#if defined (__Lynx__)
+
+/* 
+ * 'realpath' is not implemented as part of the LynxOS 4.0 libc 
+ * distribution so in order to use it we must include a version 
+ * here. 
+ *
+ * Copyright (c) 2003 Constantin S. Svintsoff <kostik@@iclub.nsu.ru>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The names of the authors may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * char *realpath(const char *path, char resolved[PATH_MAX]);
+ *
+ * Find the real name of path, by removing all ".", ".." and symlink
+ * components.  Returns (resolved) on success, or (NULL) on failure,
+ * in which case the path which caused trouble is left in (resolved).
+ */
+char *
+realpath(const char *path, char resolved[PATH_MAX])
+{
+  struct stat sb;
+  char *p, *q, *s;
+          char *left_tmp, *resolved_tmp;
+  size_t left_len, resolved_len;
+  unsigned symlinks;
+  int serrno, slen;
+  char left[PATH_MAX], next_token[PATH_MAX], symlink[PATH_MAX];
+
+  serrno = errno;
+  symlinks = 0;
+  if (path[0] == '/') {
+ 	  resolved[0] = '/';
+ 	  resolved[1] = '\0';
+ 	  if (path[1] == '\0')
+ 		  return (resolved);
+ 	  resolved_len = 1;
+ 	  left_tmp = strncpy(left, path + 1, sizeof(left));
+                  left_len = strlen(left_tmp);
+  } else {
+ 	  if (getcwd(resolved, PATH_MAX) == NULL) {
+ 		  strncpy(resolved, ".", PATH_MAX);
+ 		  return (NULL);
+ 	  }
+ 	  resolved_len = strlen(resolved);
+ 	  left_tmp = strncpy(left, path, sizeof(left));
+                  left_len = strlen(left_tmp);
+  }
+  if (left_len >= sizeof(left) || resolved_len >= PATH_MAX) {
+ 	  errno = ENAMETOOLONG;
+ 	  return (NULL);
+  }
+
+  /*
+ 	 * Iterate over path components in `left'.
+ 	 */
+  while (left_len != 0) {
+ 	  /*
+ 		 * Extract the next path component and adjust `left'
+ 		 * and its length.
+ 		 */
+ 	  p = strchr(left, '/');
+ 	  s = p ? p : left + left_len;
+ 	  if (s - left >= sizeof(next_token)) {
+ 		  errno = ENAMETOOLONG;
+ 		  return (NULL);
+ 	  }
+ 	  memcpy(next_token, left, s - left);
+ 	  next_token[s - left] = '\0';
+ 	  left_len -= s - left;
+ 	  if (p != NULL)
+ 		  memmove(left, s + 1, left_len + 1);
+ 	  if (resolved[resolved_len - 1] != '/') {
+ 		  if (resolved_len + 1 >= PATH_MAX) {
+ 			  errno = ENAMETOOLONG;
+ 			  return (NULL);
+ 		  }
+ 		  resolved[resolved_len++] = '/';
+ 		  resolved[resolved_len] = '\0';
+ 	  }
+ 	  if (next_token[0] == '\0')
+ 		  continue;
+ 	  else if (strcmp(next_token, ".") == 0)
+ 		  continue;
+ 	  else if (strcmp(next_token, "..") == 0) {
+ 		  /*
+ 			 * Strip the last path component except when we have
+ 			 * single "/"
+ 			 */
+ 		  if (resolved_len > 1) {
+ 			  resolved[resolved_len - 1] = '\0';
+ 			  q = strrchr(resolved, '/') + 1;
+ 			  *q = '\0';
+ 			  resolved_len = q - resolved;
+ 		  }
+ 		  continue;
+ 	  }
+
+ 	  /*
+ 		 * Append the next path component and lstat() it. If
+ 		 * lstat() fails we still can return successfully if
+ 		 * there are no more path components left.
+ 		 */
+ 	  resolved_tmp = strncat(resolved, next_token, PATH_MAX);
+ 	  resolved_len = strlen(resolved_tmp);
+ 	  if (resolved_len >= PATH_MAX) {
+ 		  errno = ENAMETOOLONG;
+ 		  return (NULL);
+ 	  }
+ 	  if (lstat(resolved, &sb) != 0) {
+ 		  if (errno == ENOENT && p == NULL) {
+ 			  errno = serrno;
+ 			  return (resolved);
+ 		  }
+ 		  return (NULL);
+ 	  }
+ 	  if (S_ISLNK(sb.st_mode)) {
+ 		  if (symlinks++ > MAXSYMLINKS) {
+ 			  errno = ELOOP;
+ 			  return (NULL);
+ 		  }
+ 		  slen = readlink(resolved, symlink, sizeof(symlink) - 1);
+ 		  if (slen < 0)
+ 			  return (NULL);
+ 		  symlink[slen] = '\0';
+ 		  if (symlink[0] == '/') {
+ 			  resolved[1] = 0;
+ 			  resolved_len = 1;
+ 		  } else if (resolved_len > 1) {
+ 			  /* Strip the last path component. */
+ 			  resolved[resolved_len - 1] = '\0';
+ 			  q = strrchr(resolved, '/') + 1;
+ 			  *q = '\0';
+ 			  resolved_len = q - resolved;
+ 		  }
+
+ 		  /*
+ 			 * If there are any path components left, then
+ 			 * append them to symlink. The result is placed
+ 			 * in `left'.
+ 			 */
+ 		  if (p != NULL) {
+ 			  if (symlink[slen - 1] != '/') {
+ 				  if (slen + 1 >= sizeof(symlink)) {
+ 					  errno = ENAMETOOLONG;
+ 					  return (NULL);
+ 				  }
+ 				  symlink[slen] = '/';
+ 				  symlink[slen + 1] = 0;
+ 			  }
+ 			  left_tmp = strncat(symlink, left, sizeof(left));
+ 			  left_len = strlen(left_tmp);
+ 			  if (left_len >= sizeof(left)) {
+ 				  errno = ENAMETOOLONG;
+ 				  return (NULL);
+ 			  }
+ 		  }
+ 		  left_tmp = strncpy(left, symlink, sizeof(left));
+ 		  left_len = strlen(left_tmp);
+ 	  }
+  }
+
+  /*
+ 	 * Remove trailing slash except when the resolved pathname
+ 	 * is a single "/".
+ 	 */
+  if (resolved_len > 1 && resolved[resolved_len - 1] == '/')
+ 	  resolved[resolved_len - 1] = '\0';
+  return (resolved);
+}
+
+#endif /* __Lynx__ */
+
+// Validate the included idl files, some files might have been
 // ignored by the preprocessor.
 void
 IDL_GlobalData::validate_included_idl_files (void)