Merge "Enhance getcwd(3) to handle NULL like glibc."

libc/Android.mk

@@ -17,7 +17,6 @@ libc_common_src_files := \
 	unistd/fstatfs.c \
 	unistd/ftime.c \
 	unistd/ftok.c \
-	unistd/getcwd.c \
 	unistd/getdtablesize.c \
 	unistd/gethostname.c \
 	unistd/getopt_long.c \
@@ -275,6 +274,7 @@ libc_common_src_files := \
 	bionic/fdprintf.c \
 	bionic/fork.c \
 	bionic/fts.c \
+	bionic/getcwd.cpp \
 	bionic/if_nametoindex.c \
 	bionic/if_indextoname.c \
 	bionic/ioctl.c \

libc/bionic/getcwd.cpp

@@ -25,16 +25,52 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
+
 #include <unistd.h>
 #include <errno.h>
 
-extern int __getcwd(char * buf, size_t size);
+extern "C" int __getcwd(char* buf, size_t size);
 
-char *getcwd(char *buf, size_t size)
-{
-  if (buf == NULL || size == 0) {
+char* getcwd(char* buf, size_t size) {
+  // You can't specify size 0 unless you're asking us to allocate for you.
+  if (buf != NULL && size == 0) {
     errno = EINVAL;
     return NULL;
   }
-  return ( __getcwd(buf, size) < 0 ) ? NULL : buf;
+
+  // Allocate a buffer if necessary.
+  char* allocated_buf = NULL;
+  if (buf == NULL) {
+    size_t allocated_size = size;
+    if (size == 0) {
+      // The Linux kernel won't return more than a page, so translate size 0 to 4KiB.
+      // TODO: if we need to support paths longer than that, we'll have to walk the tree ourselves.
+      size = getpagesize();
+    }
+    buf = allocated_buf = reinterpret_cast<char*>(malloc(allocated_size));
+    if (buf == NULL) {
+      // malloc set errno.
+      return NULL;
+    }
+  }
+
+  // Ask the kernel to fill our buffer.
+  int rc = __getcwd(buf, size);
+  if (rc == -1) {
+    free(allocated_buf);
+    // __getcwd set errno.
+    return NULL;
+  }
+
+  // If we allocated a whole page, only return as large an allocation as necessary.
+  if (allocated_buf != NULL) {
+    if (size == 0) {
+      buf = strdup(allocated_buf);
+      free(allocated_buf);
+    } else {
+      buf = allocated_buf;
+    }
+  }
+
+  return buf;
 }

tests/Android.mk

@@ -20,6 +20,7 @@ test_module = bionic-unit-tests
 test_tags = eng tests
 
 test_src_files = \
+    getcwd_test.cpp \
     regex_test.cpp \
 
 # Build for the device (with bionic). Run with:

tests/getcwd_test.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+
+TEST(getcwd, auto_full) {
+  // If we let the library do all the work, everything's fine.
+  errno = 0;
+  char* cwd = getcwd(NULL, 0);
+  ASSERT_TRUE(cwd != NULL);
+  ASSERT_EQ(errno, 0);
+  ASSERT_GE(strlen(cwd), 1U);
+  free(cwd);
+}
+
+TEST(getcwd, auto_reasonable) {
+  // If we ask the library to allocate a reasonable buffer, everything's fine.
+  errno = 0;
+  char* cwd = getcwd(NULL, PATH_MAX);
+  ASSERT_TRUE(cwd != NULL);
+  ASSERT_EQ(errno, 0);
+  ASSERT_GE(strlen(cwd), 1U);
+  free(cwd);
+}
+
+TEST(getcwd, auto_too_small) {
+  // If we ask the library to allocate a too-small buffer, ERANGE.
+  errno = 0;
+  char* cwd = getcwd(NULL, 1);
+  ASSERT_TRUE(cwd == NULL);
+  ASSERT_EQ(errno, ERANGE);
+}
+
+TEST(getcwd, auto_too_large) {
+  // If we ask the library to allocate an unreasonably large buffer, ERANGE.
+  errno = 0;
+  char* cwd = getcwd(NULL, static_cast<size_t>(-1));
+  ASSERT_TRUE(cwd == NULL);
+  ASSERT_EQ(errno, ENOMEM);
+}
+
+TEST(getcwd, manual_too_small) {
+  // If we allocate a too-small buffer, ERANGE.
+  char tiny_buf[1];
+  errno = 0;
+  char* cwd = getcwd(tiny_buf, sizeof(tiny_buf));
+  ASSERT_TRUE(cwd == NULL);
+  ASSERT_EQ(errno, ERANGE);
+}
+
+TEST(getcwd, manual_zero) {
+  // If we allocate a zero-length buffer, EINVAL.
+  char tiny_buf[1];
+  errno = 0;
+  char* cwd = getcwd(tiny_buf, 0);
+  ASSERT_TRUE(cwd == NULL);
+  ASSERT_EQ(errno, EINVAL);
+}
+
+TEST(getcwd, manual_path_max) {
+  char* buf = new char[PATH_MAX];
+  errno = 0;
+  char* cwd = getcwd(buf, PATH_MAX);
+  ASSERT_TRUE(cwd == buf);
+  ASSERT_EQ(errno, 0);
+  ASSERT_GE(strlen(cwd), 1U);
+  delete[] cwd;
+}