diff options
| -rw-r--r-- | libc/Android.mk | 2 | ||||
| -rw-r--r-- | libc/bionic/getcwd.cpp (renamed from libc/unistd/getcwd.c) | 46 | ||||
| -rw-r--r-- | tests/Android.mk | 1 | ||||
| -rw-r--r-- | tests/getcwd_test.cpp | 85 |
4 files changed, 128 insertions, 6 deletions
diff --git a/libc/Android.mk b/libc/Android.mk index c66ec5936..364f4cacb 100644 --- a/libc/Android.mk +++ b/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 \ diff --git a/libc/unistd/getcwd.c b/libc/bionic/getcwd.cpp index 117244554..e06f52eaa 100644 --- a/libc/unistd/getcwd.c +++ b/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; } diff --git a/tests/Android.mk b/tests/Android.mk index 2721138f9..e9fdde1ed 100644 --- a/tests/Android.mk +++ b/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: diff --git a/tests/getcwd_test.cpp b/tests/getcwd_test.cpp new file mode 100644 index 000000000..45ff395bd --- /dev/null +++ b/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; +} |