Merge "Include what we use."
diff --git a/libc/Android.bp b/libc/Android.bp
index a02139a..52e53e2 100644
--- a/libc/Android.bp
+++ b/libc/Android.bp
@@ -1402,6 +1402,7 @@
"bionic/wmempcpy.cpp",
"system_properties/context_node.cpp",
"system_properties/contexts_split.cpp",
+ "system_properties/contexts_serialized.cpp",
"system_properties/prop_area.cpp",
"system_properties/prop_info.cpp",
"system_properties/system_properties.cpp",
@@ -1423,6 +1424,7 @@
cflags: ["-D__ANDROID_TREBLE__"],
},
},
+ whole_static_libs: ["libpropertyinfoparser"],
cppflags: ["-Wold-style-cast"],
local_include_dirs: ["stdio"],
include_dirs: ["bionic/libstdc++/include"],
diff --git a/libc/stdio/vfscanf.c b/libc/stdio/vfscanf.c
index 887b435..c9e4385 100644
--- a/libc/stdio/vfscanf.c
+++ b/libc/stdio/vfscanf.c
@@ -324,10 +324,7 @@
/* scan arbitrary characters (sets NOSKIP) */
if (width == 0) width = 1;
if (flags & LONG) {
- if ((flags & SUPPRESS) == 0)
- wcp = va_arg(ap, wchar_t*);
- else
- wcp = NULL;
+ wcp = ((flags & SUPPRESS) == 0) ? va_arg(ap, wchar_t*) : NULL;
n = 0;
while (width != 0) {
if (n == (int)MB_CUR_MAX) {
@@ -388,20 +385,17 @@
break;
case CT_CCL:
- /* scan a (nonempty) character class (sets NOSKIP) */
- if (width == 0) width = (size_t)~0; /* `infinity' */
- /* take only those things in the class */
+ case CT_STRING:
+ // CT_CCL: scan a (nonempty) character class (sets NOSKIP).
+ // CT_STRING: like CCL, but zero-length string OK, & no NOSKIP.
+ if (width == 0) width = (size_t)~0; // 'infinity'.
if (flags & LONG) {
wchar_t twc;
- int nchars;
+ int nchars = 0;
- if ((flags & SUPPRESS) == 0)
- wcp = va_arg(ap, wchar_t*);
- else
- wcp = &twc;
+ wcp = (flags & SUPPRESS) == 0 ? va_arg(ap, wchar_t*) : &twc;
n = 0;
- nchars = 0;
- while (width != 0) {
+ while ((c == CT_CCL || !isspace(*fp->_p)) && width != 0) {
if (n == (int)MB_CUR_MAX) {
fp->_flags |= __SERR;
goto input_failure;
@@ -417,7 +411,7 @@
}
if (nconv == 0) *wcp = L'\0';
if (nconv != (size_t)-2) {
- if (wctob(*wcp) != EOF && !ccltab[wctob(*wcp)]) {
+ if ((c == CT_CCL && wctob(*wcp) != EOF && !ccltab[wctob(*wcp)]) || (c == CT_STRING && iswspace(*wcp))) {
while (n != 0) {
n--;
ungetc(buf[n], fp);
@@ -438,121 +432,46 @@
break;
}
}
- if (n != 0) {
+ if (c == CT_CCL && n != 0) {
fp->_flags |= __SERR;
goto input_failure;
}
n = nchars;
- if (n == 0) goto match_failure;
- if (!(flags & SUPPRESS)) {
- *wcp = L'\0';
- nassigned++;
- }
- } else
- /* take only those things in the class */
- if (flags & SUPPRESS) {
+ } else if (flags & SUPPRESS) {
n = 0;
- while (ccltab[*fp->_p]) {
+ while ((c == CT_CCL && ccltab[*fp->_p]) || (c == CT_STRING && !isspace(*fp->_p))) {
n++, fp->_r--, fp->_p++;
if (--width == 0) break;
if (fp->_r <= 0 && __srefill(fp)) {
- if (n == 0) goto input_failure;
+ if (c == CT_CCL && n == 0) goto input_failure;
break;
}
}
- if (n == 0) goto match_failure;
} else {
p0 = p = va_arg(ap, char*);
- while (ccltab[*fp->_p]) {
+ while ((c == CT_CCL && ccltab[*fp->_p]) || (c == CT_STRING && !isspace(*fp->_p))) {
fp->_r--;
*p++ = *fp->_p++;
if (--width == 0) break;
if (fp->_r <= 0 && __srefill(fp)) {
- if (p == p0) goto input_failure;
+ if (c == CT_CCL && p == p0) goto input_failure;
break;
}
}
n = p - p0;
- if (n == 0) goto match_failure;
- *p = '\0';
- nassigned++;
+ }
+ if (c == CT_CCL && n == 0) goto match_failure;
+ if (!(flags & SUPPRESS)) {
+ if (flags & LONG) {
+ *wcp = L'\0';
+ } else {
+ *p = '\0';
+ }
+ ++nassigned;
}
nread += n;
break;
- case CT_STRING:
- /* like CCL, but zero-length string OK, & no NOSKIP */
- if (width == 0) width = (size_t)~0;
- if (flags & LONG) {
- wchar_t twc;
-
- if ((flags & SUPPRESS) == 0)
- wcp = va_arg(ap, wchar_t*);
- else
- wcp = &twc;
- n = 0;
- while (!isspace(*fp->_p) && width != 0) {
- if (n == (int)MB_CUR_MAX) {
- fp->_flags |= __SERR;
- goto input_failure;
- }
- buf[n++] = *fp->_p;
- fp->_p++;
- fp->_r--;
- memset(&mbs, 0, sizeof(mbs));
- nconv = mbrtowc(wcp, buf, n, &mbs);
- if (nconv == (size_t)-1) {
- fp->_flags |= __SERR;
- goto input_failure;
- }
- if (nconv == 0) *wcp = L'\0';
- if (nconv != (size_t)-2) {
- if (iswspace(*wcp)) {
- while (n != 0) {
- n--;
- ungetc(buf[n], fp);
- }
- break;
- }
- nread += n;
- width--;
- if (!(flags & SUPPRESS)) wcp++;
- n = 0;
- }
- if (fp->_r <= 0 && __srefill(fp)) {
- if (n != 0) {
- fp->_flags |= __SERR;
- goto input_failure;
- }
- break;
- }
- }
- if (!(flags & SUPPRESS)) {
- *wcp = L'\0';
- nassigned++;
- }
- } else if (flags & SUPPRESS) {
- n = 0;
- while (!isspace(*fp->_p)) {
- n++, fp->_r--, fp->_p++;
- if (--width == 0) break;
- if (fp->_r <= 0 && __srefill(fp)) break;
- }
- nread += n;
- } else {
- p0 = p = va_arg(ap, char*);
- while (!isspace(*fp->_p)) {
- fp->_r--;
- *p++ = *fp->_p++;
- if (--width == 0) break;
- if (fp->_r <= 0 && __srefill(fp)) break;
- }
- *p = '\0';
- nread += p - p0;
- nassigned++;
- }
- continue;
-
case CT_INT:
/* scan an integer as if by strtoimax/strtoumax */
#ifdef hardway
diff --git a/libc/stdio/vfwscanf.c b/libc/stdio/vfwscanf.c
index 1030a62..71cd49b 100644
--- a/libc/stdio/vfwscanf.c
+++ b/libc/stdio/vfwscanf.c
@@ -182,7 +182,7 @@
if ((wi = __fgetwc_unlock(fp)) == WEOF) goto input_failure;
if (wi != c) {
__ungetwc(wi, fp);
- goto input_failure;
+ goto match_failure;
}
nread++;
continue;
@@ -402,28 +402,26 @@
break;
case CT_CCL:
- /* scan a (nonempty) character class (sets NOSKIP) */
- if (width == 0) width = (size_t)~0; /* `infinity' */
- /* take only those things in the class */
+ case CT_STRING:
+ // CT_CCL: scan a (nonempty) character class (sets NOSKIP).
+ // CT_STRING: like CCL, but zero-length string OK, & no NOSKIP.
+ if (width == 0) width = (size_t)~0; // 'infinity'.
if ((flags & SUPPRESS) && (flags & LONG)) {
n = 0;
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && in_ccl(wi, ccl)) n++;
+ while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && ((c == CT_CCL && in_ccl(wi, ccl)) || (c == CT_STRING && !iswspace(wi)))) n++;
if (wi != WEOF) __ungetwc(wi, fp);
- if (n == 0) goto match_failure;
} else if (flags & LONG) {
p0 = p = va_arg(ap, wchar_t*);
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && in_ccl(wi, ccl))
+ while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && ((c == CT_CCL && in_ccl(wi, ccl)) || (c == CT_STRING && !iswspace(wi)))) {
*p++ = (wchar_t)wi;
+ }
if (wi != WEOF) __ungetwc(wi, fp);
n = p - p0;
- if (n == 0) goto match_failure;
- *p = 0;
- nassigned++;
} else {
if (!(flags & SUPPRESS)) mbp = va_arg(ap, char*);
n = 0;
memset(&mbs, 0, sizeof(mbs));
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width != 0 && in_ccl(wi, ccl)) {
+ while ((wi = __fgetwc_unlock(fp)) != WEOF && width != 0 && ((c == CT_CCL && in_ccl(wi, ccl)) || (c == CT_STRING && !iswspace(wi)))) {
if (width >= MB_CUR_MAX && !(flags & SUPPRESS)) {
nconv = wcrtomb(mbp, wi, &mbs);
if (nconv == (size_t)-1) goto input_failure;
@@ -438,57 +436,20 @@
n++;
}
if (wi != WEOF) __ungetwc(wi, fp);
- if (n == 0) goto match_failure;
- if (!(flags & SUPPRESS)) {
- *mbp = 0;
- nassigned++;
+ }
+ if (c == CT_CCL && n == 0) goto match_failure;
+ if (!(flags & SUPPRESS)) {
+ if (flags & LONG) {
+ *p = L'\0';
+ } else {
+ *mbp = '\0';
}
+ ++nassigned;
}
nread += n;
nconversions++;
break;
- case CT_STRING:
- /* like CCL, but zero-length string OK, & no NOSKIP */
- if (width == 0) width = (size_t)~0;
- if ((flags & SUPPRESS) && (flags & LONG)) {
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && !iswspace(wi)) nread++;
- if (wi != WEOF) __ungetwc(wi, fp);
- } else if (flags & LONG) {
- p0 = p = va_arg(ap, wchar_t*);
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width-- != 0 && !iswspace(wi)) {
- *p++ = (wchar_t)wi;
- nread++;
- }
- if (wi != WEOF) __ungetwc(wi, fp);
- *p = 0;
- nassigned++;
- } else {
- if (!(flags & SUPPRESS)) mbp = va_arg(ap, char*);
- memset(&mbs, 0, sizeof(mbs));
- while ((wi = __fgetwc_unlock(fp)) != WEOF && width != 0 && !iswspace(wi)) {
- if (width >= MB_CUR_MAX && !(flags & SUPPRESS)) {
- nconv = wcrtomb(mbp, wi, &mbs);
- if (nconv == (size_t)-1) goto input_failure;
- } else {
- nconv = wcrtomb(mbbuf, wi, &mbs);
- if (nconv == (size_t)-1) goto input_failure;
- if (nconv > width) break;
- if (!(flags & SUPPRESS)) memcpy(mbp, mbbuf, nconv);
- }
- if (!(flags & SUPPRESS)) mbp += nconv;
- width -= nconv;
- nread++;
- }
- if (wi != WEOF) __ungetwc(wi, fp);
- if (!(flags & SUPPRESS)) {
- *mbp = 0;
- nassigned++;
- }
- }
- nconversions++;
- continue;
-
case CT_INT:
/* scan an integer as if by strtoimax/strtoumax */
if (width == 0 || width > sizeof(buf) / sizeof(*buf) - 1)
diff --git a/libc/system_properties/context_node.h b/libc/system_properties/context_node.h
index 1c6cbbb..769b853 100644
--- a/libc/system_properties/context_node.h
+++ b/libc/system_properties/context_node.h
@@ -41,9 +41,16 @@
~ContextNode() {
Unmap();
}
+
+ ContextNode(const ContextNode&) = delete;
+ ContextNode(ContextNode&&) = delete;
+ void operator=(const ContextNode&) = delete;
+ void operator=(const ContextNode&&) = delete;
+
bool Open(bool access_rw, bool* fsetxattr_failed);
bool CheckAccessAndOpen();
void ResetAccess();
+ void Unmap();
const char* context() const {
return context_;
@@ -54,7 +61,6 @@
private:
bool CheckAccess();
- void Unmap();
Lock lock_;
const char* context_;
diff --git a/libc/system_properties/contexts_serialized.cpp b/libc/system_properties/contexts_serialized.cpp
new file mode 100644
index 0000000..117b5cf
--- /dev/null
+++ b/libc/system_properties/contexts_serialized.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#include "contexts_serialized.h"
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <new>
+
+#include <async_safe/log.h>
+
+#include "private/bionic_prctl.h"
+#include "property_filename.h"
+
+bool ContextsSerialized::InitializeContextNodes() {
+ auto num_context_nodes = property_info_area_file_->num_contexts();
+ auto context_nodes_mmap_size = sizeof(ContextNode) * num_context_nodes;
+ // We want to avoid malloc in system properties, so we take an anonymous map instead (b/31659220).
+ void* const map_result = mmap(nullptr, context_nodes_mmap_size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (map_result == MAP_FAILED) {
+ return false;
+ }
+
+ prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, map_result, context_nodes_mmap_size,
+ "System property context nodes");
+
+ context_nodes_ = reinterpret_cast<ContextNode*>(map_result);
+ num_context_nodes_ = num_context_nodes;
+ context_nodes_mmap_size_ = context_nodes_mmap_size;
+
+ for (size_t i = 0; i < num_context_nodes; ++i) {
+ new (&context_nodes_[i]) ContextNode(property_info_area_file_->context(i));
+ }
+
+ return true;
+}
+
+bool ContextsSerialized::MapSerialPropertyArea(bool access_rw, bool* fsetxattr_failed) {
+ char filename[PROP_FILENAME_MAX];
+ int len = async_safe_format_buffer(filename, sizeof(filename), "%s/properties_serial",
+ property_filename);
+ if (len < 0 || len > PROP_FILENAME_MAX) {
+ serial_prop_area_ = nullptr;
+ return false;
+ }
+
+ if (access_rw) {
+ serial_prop_area_ =
+ prop_area::map_prop_area_rw(filename, "u:object_r:properties_serial:s0", fsetxattr_failed);
+ } else {
+ serial_prop_area_ = prop_area::map_prop_area(filename);
+ }
+ return serial_prop_area_;
+}
+
+bool ContextsSerialized::InitializeProperties() {
+ if (!property_info_area_file_.LoadDefaultPath()) {
+ return false;
+ }
+
+ if (!InitializeContextNodes()) {
+ FreeAndUnmap();
+ return false;
+ }
+
+ return true;
+}
+
+bool ContextsSerialized::Initialize(bool writable) {
+ if (!InitializeProperties()) {
+ return false;
+ }
+
+ if (writable) {
+ mkdir(property_filename, S_IRWXU | S_IXGRP | S_IXOTH);
+ bool open_failed = false;
+ bool fsetxattr_failed = false;
+
+ for (size_t i = 0; i < num_context_nodes_; ++i) {
+ if (!context_nodes_[i].Open(true, &fsetxattr_failed)) {
+ open_failed = true;
+ }
+ }
+ if (open_failed || !MapSerialPropertyArea(true, &fsetxattr_failed)) {
+ FreeAndUnmap();
+ return false;
+ }
+
+ return !fsetxattr_failed;
+ } else {
+ if (!MapSerialPropertyArea(false, nullptr)) {
+ FreeAndUnmap();
+ return false;
+ }
+ }
+ return true;
+}
+
+prop_area* ContextsSerialized::GetPropAreaForName(const char* name) {
+ uint32_t index;
+ property_info_area_file_->GetPropertyInfoIndexes(name, &index, nullptr);
+ if (index == ~0u || index >= num_context_nodes_) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "libc", "Could not find context for property \"%s\"",
+ name);
+ return nullptr;
+ }
+ auto* context_node = &context_nodes_[index];
+ if (!context_node->pa()) {
+ // We explicitly do not check no_access_ in this case because unlike the
+ // case of foreach(), we want to generate an selinux audit for each
+ // non-permitted property access in this function.
+ context_node->Open(false, nullptr);
+ }
+ return context_node->pa();
+}
+
+void ContextsSerialized::ForEach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) {
+ for (size_t i = 0; i < num_context_nodes_; ++i) {
+ if (context_nodes_[i].CheckAccessAndOpen()) {
+ context_nodes_[i].pa()->foreach (propfn, cookie);
+ }
+ }
+}
+
+void ContextsSerialized::ResetAccess() {
+ for (size_t i = 0; i < num_context_nodes_; ++i) {
+ context_nodes_[i].ResetAccess();
+ }
+}
+
+void ContextsSerialized::FreeAndUnmap() {
+ property_info_area_file_.Reset();
+ if (context_nodes_ != nullptr) {
+ for (size_t i = 0; i < num_context_nodes_; ++i) {
+ context_nodes_[i].Unmap();
+ }
+ munmap(context_nodes_, context_nodes_mmap_size_);
+ context_nodes_ = nullptr;
+ }
+ prop_area::unmap_prop_area(&serial_prop_area_);
+ serial_prop_area_ = nullptr;
+}
diff --git a/libc/system_properties/contexts_serialized.h b/libc/system_properties/contexts_serialized.h
new file mode 100644
index 0000000..52474c3
--- /dev/null
+++ b/libc/system_properties/contexts_serialized.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ */
+
+#ifndef SYSTEM_PROPERTIES_CONTEXTS_SERIALIZED_H
+#define SYSTEM_PROPERTIES_CONTEXTS_SERIALIZED_H
+
+#include <property_info_parser/property_info_parser.h>
+
+#include "context_node.h"
+#include "contexts.h"
+
+class ContextsSerialized : public Contexts {
+ public:
+ virtual ~ContextsSerialized() override {
+ }
+
+ virtual bool Initialize(bool writable) override;
+ virtual prop_area* GetPropAreaForName(const char* name) override;
+ virtual prop_area* GetSerialPropArea() override {
+ return serial_prop_area_;
+ }
+ virtual void ForEach(void (*propfn)(const prop_info* pi, void* cookie), void* cookie) override;
+ virtual void ResetAccess() override;
+ virtual void FreeAndUnmap() override;
+
+ private:
+ bool InitializeContextNodes();
+ bool InitializeProperties();
+ bool MapSerialPropertyArea(bool access_rw, bool* fsetxattr_failed);
+
+ android::properties::PropertyInfoAreaFile property_info_area_file_;
+ ContextNode* context_nodes_ = nullptr;
+ size_t num_context_nodes_ = 0;
+ size_t context_nodes_mmap_size_ = 0;
+ prop_area* serial_prop_area_ = nullptr;
+};
+
+#endif
diff --git a/libc/system_properties/system_properties.cpp b/libc/system_properties/system_properties.cpp
index 89a6fe7..f67fc4d 100644
--- a/libc/system_properties/system_properties.cpp
+++ b/libc/system_properties/system_properties.cpp
@@ -59,6 +59,7 @@
#include "context_node.h"
#include "contexts.h"
#include "contexts_pre_split.h"
+#include "contexts_serialized.h"
#include "contexts_split.h"
#include "prop_area.h"
#include "prop_info.h"
@@ -71,6 +72,7 @@
static union ContextsUnion {
ContextsUnion() {}
~ContextsUnion() {}
+ ContextsSerialized contexts_serialized;
ContextsSplit contexts_split;
ContextsPreSplit contexts_pre_split;
} contexts_union;
@@ -283,11 +285,19 @@
}
contexts = nullptr;
if (is_dir(property_filename)) {
- new (&contexts_union.contexts_split) ContextsSplit();
- if (!contexts_union.contexts_split.Initialize(false)) {
- return -1;
+ if (access("/dev/__properties__/property_info", R_OK) == 0) {
+ new (&contexts_union.contexts_serialized) ContextsSerialized();
+ if (!contexts_union.contexts_serialized.Initialize(false)) {
+ return -1;
+ }
+ contexts = &contexts_union.contexts_serialized;
+ } else {
+ new (&contexts_union.contexts_split) ContextsSplit();
+ if (!contexts_union.contexts_split.Initialize(false)) {
+ return -1;
+ }
+ contexts = &contexts_union.contexts_split;
}
- contexts = &contexts_union.contexts_split;
} else {
new (&contexts_union.contexts_pre_split) ContextsPreSplit();
if (!contexts_union.contexts_pre_split.Initialize(false)) {
@@ -314,9 +324,9 @@
}
// We set this unconditionally as we want tests to continue on regardless of if this failed
// and property_service will abort on an error condition, so no harm done.
- new (&contexts_union.contexts_split) ContextsSplit;
- contexts = &contexts_union.contexts_split;
- if (!contexts_union.contexts_split.Initialize(true)) {
+ new (&contexts_union.contexts_serialized) ContextsSerialized;
+ contexts = &contexts_union.contexts_serialized;
+ if (!contexts_union.contexts_serialized.Initialize(true)) {
return -1;
}
return 0;
diff --git a/tests/stdio_test.cpp b/tests/stdio_test.cpp
index f0e0ab6..e060cd9 100644
--- a/tests/stdio_test.cpp
+++ b/tests/stdio_test.cpp
@@ -1016,6 +1016,95 @@
CheckScanf(swscanf, L"+,-/.", L"%[+--/]", 1, "+,-/");
}
+// https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=202240
+TEST(STDIO_TEST, scanf_wscanf_EOF) {
+ EXPECT_EQ(0, sscanf("b", "ab"));
+ EXPECT_EQ(EOF, sscanf("", "a"));
+ EXPECT_EQ(0, swscanf(L"b", L"ab"));
+ EXPECT_EQ(EOF, swscanf(L"", L"a"));
+}
+
+TEST(STDIO_TEST, scanf_invalid_UTF8) {
+#if 0 // TODO: more tests invented during code review; no regressions, so fix later.
+ char buf[BUFSIZ];
+ wchar_t wbuf[BUFSIZ];
+
+ memset(buf, 0, sizeof(buf));
+ memset(wbuf, 0, sizeof(wbuf));
+ EXPECT_EQ(0, sscanf("\xc0" " foo", "%ls %s", wbuf, buf));
+#endif
+}
+
+TEST(STDIO_TEST, scanf_no_match_no_termination) {
+ char buf[4] = "x";
+ EXPECT_EQ(0, sscanf("d", "%[abc]", buf));
+ EXPECT_EQ('x', buf[0]);
+ EXPECT_EQ(0, swscanf(L"d", L"%[abc]", buf));
+ EXPECT_EQ('x', buf[0]);
+
+ wchar_t wbuf[4] = L"x";
+ EXPECT_EQ(0, swscanf(L"d", L"%l[abc]", wbuf));
+ EXPECT_EQ(L'x', wbuf[0]);
+
+ EXPECT_EQ(EOF, sscanf("", "%s", buf));
+ EXPECT_EQ('x', buf[0]);
+
+ EXPECT_EQ(EOF, swscanf(L"", L"%ls", wbuf));
+ EXPECT_EQ(L'x', wbuf[0]);
+}
+
+TEST(STDIO_TEST, scanf_wscanf_wide_character_class) {
+#if 0 // TODO: more tests invented during code review; no regressions, so fix later.
+ wchar_t buf[BUFSIZ];
+
+ // A wide character shouldn't match an ASCII-only class for scanf or wscanf.
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, sscanf("xĀyz", "%l[xy]", buf));
+ EXPECT_EQ(L"x"s, std::wstring(buf));
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, swscanf(L"xĀyz", L"%l[xy]", buf));
+ EXPECT_EQ(L"x"s, std::wstring(buf));
+
+ // Even if scanf has wide characters in a class, they won't match...
+ // TODO: is that a bug?
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, sscanf("xĀyz", "%l[xĀy]", buf));
+ EXPECT_EQ(L"x"s, std::wstring(buf));
+ // ...unless you use wscanf.
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, swscanf(L"xĀyz", L"%l[xĀy]", buf));
+ EXPECT_EQ(L"xĀy"s, std::wstring(buf));
+
+ // Negation only covers ASCII for scanf...
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, sscanf("xĀyz", "%l[^ab]", buf));
+ EXPECT_EQ(L"x"s, std::wstring(buf));
+ // ...but covers wide characters for wscanf.
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, swscanf(L"xĀyz", L"%l[^ab]", buf));
+ EXPECT_EQ(L"xĀyz"s, std::wstring(buf));
+
+ // We already determined that non-ASCII characters are ignored in scanf classes.
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, sscanf("x"
+ "\xc4\x80" // Matches a byte from each wide char in the class.
+ "\xc6\x82" // Neither byte is in the class.
+ "yz",
+ "%l[xy" "\xc5\x80" "\xc4\x81" "]", buf));
+ EXPECT_EQ(L"x", std::wstring(buf));
+ // bionic and glibc both behave badly for wscanf, so let's call it right for now...
+ memset(buf, 0, sizeof(buf));
+ EXPECT_EQ(1, swscanf(L"x"
+ L"\xc4\x80"
+ L"\xc6\x82"
+ L"yz",
+ L"%l[xy" L"\xc5\x80" L"\xc4\x81" L"]", buf));
+ // Note that this isn't L"xĀ" --- although the *bytes* matched, they're
+ // not put back together as a wide character.
+ EXPECT_EQ(L"x" L"\xc4" L"\x80", std::wstring(buf));
+#endif
+}
+
TEST(STDIO_TEST, cantwrite_EBADF) {
// If we open a file read-only...
FILE* fp = fopen("/proc/version", "r");