*
* We don't support the format used by the Win32 API function
* AddResourceAttributeAce(), which is called CLAIM_SECURITY_ATTRIBUTE_V1.
- * Nobody has ever used that function in public, and it the format is not used
+ * Nobody has ever used that function in public, and the format is not used
* on the wire.
*/
* Conditional ACE logic truth tables.
*
* Conditional ACES use a ternary logic, with "unknown" as well as true and
- * false. The ultmate meaning of unknown depends on the context; in a deny
+ * false. The ultimate meaning of unknown depends on the context; in a deny
* ace, unknown means yes, in an allow ace, unknown means no. That is, we
* treat unknown results with maximum suspicion.
*
* If there is no matching resource ACE, a NULL result is returned,
* which should compare UNKNOWN to anything. The NULL will have the
* CONDITIONAL_ACE_FLAG_NULL_MEANS_ERROR flag set if it seems failure
- * is not simply due to the sought claim not existing. This useful for
+ * is not simply due to the sought claim not existing. This is useful for
* the Exists and Not_Exists operators.
*/
size_t i;
* that. This means we can't short-cut by comparing the
* lengths.
*
- * THe extra sad thing is we might have to do it both ways
+ * The extra sad thing is we might have to do it both ways
* round. For example, comparing {a, a, b, a} to {a, b, c}, we
* find all of the first group in the second, but that doesn't
* mean all of the second are in the first.
* other error in running it. The *result parameter is set to
* ACE_CONDITION_FALSE, ACE_CONDITION_TRUE, or ACE_CONDITION_UNKNOWN.
*
- * ACE_CONDITION_UNKNOWN should be treated pessimistically, as if were
+ * ACE_CONDITION_UNKNOWN should be treated pessimistically, as if it were
* TRUE for deny ACEs, and FALSE for allow ACEs.
*
* @param[in] ace - the ACE being processed.
* [MS-DTYP]. MS-DTYP uses 'LHS' to describe the
* operand of unary operators even though they are
* always displayed on the right of the operator. It
- * which makes everything much simpler to use rhs
+ * makes everything much simpler to use rhs
* instead.
*/
n_trees--;
if (expecting_bare_sids) {
/*
* This flag is set for a resource ACE which doesn't have the
- * SID() wrapper around the the SID string, and not for a
+ * SID() wrapper around the SID string, and not for a
* conditional ACE, which must have the "SID(...)".
*
* The resource ACE doesn't need this because there is no
* etc).
*
* We're sticking to the [IUSDXB] codes rather than using converting
- * earlier to tok->type (whereby this who thing becomes "if (tok->type
+ * earlier to tok->type (whereby this whole thing becomes "if (tok->type
* == type)") to enable bounds checks on the various integer types.
*/
switch(c) {
return sddl_write_unicode(ctx, tok);
case CONDITIONAL_ACE_TOKEN_SID:
- /* unlike conditional ACE, SID does not had "SID()" wrapper. */
+ /* unlike conditional ACE, SID does not have a "SID()" wrapper. */
sid = sddl_encode_sid(ctx->mem_ctx, &tok->data.sid.sid, NULL);
if (sid == NULL) {
return false;
Some of our fuzzers generate SDDL strings with trailing garbage.
This script converts them into the JSON format used by
-windws-sddl-tests.py, though it doesn't parse the SDDL, mapping all
+windows-sddl-tests.py, though it doesn't parse the SDDL, mapping all
strings to an empty list. The idea is you can feed this through
-windws-sddl-tests.py or something else to get the correct bytes.
+windows-sddl-tests.py or something else to get the correct bytes.
Valid and invalid strings are treated alike, so long as they are
utf-8. The JSON is un-indented, but structurally equivalent to this:
static void test_composite_mixed_types(void **state)
{
/*
- * If the conditional ACE composite hasa mixed types, it can
+ * If the conditional ACE composite has mixed types, it can
* never equal a claim, which only has one type.
*/
INIT()
}
-static void test_device_claim_comtains_resource_claim(void **state)
+static void test_device_claim_contains_resource_claim(void **state)
{
INIT();
USER_SIDS("WD", "AA");
cmocka_unit_test(test_resource_ace_multi),
cmocka_unit_test(test_resource_ace_multi_any_of),
cmocka_unit_test(test_user_claim_eq_device_claim),
- cmocka_unit_test(test_device_claim_comtains_resource_claim),
+ cmocka_unit_test(test_device_claim_contains_resource_claim),
cmocka_unit_test(test_device_claim_eq_resource_claim),
cmocka_unit_test(test_Device_claim_contains_Resource_claim),
cmocka_unit_test(test_not_Not_Contains_1),
0x00, 0x00,
/* ACE starts here, 352 */
0x09, 0x00, /* type 9, access allowed callback */
- 0x20, 0x00, /* swize 32 */
+ 0x20, 0x00, /* size 32 */
0x3f, 0x00, 0x00, 0x00, /*mask */
0x01, 0x01, /* S-1-... (1 subauth) */
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, /*...-16-...*/
# maybe 0xffff is an incorrect guess -- it gives use v2 (NT), not v4 (AD)
c = w.ConvertSecurityDescriptorToStringSecurityDescriptor(sd, 1, 0xffff)
except Exception as e:
- print(f"could sot serialize '{sd}': {e}")
+ print(f"could not serialize '{sd}': {e}")
print(f" derived from '{a}'")
exceptions[f"{e} serialize"].append(a)
unserializeable_cases.append(a)
for k, v in exceptions.items():
print(f"{k}: {len(v)}")
- print(f"{len(unparseable_cases)} failed to parsed")
+ print(f"{len(unparseable_cases)} failed to parse")
print(f"{len(parseable_cases)} successfully parsed")
print(f"{len(unserializeable_cases)} of these failed to re-serialize")
print(f"{len(round_trip_failures)} of these failed to round trip")
{ 1, 1, {0,0,0,0,0,5}, {11,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
#if 0
/* for documentation S-1-5-12 */
-const struct dom_sid global_sid_Restriced = /* Restricted Code */
+const struct dom_sid global_sid_Restricted = /* Restricted Code */
{ 1, 1, {0,0,0,0,0,5}, {12,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
#endif
projects / thirdparty / samba.git / commitdiff
