//
	// While this format is compatible with most tar readers,
	// the format has several limitations making it unsuitable for some usages.
	// Most notably, it cannot support sparse files, files larger than 8GiB,
	// filenames larger than 256 characters, and non-ASCII filenames.
	//
	// Reference:
	//	http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_06

            this.sids.decode(_src);
            this.retval = _src.dec_ndr_long();
        }
    }

    /** Security group attribute: Mandatory group that cannot be disabled */
    public static final int SE_GROUP_MANDATORY = 1;
    /** Security group attribute: Group is enabled by default */
    public static final int SE_GROUP_ENABLED_BY_DEFAULT = 2;

            sids.decode(_src);
            retval = _src.dec_ndr_long();
        }
    }

    /** Security group attribute: Mandatory group that cannot be disabled */
    public static final int SE_GROUP_MANDATORY = 1;
    /** Security group attribute: Group is enabled by default */
    public static final int SE_GROUP_ENABLED_BY_DEFAULT = 2;

	if isSvcAccForRequestor {
		if requestorIsDerivedCredential {
			if requestorParentUser == "" {
				writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx,
					errors.New("service accounts cannot be generated for temporary credentials without parent")), r.URL)
				return
			}
			targetUser = requestorParentUser
		}
		targetGroups = requestorGroups

		// Deny if the target user is not LDAP

                // Note: Most fields in SmbTreeImpl are final or managed differently

                // Clear session reference if mutable
                // Note: session field may be final, cannot be nulled
            }
        } catch (Exception e) {
            log.error("Failed to perform emergency tree cleanup", e);
        }
    }

    /**
     *

### `Query` as the default value or in `Annotated` { #query-as-the-default-value-or-in-annotated }

Keep in mind that when using `Query` inside of `Annotated` you cannot use the `default` parameter for `Query`.

Instead, use the actual default value of the function parameter. Otherwise, it would be inconsistent.

For example, this is not allowed:

```Python

		delete(sys.metadataMap, bucket)
		globalBucketMonitor.DeleteBucket(bucket)
	}
}

// Set - sets a new metadata in-memory.
// Only a shallow copy is saved and fields with references
// cannot be modified without causing a race condition,
// so they should be replaced atomically and not appended to, etc.
// Data is not persisted to disk.
func (sys *BucketMetadataSys) Set(bucket string, meta BucketMetadata) {

     */
    protected int getBatchLimit(final Configuration cfg, final byte cmd) {
        /*
         * the default limit is 0 batched messages before this
         * one, meaning this message cannot be batched.
         */
        return 0;
    }

    /*
     * We overload this method from ServerMessageBlock because
     * we want writeAndXWireFormat to write the parameterWords

     */
    public ChannelGroup createChannels(String sessionId, List<InetAddress> serverAddresses) throws CIFSException {
        if (sessionId == null || sessionId.isEmpty()) {
            throw new CIFSException("Session ID cannot be null or empty");
        }

        ChannelGroup channelGroup = new ChannelGroup(sessionId);
        sessionChannels.put(sessionId, channelGroup);

        try {

Whenever you pass exactly the same content (exactly the same password) you get exactly the same gibberish.

But you cannot convert from the gibberish back to the password.

### Why use password hashing { #why-use-password-hashing }

If your database is stolen, the thief won't have your users' plaintext passwords, only the hashes.