Merge branch 'hidden-ab'

Author: jengelh

Makefile.am

@@ -130,6 +130,7 @@ libgxp_exchange_nsp_la_SOURCES = exch/nsp/common_util.cpp exch/nsp/common_util.h
 libgxp_exchange_nsp_la_LDFLAGS = ${default_SYFLAGS}
 libgxp_exchange_nsp_la_LIBADD = -lpthread ${libcrypto_LIBS} ${fmt_LIBS} ${libHX_LIBS} ${iconv_LIBS} libgromox_common.la libgromox_mapi.la libgromox_rpc.la libgxs_mysql_adaptor.la libgromox_abtree.la
 EXTRA_libgxp_exchange_nsp_la_DEPENDENCIES = default.sym
+EXTRA_DIST += exch/nsp/repr.cpp
 libgxp_exchange_rfr_la_SOURCES = exch/rfr.cpp
 libgxp_exchange_rfr_la_LDFLAGS = ${default_SYFLAGS}
 libgxp_exchange_rfr_la_LIBADD = ${fmt_LIBS} ${libHX_LIBS} libgromox_common.la libgromox_rpc.la libgxs_mysql_adaptor.la

doc/glossary.rst

@@ -281,8 +281,12 @@ GLOBCNT / GCV
 	* otherwise, a ``uint64_t`` holds the GCV in host-endian
 
 Minimal Entry ID, MINID
-	A global counter for objects in an address book.
+	A unique identifier for objects in an address book.
 	Scope: one address book provider. Limit: 2^32 - 16.
+	The first 16 values are reserved for special values like
+	minid::BEGINNING_OF_TABLE, minid::UNRESOLVED, etc.
+	NSPI also implicitly reserves >= 0x80000000, e.g. PR_EMS_AB_MEMBER
+	makes for a special container, too.
 
 Change number / CN
 	Scope: one mailbox replica. Limit: 2^48. Every time a folder or message

exch/nsp/nsp_interface.cpp

@@ -37,6 +37,7 @@
 #include <gromox/util.hpp>
 #include "common_util.hpp"
 #include "nsp_interface.hpp"
+#include "repr.cpp"
 
 using namespace std::string_literals;
 using namespace gromox;
@@ -904,6 +905,9 @@ ec_error_t nsp_interface_seek_entries(NSPI_HANDLE handle, uint32_t reserved,
 {
 	*pprows = nullptr;
 	nsp_trace(__func__, 0, pstat);
+	if (g_nsp_trace >= 2 && ptarget != nullptr)
+		fprintf(stderr, "seek_entries target={%xh,%s}\n",
+			ptarget->proptag, ptarget->repr().c_str());
 	if (handle.handle_type != HANDLE_EXCHANGE_NSP)
 		return ecError;
 	if (pstat == nullptr || pstat->codepage == CP_WINUNICODE ||
@@ -1172,6 +1176,22 @@ static std::unordered_set<std::string> delegates_for(const char *dir) try
 	return {};
 }
 
+/**
+ * Used to search the address book based on certain criteria (like a display
+ * name prefix), and returns a list of matching entries.
+ *
+ * (Also see resolve_namesw for differences.)
+ *
+ * Outlook uses get_matches(container=PR_EMS_AB_MEMBER, cur_rec=<minid of an
+ * mlist>, filter=nullptr) to obtain the members of an address list.
+ *
+ * Outlook uses get_matches(container=0 <gal>, cur_rec=0, filter={PR_ANR,
+ * "needle"}) as an alternative to resolve_names().
+ *
+ * Also note that get_matches(container=0, filter=RES_EXIST{PR_ENTRYID}) yields
+ * the same as iterating the GAL with query_rows(container=0). We need to be
+ * wary of HIDE flag testing.
+ */
 ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
     STAT *pstat, const MID_ARRAY *ptable, uint32_t reserved2,
     const NSPRES *pfilter, const NSP_PROPNAME *ppropname,
@@ -1181,6 +1201,8 @@ ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
 	*ppoutmids = nullptr;
 	*pprows = nullptr;
 	nsp_trace(__func__, 0, pstat);
+	if (g_nsp_trace >= 2 && pfilter != nullptr)
+		mlog(LV_DEBUG, "get_matches filter: %s", pfilter->repr().c_str());
 	if (handle.handle_type != HANDLE_EXCHANGE_NSP)
 		return ecError;
 	PROPERTY_VALUE prop_val;
@@ -1236,7 +1258,6 @@ ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
 				return ecServerOOM;
 			*pproptag = node.mid;
 		}
-		goto FETCH_ROWS;
 	} else if (pstat->container_id == PR_EMS_AB_PUBLIC_DELEGATES) {
 		ab_tree::ab_node node(base, pstat->cur_rec);
 		if (!node.exists())
@@ -1264,9 +1285,8 @@ ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
 				return ecServerOOM;
 			*pproptag = node.mid;
 		}
-		goto FETCH_ROWS;
-	}
-	if (pfilter == nullptr) {
+	} else if (pfilter == nullptr) {
+		/* OXNSPI v14 §3.1.4.1.10 pg. 56 item 8 */
 		char temp_buff[1024];
 		ab_tree::ab_node node = {base, pstat->cur_rec};
 		if (node.exists() && nsp_interface_fetch_property(node,
@@ -1278,15 +1298,19 @@ ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
 			*pproptag = node.mid;
 		}
 	} else if (pstat->container_id == 0) {
+		/* Alternative attempt by OL to do resolvenames */
 		uint32_t start_pos, total;
 		nsp_interface_position_in_list(pstat, base.get(), &start_pos, &total);
-		for (auto it = base->ubegin() + start_pos; it != base->uend() && it-base->ubegin() < total; ++it)
-			if (nsp_interface_match_node({base, *it}, pstat->codepage, pfilter)) {
-				auto pproptag = common_util_proptagarray_enlarge(outmids);
-				if (pproptag == nullptr)
-					return ecServerOOM;
-				*pproptag = *it;
-			}
+		for (auto it = base->ubegin() + start_pos; it != base->uend() && it-base->ubegin() < total; ++it) {
+			ab_tree::ab_node node(base, *it);
+			if (node.hidden() & (AB_HIDE_RESOLVE | AB_HIDE_FROM_GAL) ||
+			    !nsp_interface_match_node(node, pstat->codepage, pfilter))
+				continue;
+			auto pproptag = common_util_proptagarray_enlarge(outmids);
+			if (pproptag == nullptr)
+				return ecServerOOM;
+			*pproptag = *it;
+		}
 	} else {
 		ab_tree::ab_node node(base, pstat->container_id);
 		if (!node.exists())
@@ -1301,18 +1325,19 @@ ec_error_t nsp_interface_get_matches(NSPI_HANDLE handle, uint32_t reserved1,
 			nsp_trace(__func__, 1, pstat, nullptr, rowset);
 			return ecSuccess;
 		}
-		for (auto it = node.begin() + start_pos; it != node.end(); ++it)
-			if (!(node.hidden() & AB_HIDE_FROM_AL) && nsp_interface_match_node({base, *it}, pstat->codepage, pfilter)) {
-				auto pproptag = common_util_proptagarray_enlarge(outmids);
-				if (pproptag == nullptr)
-					return ecServerOOM;
-				*pproptag = *it;
-				if (outmids->cvalues >= requested)
-					break;
-			}
+		for (auto it = node.begin() + start_pos; it != node.end(); ++it) {
+			if (node.hidden() & (AB_HIDE_RESOLVE | AB_HIDE_FROM_AL) ||
+			    !nsp_interface_match_node({base, *it}, pstat->codepage, pfilter))
+				continue;
+			auto pproptag = common_util_proptagarray_enlarge(outmids);
+			if (pproptag == nullptr)
+				return ecServerOOM;
+			*pproptag = *it;
+			if (outmids->cvalues >= requested)
+				break;
+		}
 	}
 
- FETCH_ROWS:
 	if (rowset != nullptr) {
 		for (size_t i = 0; i < outmids->cvalues; ++i) {
 			auto prow = common_util_proprowset_enlarge(rowset);
@@ -2090,6 +2115,15 @@ static ab_tree::minid nsp_interface_resolve_gal(const ab_tree::ab::const_base_re
 	return res;
 }
 
+/**
+ * Used to resolve a list of names into unique address book entries (or fail if
+ * ambiguous).
+ *
+ * (Also see get_matches for differences.)
+ *
+ * If Outlook does not get a resolution using this call, it will retry with
+ * get_matches()!
+ */
 ec_error_t nsp_interface_resolve_namesw(NSPI_HANDLE handle, uint32_t reserved,
     const STAT *pstat, LPROPTAG_ARRAY *&pproptags,
     const STRINGS_ARRAY *pstrs, MID_ARRAY **ppmids, NSP_ROWSET **pprows)

exch/nsp/nsp_types.hpp

@@ -71,6 +71,7 @@ struct PROPERTY_VALUE {
 	gromox::proptag_t proptag;
 	uint32_t reserved;
 	PROP_VAL_UNION value; /* type is PROP_TYPE(proptag) */
+	std::string repr() const;
 };
 
 struct NSP_PROPROW {
@@ -107,50 +108,59 @@ struct NSPRES;
 struct NSPRES_AND_OR {
 	uint32_t cres;
 	NSPRES *pres;
+	std::string repr(const char *sep = ",") const;
 };
 
 struct NSPRES_NOT {
 	NSPRES *pres;
+	std::string repr() const;
 };
 
 struct NSPRES_CONTENT {
 	uint32_t fuzzy_level;
 	gromox::proptag_t proptag;
 	PROPERTY_VALUE *pprop;
+	std::string repr() const;
 };
 
 struct NSPRES_PROPERTY {
 	enum relop relop;
 	gromox::proptag_t proptag;
 	PROPERTY_VALUE *pprop;
+	std::string repr() const;
 };
 
 struct NSPRES_PROPCOMPARE {
 	enum relop relop;
 	gromox::proptag_t proptag1, proptag2;
+	std::string repr() const;
 };
 
 struct NSPRES_BITMASK {
 	enum bm_relop rel_mbr;
 	gromox::proptag_t proptag;
 	uint32_t mask;
+	std::string repr() const;
 };
 
 struct NSPRES_SIZE {
 	enum relop relop;
 	gromox::proptag_t proptag;
 	uint32_t cb;
+	std::string repr() const;
 };
 
 struct NSPRES_EXIST {
 	uint32_t reserved1;
 	gromox::proptag_t proptag;
 	uint32_t reserved2;
+	std::string repr() const;
 };
 
 struct NSPRES_SUB {
 	uint32_t subobject;
 	NSPRES *pres;
+	std::string repr() const;
 };
 
 union NSPRES_UNION {
@@ -168,6 +178,7 @@ union NSPRES_UNION {
 struct NSPRES {
 	mapi_rtype res_type;
 	NSPRES_UNION res;
+	std::string repr() const;
 };
 
 struct EPHEMERAL_ENTRYID {

exch/nsp/repr.cpp

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2022–2025 grommunio GmbH
+// This file is part of Gromox.
+#include <string>
+#include <fmt/core.h>
+
+std::string PROPERTY_VALUE::repr() const
+{
+#define E(p) TAGGED_PROPVAL{proptag, deconst(p)}.repr()
+	switch (PROP_TYPE(proptag)) {
+	case PT_SHORT:      return E(&value.s);
+	case PT_LONG:       return E(&value.l);
+	case PT_I8:         return E(&value.ll);
+	case PT_FLOAT:      return E(&value.flt);
+	case PT_DOUBLE:     return E(&value.dbl);
+	case PT_BOOLEAN:    return E(&value.b);
+	case PT_BINARY:     return E(value.pv);
+	case PT_STRING8:    [[fallthrough]];
+	case PT_UNICODE:    return E(value.pstr);
+	case PT_CLSID:      return E(value.pguid);
+	case PT_SYSTIME:    return E(&value.ftime);
+	case PT_ERROR:      return E(&value.err);
+	case PT_MV_SHORT:   return E(&value.short_array);
+	case PT_MV_LONG:    return E(&value.long_array);
+	case PT_MV_STRING8: [[fallthrough]];
+	case PT_MV_UNICODE: return E(&value.string_array);
+	case PT_MV_BINARY:  return E(&value.bin_array);
+	case PT_MV_CLSID:   return E(&value.guid_array);
+	case PT_MV_SYSTIME: return E(&value.ftime_array);
+	default:            return "??";
+	}
+}
+
+std::string NSPRES_AND_OR::repr(const char *sep) const
+{
+	std::string s;
+	for (size_t i = 0; i < cres; ++i)
+		if (i ==  0)
+			s = pres[i].repr();
+		else
+			s += sep + pres[i].repr();
+	return "RES_AOR[" + std::to_string(cres) + "]{" + std::move(s) + "}";
+}
+
+std::string NSPRES_NOT::repr() const
+{
+	return "RES_NOT{" + pres->repr() + "}";
+}
+
+std::string NSPRES_CONTENT::repr() const
+{
+	std::string ss = "RES_CONTENT{";
+	switch (fuzzy_level & 0xffff) {
+	case FL_FULLSTRING: ss += "FL_FULLSTRING,"; break;
+	case FL_SUBSTRING: ss += "FL_SUBSTRING,"; break;
+	case FL_PREFIX: ss += "FL_PREFIX,"; break;
+	default: ss += "part??,"; break;
+	}
+	if (fuzzy_level & FL_PREFIX_ON_ANY_WORD)
+		ss += "FL_PREFIX_ON_ANY_WORD,";
+	if (fuzzy_level & FL_PHRASE_MATCH)
+		ss += "FL_PHRASE_MATCH,";
+	if (fuzzy_level & FL_IGNORECASE)
+		ss += "FL_IGNORECASE,";
+	if (fuzzy_level & FL_IGNORENONSPACE)
+		ss += "FL_IGNORE_NON_SPACE,";
+	if (fuzzy_level & FL_LOOSE)
+		ss += "FL_LOOSE,";
+	ss += fmt::format("{:x}h,{}", proptag, pprop->repr());
+	return ss;
+}
+
+std::string NSPRES_PROPERTY::repr() const
+{
+	return fmt::format("RES_PROP{{val({:x}h) {} {}}}",
+	       proptag, gromox::relop_repr(relop), pprop->repr());
+}
+
+std::string NSPRES_PROPCOMPARE::repr() const
+{
+	return fmt::format("RES_PROPCMP{{val({:x}h) {} val({})}}",
+	       proptag1, gromox::relop_repr(relop), proptag2);
+}
+
+std::string NSPRES_BITMASK::repr() const
+{
+	std::string ss = fmt::format("RES_BITMASK{{val({:x}h & {:x}", proptag, mask);
+	switch (rel_mbr) {
+	case BMR_EQZ: ss += "h == 0}"; break;
+	case BMR_NEZ: ss += "h != 0}"; break;
+	default: ss += "h ..op?}"; break;
+	}
+	return ss;
+}
+
+std::string NSPRES_SIZE::repr() const
+{
+	return fmt::format("RES_SIZE{{{},{:x}h,{}}}",
+	       gromox::relop_repr(relop), proptag, cb);
+}
+
+std::string NSPRES_EXIST::repr() const
+{
+	return fmt::format("RES_EXIST{{{:x}h}}", proptag);
+}
+
+std::string NSPRES_SUB::repr() const
+{
+	return fmt::format("RES_SUBOBJ{{{:x}h,{}}}", subobject, pres->repr());
+}
+
+std::string NSPRES::repr() const
+{
+	switch (res_type) {
+	case RES_AND:            return "RES_AND" + res.res_andor.repr(" && ");
+	case RES_OR:             return "RES_OR" + res.res_andor.repr(" || ");
+	case RES_NOT:            return res.res_not.repr();
+	case RES_CONTENT:        return res.res_content.repr();
+	case RES_PROPERTY:       return res.res_property.repr();
+	case RES_PROPCOMPARE:    return res.res_propcompare.repr();
+	case RES_BITMASK:        return res.res_bitmask.repr();
+	case RES_SIZE:           return res.res_size.repr();
+	case RES_EXIST:          return res.res_exist.repr();
+	case RES_SUBRESTRICTION: return res.res_sub.repr();
+	case RES_COMMENT:        return "RES_COMMENT{..}";
+	case RES_COUNT:          return "RES_COUNT{..}";
+	case RES_ANNOTATION:     return "RES_ANNOTATION{..}";
+	case RES_NULL:           return "RES_NULL{}";
+	default:                 return "RES_??{}";
+	}
+}
+

exch/zcore/ab_tree.cpp

@@ -546,7 +546,8 @@ BOOL ab_tree_match_minids(const ab_tree::ab_base *pbase, uint32_t container_id,
 	if (container_id == ab_tree::minid::SC_GAL) {
 		for (auto it = pbase->ubegin(); it != pbase->uend(); ++it) {
 			ab_tree::ab_node node(it);
-			if (node.hidden() & AB_HIDE_FROM_GAL || !ab_tree_match_node(node, pfilter))
+			if (node.hidden() & AB_HIDE_FROM_GAL ||
+			    !ab_tree_match_node(node, pfilter))
 				continue;
 			tlist.push_back(*it);
 		}
@@ -559,7 +560,7 @@ BOOL ab_tree_match_minids(const ab_tree::ab_base *pbase, uint32_t container_id,
 		}
 		for (ab_tree::minid mid : node) {
 			ab_tree::ab_node child(pbase, mid);
-			if(child.type() >= ab_tree::abnode_type::containers ||
+			if (child.type() >= ab_tree::abnode_type::containers ||
 			    child.hidden() & AB_HIDE_FROM_AL ||
 			    !ab_tree_match_node(child, pfilter))
 				continue;