Changeset 989 for vendor/current/source3

vendor/current/source3/auth/auth_generic.c

-              r988
+              r989
 #ifdef HAVE_KRB5
 #include "auth/kerberos/pac_utils.h"
+#include "nsswitch/libwbclient/wbclient.h"
 #endif
 #include "librpc/crypto/gse.h"
 …
         if (pac_blob) {
 #ifdef HAVE_KRB5
+                struct wbcAuthUserParams params = {};
+                struct wbcAuthUserInfo *info = NULL;
+                struct wbcAuthErrorInfo *err = NULL;
+                wbcErr wbc_err;
+                /*
+                 * Let winbind decode the PAC.
+                 * This will also store the user
+                 * data in the netsamlogon cache.
+                 *
+                 * We need to do this *before* we
+                 * call get_user_from_kerberos_info()
+                 * as that does a user lookup that
+                 * expects info in the netsamlogon cache.
+                 *
+                 * See BUG: https://bugzilla.samba.org/show_bug.cgi?id=11259
+                 */
+                params.level = WBC_AUTH_USER_LEVEL_PAC;
+                params.password.pac.data = pac_blob->data;
+                params.password.pac.length = pac_blob->length;
+                become_root();
+                wbc_err = wbcAuthenticateUserEx(&params, &info, &err);
+                unbecome_root();
+                /*
+                 * As this is merely a cache prime
+                 * WBC_ERR_WINBIND_NOT_AVAILABLE
+                 * is not a fatal error, treat it
+                 * as success.
+                 */
+                switch (wbc_err) {
+                        case WBC_ERR_WINBIND_NOT_AVAILABLE:
+                        case WBC_ERR_SUCCESS:
+                                break;
+                        case WBC_ERR_AUTH_ERROR:
+                                status = NT_STATUS(err->nt_status);
+                                wbcFreeMemory(err);
+                                goto done;
+                        default:
+                                status = NT_STATUS_LOGON_FAILURE;
+                                goto done;
+                }
                 status = kerberos_pac_logon_info(tmp_ctx, *pac_blob, NULL, NULL,
                                                  NULL, NULL, 0, &logon_info);
 …
+        }
         /* save the PAC data if we have it */
+        /* Get the info3 from the PAC data if we have it */
         if (logon_info) {
                 status = create_info3_from_pac_logon_info(tmp_ctx,
 …
                         goto done;
+                }
-                netsamlogon_cache_store(ntuser, info3_copy);
+        }

vendor/current/source3/auth/token_util.c

-              r988
+              r989
         gid_t *gids;
         struct dom_sid *group_sids;
+        struct dom_sid tmp_sid;
         uint32_t num_group_sids;
         uint32_t num_gids;
 …
         } else  if (sid_check_is_in_unix_users(user_sid)) {
-                struct dom_sid tmp_sid;
                 uint32_t getgroups_num_group_sids;
                 /* This is a unix user not in passdb. We need to ask nss

vendor/current/source3/client/smbspool.c

r988	r989
251	251	*/
252	252
253		setup_logging("smbspool", DEBUG_STD~~OUT~~);
	253	setup_logging("smbspool", DEBUG_STDERR);
254	254
255	255	smb_init_locale();

vendor/current/source3/client/smbspool_krb5_wrapper.c

-              r988
+              r989
 #include <errno.h>
+#include <stdlib.h>
 #include <string.h>
 …
 #include "dynconfig/dynconfig.h"
+#undef calloc
 enum cups_smb_dbglvl_e {
 …
          * environment variables set.
          */
+#ifdef HAVE_CLEARENV
         clearenv();
+#else
+        {
+                extern char **environ;
+                environ = calloc(1, sizeof(*environ));
+        }
+#endif
         CUPS_SMB_DEBUG("Setting KRB5CCNAME to '%s'", gen_cc);

vendor/current/source3/include/includes.h

-              r988
+              r989
 #include <talloc.h>
 #include "event.h"
+#include <tevent.h>
+#include "util_event.h"
 #include "../lib/util/data_blob.h"

vendor/current/source3/include/proto.h

r988	r989
1021	1021	void lp_set_mangling_method(const char *new_method);
1022	1022	bool lp_posix_pathnames(void);
1023		~~void lp_set_posix_pathnames(void~~);
	1023	bool lp_set_posix_pathnames(bool newval);
1024	1024	enum brl_flavour lp_posix_cifsu_locktype(files_struct *fsp);
1025	1025	void lp_set_posix_default_cifsx_readwrite_locktype(enum brl_flavour val);

vendor/current/source3/include/smb_macros.h

-              r988
+              r989
                         ((req->flags2 & FLAGS2_READ_PERMIT_EXECUTE) && \
                          (fsp->access_mask & FILE_EXECUTE))))
+/* An IOCTL readability check (validating read access
+ * when the IOCTL code requires it)
+ * http://social.technet.microsoft.com/wiki/contents/articles/24653.decoding-io-control-codes-ioctl-fsctl-and-deviceiocodes-with-table-of-known-values.aspx
+ * ). On Windows servers, this is done by the IO manager, which is unaware of
+ * the "if execute is granted then also grant read" arrangement.
+ */
+#define CHECK_READ_IOCTL(fsp, req) (((fsp)->fh->fd != -1) && ((fsp)->can_read))
 #define CHECK_WRITE(fsp) ((fsp)->can_write && ((fsp)->fh->fd != -1))

vendor/current/source3/include/vfs.h

r988	r989
237	237	uint32_t access_mask; /* NTCreateX access bits (FILE_READ_DATA etc.) */
238	238	uint32_t share_access; /* NTCreateX share constants (FILE_SHARE_READ\|FILE_SHARE_WRITE\|FILE_SHARE_DELETE). */
	239
	240	bool kernel_share_modes_taken;
239	241
240	242	bool update_write_time_triggered;

vendor/current/source3/lib/dbwrap/dbwrap_ctdb.c

-              r988
+              r989
         bool ask_for_readonly_copy;
         bool done;
+        bool empty_record;
 };
 …
         if (db_ctdb_can_use_local_hdr(header, true)) {
+                state->parser(key, data, state->private_data);
+                /*
+                 * A record consisting only of the ctdb header can be
+                 * a validly created empty record or a tombstone
+                 * record of a deleted record (not vacuumed yet). Mark
+                 * it accordingly.
+                 */
+                state->empty_record = (data.dsize == 0);
+                if (!state->empty_record) {
+                        state->parser(key, data, state->private_data);
+                }
                 state->done = true;
         } else {
 …
         state.parser = parser;
         state.private_data = private_data;
+        state.empty_record = false;
         if (ctx->transaction != NULL) {
 …
                 ctx, key, db_ctdb_parse_record_parser_nonpersistent, &state);
         if (NT_STATUS_IS_OK(status) && state.done) {
+                if (state.empty_record) {
+                        /*
+                         * We know authoritatively, that this is an empty
+                         * record. Since ctdb does not distinguish between empty
+                         * and deleted records, this can be a record stored as
+                         * empty or a not-yet-vacuumed tombstone record of a
+                         * deleted record. Now Samba right now can live without
+                         * empty records, so we can safely report this record
+                         * as non-existing.
+                         *
+                         * See bugs 10008 and 12005.
+                         */
+                        return NT_STATUS_NOT_FOUND;
+                }
                 return NT_STATUS_OK;
+        }
 …
                           state.ask_for_readonly_copy, parser, private_data);
         if (ret != 0) {
+                if (ret == ENOENT) {
+                        /*
+                         * This maps to
+                         * NT_STATUS_OBJECT_NAME_NOT_FOUND. Our upper
+                         * layers expect NT_STATUS_NOT_FOUND for "no
+                         * record around". We need to convert dbwrap
+                         * to 0/errno away from NTSTATUS ... :-)
+                         */
+                        return NT_STATUS_NOT_FOUND;
+                }
                 return map_nt_error_from_unix(ret);
+        }

vendor/current/source3/lib/dumpcore.c

-              r988
+              r989
+        }
-#ifdef HAVE_GETRLIMIT
-#ifdef RLIMIT_CORE
+        {
-                struct rlimit rlp;
-                getrlimit(RLIMIT_CORE, &rlp);
-                rlp.rlim_cur = MAX(16*1024*1024,rlp.rlim_cur);
-                setrlimit(RLIMIT_CORE, &rlp);
-                getrlimit(RLIMIT_CORE, &rlp);
-                DEBUG(3,("Maximum core file size limits now %d(soft) %d(hard)\n",
-                         (int)rlp.rlim_cur,(int)rlp.rlim_max));
+        }
-#endif
-#endif
         /* FIXME: if we have a core-plus-pid facility, configurably set
          * this up here.

vendor/current/source3/lib/gencache.c

r988	r989
671	671	}
672	672
673		res = tdb_lockall(cache_notrans->tdb);
	673	res = tdb_lockall_nonblock(cache_notrans->tdb);
674	674	if (res != 0) {
675	675	tdb_transaction_cancel(cache->tdb);

vendor/current/source3/lib/msghdr.c

-              r988
+              r989
                 msgsize - offsetof(struct msghdr_buf, buf) : 0;
+        fd_len = msghdr_prep_fds(&msg->msg, msg->buf, bufsize, fds, num_fds);
+        if (msg != NULL) {
+                msg->msg = (struct msghdr) { 0 };
+                fd_len = msghdr_prep_fds(&msg->msg, msg->buf, bufsize,
+                                         fds, num_fds);
+        } else {
+                fd_len = msghdr_prep_fds(NULL, NULL, bufsize, fds, num_fds);
+        }
         if (fd_len == -1) {

vendor/current/source3/lib/poll_funcs/poll_funcs_tevent.c

-              r988
+              r989
                 TALLOC_FREE(state->watches[i]);
+        }
+        for (i=0; i<state->num_contexts; i++) {
+                TALLOC_FREE(state->contexts[i]);
+        }
         return 0;
+}
 …
         unsigned i;
+        /* Look for an existing match first. */
         for (i=0; i<state->num_contexts; i++) {
                 struct poll_funcs_tevent_context *ctx = state->contexts[i];
                 if ((ctx == NULL) || (ctx->ev == ev)) {
+                if (ctx != NULL && ctx->ev == ev) {
                         *slot = i;
                         return true;
+                }
+        }
+        /* Now look for a free slot. */
+        for (i=0; i<state->num_contexts; i++) {
+                struct poll_funcs_tevent_context *ctx = state->contexts[i];
+                if (ctx == NULL) {
+                        *slot = i;
+                        return true;
+                }
+        }
         contexts = talloc_realloc(state, state->contexts,

vendor/current/source3/lib/server_contexts.c

r988	r989
32	32	* children exiting.
33	33	*/
34		server_event_ctx = s3_tevent_context_init(NULL);
	34	server_event_ctx = samba_tevent_context_init(NULL);
35	35	}
36	36	if (!server_event_ctx) {

vendor/current/source3/lib/substitute.c

-              r988
+              r989
                 case 'G' : {
                         struct passwd *pass;
+                        bool is_domain_name = false;
+                        const char *sep = lp_winbind_separator();
                         if (domain_name != NULL && domain_name[0] != '\0' &&
                             !strequal(domain_name, my_sam_name()))
+                        {
+                            (lp_security() == SEC_ADS ||
+                             lp_security() == SEC_DOMAIN)) {
                                 r = talloc_asprintf(tmp_ctx,
                                                     "%s%c%s",
                                                     domain_name,
                                                     *lp_winbind_separator(),
+                                                    *sep,
                                                     smb_name);
+                                is_domain_name = true;
                         } else {
                                 r = talloc_strdup(tmp_ctx, smb_name);
 …
                         pass = Get_Pwnam_alloc(tmp_ctx, r);
                         if (pass != NULL) {
+                                a_string = realloc_string_sub(
+                                        a_string, "%G",
+                                        gidtoname(pass->pw_gid));
+                                char *group_name;
+                                group_name = gidtoname(pass->pw_gid);
+                                if (is_domain_name) {
+                                        p = strchr_m(group_name, *sep);
+                                        if (p != NULL) {
+                                                group_name = p + 1;
+                                        }
+                                }
+                                a_string = realloc_string_sub(a_string,
+                                                              "%G",
+                                                              group_name);
+                        }
                         TALLOC_FREE(pass);

vendor/current/source3/lib/sysquotas_4B.c

-              r988
+              r989
         dp->curblocks = XLATE_TO_BLOCKS(qblk->dqb_curbytes);
 #undef XLATE_TO_BLOCKS
+#else
+        dp->bsize = DEV_BSIZE;
+        dp->softlimit = qblk->dqb_bsoftlimit;
+        dp->hardlimit = qblk->dqb_bhardlimit;
+        dp->curblocks = qblk->dqb_curblocks;
 #endif

vendor/current/source3/libads/cldap.c

-              r988
+              r989
                                            state->servers[i],
                                            &state->cldap[i]);
+                if (tevent_req_nterror(req, status)) {
+                        return tevent_req_post(req, ev);
+                if (!NT_STATUS_IS_OK(status)) {
+                        /*
+                         * Don't error out all sends just
+                         * because one cldap_socket_init() failed.
+                         * Log it here, and the cldap_netlogon_send()
+                         * will catch it (with in.dest_address == NULL)
+                         * and correctly error out in
+                         * cldap_multi_netlogon_done(). This still allows
+                         * the other requests to be concurrently sent.
+                         */
+                        DBG_NOTICE("cldap_socket_init failed for %s "
+                                " error %s\n",
+                                tsocket_address_string(state->servers[i],
+                                        req),
+                                nt_errstr(status));
+                }

vendor/current/source3/libads/kerberos.c

-              r988
+              r989
+{
         if (num_prompts == 0) return 0;
+#if HAVE_KRB5_PROMPT_TYPE
+        /*
+         * only heimdal has a prompt type and we need to deal with it here to
+         * avoid loops.
+         *
+         * removing the prompter completely is not an option as at least these
+         * versions would crash: heimdal-1.0.2 and heimdal-1.1. Later heimdal
+         * version have looping detection and return with a proper error code.
+         */
+        if ((num_prompts == 2) &&
+            (prompts[0].type == KRB5_PROMPT_TYPE_NEW_PASSWORD) &&
+            (prompts[1].type == KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN)) {
+        if (num_prompts == 2) {
                 /*
+                 * We don't want to change passwords here. We're
+                 * called from heimal when the KDC returns
+                 * KRB5KDC_ERR_KEY_EXPIRED, but at this point we don't
+                 * have the chance to ask the user for a new
+                 * password. If we return 0 (i.e. success), we will be
+                 * spinning in the endless for-loop in
+                 * change_password() in
+                 * source4/heimdal/lib/krb5/init_creds_pw.c:526ff
+                 * only heimdal has a prompt type and we need to deal with it here to
+                 * avoid loops.
+                 *
+                 * removing the prompter completely is not an option as at least these
+                 * versions would crash: heimdal-1.0.2 and heimdal-1.1. Later heimdal
+                 * version have looping detection and return with a proper error code.
                  */
+                return KRB5KDC_ERR_KEY_EXPIRED;
+        }
+#endif /* HAVE_KRB5_PROMPT_TYPE */
+#if HAVE_KRB5_PROMPT_TYPE /* Heimdal */
+                 if (prompts[0].type == KRB5_PROMPT_TYPE_NEW_PASSWORD &&
+                     prompts[1].type == KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN) {
+                        /*
+                         * We don't want to change passwords here. We're
+                         * called from heimal when the KDC returns
+                         * KRB5KDC_ERR_KEY_EXPIRED, but at this point we don't
+                         * have the chance to ask the user for a new
+                         * password. If we return 0 (i.e. success), we will be
+                         * spinning in the endless for-loop in
+                         * change_password() in
+                         * source4/heimdal/lib/krb5/init_creds_pw.c:526ff
+                         */
+                        return KRB5KDC_ERR_KEY_EXPIRED;
+                }
+#elif defined(HAVE_KRB5_GET_PROMPT_TYPES) /* MIT */
+                krb5_prompt_type *prompt_types = NULL;
+                prompt_types = krb5_get_prompt_types(ctx);
+                if (prompt_types != NULL) {
+                        if (prompt_types[0] == KRB5_PROMPT_TYPE_NEW_PASSWORD &&
+                            prompt_types[1] == KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN) {
+                                return KRB5KDC_ERR_KEY_EXP;
+                        }
+                }
+#endif
+        }
         memset(prompts[0].reply->data, '\0', prompts[0].reply->length);
         if (prompts[0].reply->length > 0) {

vendor/current/source3/libads/kerberos_keytab.c

-              r988
+              r989
         TALLOC_FREE(frame);
+        {
+        if (context) {
                 krb5_keytab_entry zero_kt_entry;
+                krb5_kt_cursor zero_csr;
                 ZERO_STRUCT(zero_kt_entry);
+                ZERO_STRUCT(zero_csr);
                 if (memcmp(&zero_kt_entry, &kt_entry,
                                 sizeof(krb5_keytab_entry))) {
                         smb_krb5_kt_free_entry(context, &kt_entry);
+                }
+        }
+        {
-                krb5_kt_cursor zero_csr;
-                ZERO_STRUCT(zero_csr);
                 if ((memcmp(&cursor, &zero_csr,
                                 sizeof(krb5_kt_cursor)) != 0) && keytab) {
                         krb5_kt_end_seq_get(context, keytab, &cursor);
+                }
+        }
+        if (keytab) {
+                krb5_kt_close(context, keytab);
+        }
+        if (context) {
+                if (keytab) {
+                        krb5_kt_close(context, keytab);
+                }
                 krb5_free_context(context);
+        }

vendor/current/source3/libads/sasl.c

-              r988
+              r989
 #include "system/gssapi.h"
 #include "lib/param/loadparm.h"
+#include "krb5_env.h"
 #ifdef HAVE_LDAP
 …
         int rc, i;
         ADS_STATUS status;
         DATA_BLOB blob;
+        DATA_BLOB blob = data_blob_null;
         char *given_principal = NULL;
         char *OIDs[ASN1_MAX_OIDS];
 …
             got_kerberos_mechanism)
+        {
+                status = ads_sasl_spnego_gensec_bind(ads, "GSS-SPNEGO",
+                                                     CRED_MUST_USE_KERBEROS,
+                                                     p.service, p.hostname,
+                                                     blob);
+                if (ADS_ERR_OK(status)) {
+                        ads_free_service_principal(&p);
+                        goto done;
+                }
+                DEBUG(10,("ads_sasl_spnego_gensec_bind(KRB5) failed with: %s, "
+                          "calling kinit\n", ads_errstr(status)));
+                if (ads->auth.password == NULL ||
+                    ads->auth.password[0] == '\0')
+                {
+                        status = ads_sasl_spnego_gensec_bind(ads, "GSS-SPNEGO",
+                                                             CRED_MUST_USE_KERBEROS,
+                                                             p.service, p.hostname,
+                                                             blob);
+                        if (ADS_ERR_OK(status)) {
+                                ads_free_service_principal(&p);
+                                goto done;
+                        }
+                        DEBUG(10,("ads_sasl_spnego_gensec_bind(KRB5) failed with: %s, "
+                                  "calling kinit\n", ads_errstr(status)));
+                }
                 status = ADS_ERROR_KRB5(ads_kinit_password(ads));
 …
         ads_free_service_principal(&p);
         TALLOC_FREE(frame);
+        if (blob.data != NULL) {
+                data_blob_free(&blob);
+        }
         return status;
+}
 …
+        }
+        status = ads_sasl_gssapi_do_bind(ads, p.name);
+        if (ADS_ERR_OK(status)) {
+                ads_free_service_principal(&p);
+                return status;
+        }
+        DEBUG(10,("ads_sasl_gssapi_do_bind failed with: %s, "
+                  "calling kinit\n", ads_errstr(status)));
+        if (ads->auth.password == NULL ||
+            ads->auth.password[0] == '\0') {
+                status = ads_sasl_gssapi_do_bind(ads, p.name);
+                if (ADS_ERR_OK(status)) {
+                        ads_free_service_principal(&p);
+                        return status;
+                }
+                DEBUG(10,("ads_sasl_gssapi_do_bind failed with: %s, "
+                          "calling kinit\n", ads_errstr(status)));
+        }
         status = ADS_ERROR_KRB5(ads_kinit_password(ads));

vendor/current/source3/libnet/libnet_join.c

-              r988
+              r989
         char *spn = NULL;
         bool ok;
+        const char **netbios_aliases = NULL;
         /* Find our DN */
 …
                                 return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                }
+        }
+        netbios_aliases = lp_netbios_aliases();
+        if (netbios_aliases != NULL) {
+                for (; *netbios_aliases != NULL; netbios_aliases++) {
+                        /*
+                         * Add HOST/NETBIOSNAME
+                         */
+                        spn = talloc_asprintf(mem_ctx, "HOST/%s", *netbios_aliases);
+                        if (spn == NULL) {
+                                TALLOC_FREE(spn);
+                                return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                        if (!strupper_m(spn)) {
+                                TALLOC_FREE(spn);
+                                return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                        ok = ads_element_in_array(spn_array, num_spns, spn);
+                        if (ok) {
+                                TALLOC_FREE(spn);
+                                continue;
+                        }
+                        ok = add_string_to_array(spn_array, spn,
+                                                 &spn_array, &num_spns);
+                        if (!ok) {
+                                TALLOC_FREE(spn);
+                                return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                        TALLOC_FREE(spn);
+                        /*
+                         * Add HOST/netbiosname.domainname
+                         */
+                        if (r->out.dns_domain_name == NULL) {
+                                continue;
+                        }
+                        fstr_sprintf(my_fqdn, "%s.%s",
+                                     *netbios_aliases,
+                                     r->out.dns_domain_name);
+                        spn = talloc_asprintf(mem_ctx, "HOST/%s", my_fqdn);
+                        if (spn == NULL) {
+                                return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                        ok = ads_element_in_array(spn_array, num_spns, spn);
+                        if (ok) {
+                                TALLOC_FREE(spn);
+                                continue;
+                        }
+                        ok = add_string_to_array(spn_array, spn,
+                                                 &spn_array, &num_spns);
+                        if (!ok) {
+                                TALLOC_FREE(spn);
+                                return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
+                        }
+                        TALLOC_FREE(spn);
+                }
+        }
 …
         bool valid_workgroup = false;
         bool valid_realm = false;
+        bool ignored_realm = false;
         /* check if configuration is already set correctly */
 …
                         switch (lp_security()) {
                         case SEC_DOMAIN:
+                                if (!valid_realm && lp_winbind_rpc_only()) {
+                                        valid_realm = true;
+                                        ignored_realm = true;
+                                }
                         case SEC_ADS:
                                 valid_security = true;
 …
                         if (valid_workgroup && valid_realm && valid_security) {
+                                if (ignored_realm && !r->in.modify_config)
+                                {
+                                        libnet_join_set_error_string(mem_ctx, r,
+                                                "Warning: ignoring realm when "
+                                                "joining AD domain with "
+                                                "'security=domain' and "
+                                                "'winbind rpc only = yes'. "
+                                                "(realm set to '%s', "
+                                                "should be '%s').", lp_realm(),
+                                                r->out.dns_domain_name);
+                                }
                                 /* nothing to be done */
                                 return WERR_OK;
 …
         create_local_private_krb5_conf_for_domain(
                 r->out.dns_domain_name, r->out.netbios_domain_name,
                 NULL, smbXcli_conn_remote_sockaddr(cli->conn));
+                sitename, smbXcli_conn_remote_sockaddr(cli->conn));
         if (r->out.domain_is_ad &&

vendor/current/source3/librpc/idl/smbXsrv.idl

-              r988
+              r989
                 boolean8                                durable;
                 DATA_BLOB                               backend_cookie;
+                hyper                                   channel_sequence;
         } smbXsrv_open_global0;
 …
                 smbXsrv_open_flags                      flags;
                 uint32                                  create_action;
+                hyper                                   request_count;
+                hyper                                   pre_request_count;
         } smbXsrv_open;

vendor/current/source3/libsmb/cli_smb2_fnum.c

-              r988
+              r989
         struct tevent_req *req, *subreq;
         struct cli_smb2_create_fnum_state *state;
+        size_t fname_len = 0;
         req = tevent_req_create(mem_ctx, &state,
 …
         if (*fname == '\\') {
                 fname++;
+        }
+        /* Or end in a '\' */
+        fname_len = strlen(fname);
+        if (fname_len > 0 && fname[fname_len-1] == '\\') {
+                char *new_fname = talloc_strdup(state, fname);
+                if (tevent_req_nomem(new_fname, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                new_fname[fname_len-1] = '\0';
+                fname = new_fname;
+        }
 …
         if (tevent_req_is_nterror(req, &status)) {
+                state->cli->raw_status = status;
                 return status;
+        }
 …
                 *cr = state->cr;
+        }
+        state->cli->raw_status = NT_STATUS_OK;
         return NT_STATUS_OK;
+}
 …
 NTSTATUS cli_smb2_close_fnum_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+        struct cli_smb2_close_fnum_state *state = tevent_req_data(
+                req, struct cli_smb2_close_fnum_state);
+        NTSTATUS status = tevent_req_simple_recv_ntstatus(req);
+        state->cli->raw_status = status;
+        return status;
+}
 …
         if (tevent_req_is_nterror(req, &status)) {
+                state->cli->raw_status = status;
                 return status;
+        }
 …
         *received = (ssize_t)state->received;
         *rcvbuf = state->buf;
+        state->cli->raw_status = NT_STATUS_OK;
         return NT_STATUS_OK;
+}
 …
         if (tevent_req_is_nterror(req, &status)) {
+                state->cli->raw_status = status;
                 tevent_req_received(req);
                 return status;
 …
                 *pwritten = (size_t)state->written;
+        }
+        state->cli->raw_status = NT_STATUS_OK;
         tevent_req_received(req);
         return NT_STATUS_OK;
 …
         if (tevent_req_is_nterror(req, &status)) {
+                state->cli->raw_status = status;
                 return status;
+        }
 …
                 *pwritten = (size_t)state->written;
+        }
+        state->cli->raw_status = NT_STATUS_OK;
         return NT_STATUS_OK;
+}
 …
         if (tevent_req_is_nterror(req, &status)) {
+                state->cli->raw_status = status;
                 tevent_req_received(req);
                 return status;
 …
                 *written = state->written;
+        }
+        state->cli->raw_status = NT_STATUS_OK;
         tevent_req_received(req);
         return NT_STATUS_OK;

vendor/current/source3/libsmb/cliconnect.c

-              r988
+              r989
+                         *
                          * So just pretend we are completely done.
+                         *
+                         * Note that smbXcli_session_is_guest()
+                         * always returns false if we require signing.
                          */
                         state->blob_in = data_blob_null;
 …
                 state->desthost = host;
         } else {
+        } else if (dest_ss != NULL) {
                 state->desthost = print_canonical_sockaddr(state, dest_ss);
                 if (tevent_req_nomem(state->desthost, req)) {
                         return tevent_req_post(req, ev);
+                }
+        } else {
+                /* No host or dest_ss given. Error out. */
+                tevent_req_error(req, EINVAL);
+                return tevent_req_post(req, ev);
+        }

vendor/current/source3/libsmb/clifile.c

r988	r989
4594	4594	setup, 1, 0,
4595	4595	param, param_len, 2,
4596		data, data_len, ~~CLI_BUFFER_SIZE~~,
	4596	data, data_len, 0,
4597	4597	NULL,
4598	4598	NULL, 0, NULL, /* rsetup */

vendor/current/source3/locking/share_mode_lock.c

-              r988
+              r989
         /*
+         * Release the dptr as well before reparenting to NULL
+         * (in-memory cache) context.
+         */
+        TALLOC_FREE(data.dptr);
+        /*
          * Reparent d into the in-memory cache so it can be reused if the
          * sequence number matches. See parse_share_modes()
 …
         struct share_mode_lock *lck = talloc_get_type_abort(
                 private_data, struct share_mode_lock);
+        if (data.dsize == 0) {
+                /* Likely a ctdb tombstone record, ignore it */
+                lck->data = NULL;
+                return;
+        }
         lck->data = parse_share_modes(lck, key, data);

vendor/current/source3/modules/getdate.c

r414	r989
182	182	#endif
183	183
184		#if ~~__GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 8) \|\| __STRICT_ANSI~~__
	184	#ifndef HAVE___ATTRIBUTE__
185	185	# define __attribute__(x)
186	186	#endif

vendor/current/source3/modules/getdate.y

r414	r989
73	73	#endif
74	74
75		#if ~~__GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 8) \|\| __STRICT_ANSI~~__
	75	#ifndef HAVE___ATTRIBUTE__
76	76	# define __attribute__(x)
77	77	#endif

vendor/current/source3/modules/vfs_acl_common.c

-              r988
+              r989
 #include "../librpc/gen_ndr/ndr_security.h"
 #include "../lib/util/bitmap.h"
+#include "passdb/lookup_sid.h"
 static NTSTATUS create_acl_blob(const struct security_descriptor *psd,
 …
                                 SECINFO_DACL | \
                                 SECINFO_SACL)
+enum default_acl_style {DEFAULT_ACL_POSIX, DEFAULT_ACL_WINDOWS};
+static const struct enum_list default_acl_style[] = {
+        {DEFAULT_ACL_POSIX,     "posix"},
+        {DEFAULT_ACL_WINDOWS,   "windows"}
+};
+struct acl_common_config {
+        bool ignore_system_acls;
+        enum default_acl_style default_acl_style;
+};
+static bool init_acl_common_config(vfs_handle_struct *handle)
+{
+        struct acl_common_config *config = NULL;
+        config = talloc_zero(handle->conn, struct acl_common_config);
+        if (config == NULL) {
+                DBG_ERR("talloc_zero() failed\n");
+                errno = ENOMEM;
+                return false;
+        }
+        config->ignore_system_acls = lp_parm_bool(SNUM(handle->conn),
+                                                  ACL_MODULE_NAME,
+                                                  "ignore system acls",
+                                                  false);
+        config->default_acl_style = lp_parm_enum(SNUM(handle->conn),
+                                                 ACL_MODULE_NAME,
+                                                 "default acl style",
+                                                 default_acl_style,
+                                                 DEFAULT_ACL_POSIX);
+        SMB_VFS_HANDLE_SET_DATA(handle, config, NULL,
+                                struct acl_common_config,
+                                return false);
+        return true;
+}
 /*******************************************************************
 …
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 DEBUG(5, ("parse_acl_blob: ndr_pull_xattr_NTACL failed: %s\n",
                         ndr_errstr(ndr_err)));
+                DBG_INFO("ndr_pull_xattr_NTACL failed: %s\n",
+                         ndr_errstr(ndr_err));
                 TALLOC_FREE(frame);
                 return ndr_map_error2ntstatus(ndr_err);
 …
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 DEBUG(5, ("create_acl_blob: ndr_push_xattr_NTACL failed: %s\n",
                         ndr_errstr(ndr_err)));
+                DBG_INFO("ndr_push_xattr_NTACL failed: %s\n",
+                         ndr_errstr(ndr_err));
                 return ndr_map_error2ntstatus(ndr_err);
+        }
 …
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 DEBUG(5, ("create_acl_blob: ndr_push_xattr_NTACL failed: %s\n",
                         ndr_errstr(ndr_err)));
+                DBG_INFO("ndr_push_xattr_NTACL failed: %s\n",
+                         ndr_errstr(ndr_err));
                 return ndr_map_error2ntstatus(ndr_err);
+        }
 …
         mode = dir_mode | file_mode;
+        DEBUG(10, ("add_directory_inheritable_components: directory %s, "
+                "mode = 0%o\n",
+                name,
+                (unsigned int)mode ));
+        DBG_DEBUG("directory %s, mode = 0%o\n", name, (unsigned int)mode);
         if (num_aces) {
 …
+}
+/*******************************************************************
+ Pull a DATA_BLOB from an xattr given a pathname.
+ If the hash doesn't match, or doesn't exist - return the underlying
+ filesystem sd.
+*******************************************************************/
+static NTSTATUS get_nt_acl_internal(vfs_handle_struct *handle,
+                                    files_struct *fsp,
+                                    const char *name,
+                                    uint32_t security_info,
+                                    TALLOC_CTX *mem_ctx,
+                                    struct security_descriptor **ppdesc)
+{
+        DATA_BLOB blob = data_blob_null;
+static NTSTATUS make_default_acl_posix(TALLOC_CTX *ctx,
+                                       const char *name,
+                                       SMB_STRUCT_STAT *psbuf,
+                                       struct security_descriptor **ppdesc)
+{
+        struct dom_sid owner_sid, group_sid;
+        size_t size = 0;
+        struct security_ace aces[4];
+        uint32_t access_mask = 0;
+        mode_t mode = psbuf->st_ex_mode;
+        struct security_acl *new_dacl = NULL;
+        int idx = 0;
+        DBG_DEBUG("file %s mode = 0%o\n",name, (int)mode);
+        uid_to_sid(&owner_sid, psbuf->st_ex_uid);
+        gid_to_sid(&group_sid, psbuf->st_ex_gid);
+        /*
+         We provide up to 4 ACEs
+                - Owner
+                - Group
+                - Everyone
+                - NT System
+        */
+        if (mode & S_IRUSR) {
+                if (mode & S_IWUSR) {
+                        access_mask |= SEC_RIGHTS_FILE_ALL;
+                } else {
+                        access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+                }
+        }
+        if (mode & S_IWUSR) {
+                access_mask |= SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
+        }
+        init_sec_ace(&aces[idx],
+                        &owner_sid,
+                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                        access_mask,
+);
+        idx++;
+        access_mask = 0;
+        if (mode & S_IRGRP) {
+                access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+        }
+        if (mode & S_IWGRP) {
+                /* note that delete is not granted - this matches posix behaviour */
+                access_mask |= SEC_RIGHTS_FILE_WRITE;
+        }
+        if (access_mask) {
+                init_sec_ace(&aces[idx],
+                        &group_sid,
+                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                        access_mask,
+);
+                idx++;
+        }
+        access_mask = 0;
+        if (mode & S_IROTH) {
+                access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+        }
+        if (mode & S_IWOTH) {
+                access_mask |= SEC_RIGHTS_FILE_WRITE;
+        }
+        if (access_mask) {
+                init_sec_ace(&aces[idx],
+                        &global_sid_World,
+                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                        access_mask,
+);
+                idx++;
+        }
+        init_sec_ace(&aces[idx],
+                        &global_sid_System,
+                        SEC_ACE_TYPE_ACCESS_ALLOWED,
+                        SEC_RIGHTS_FILE_ALL,
+);
+        idx++;
+        new_dacl = make_sec_acl(ctx,
+                        NT4_ACL_REVISION,
+                        idx,
+                        aces);
+        if (!new_dacl) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        *ppdesc = make_sec_desc(ctx,
+                        SECURITY_DESCRIPTOR_REVISION_1,
+                        SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
+                        &owner_sid,
+                        &group_sid,
+                        NULL,
+                        new_dacl,
+                        &size);
+        if (!*ppdesc) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS make_default_acl_windows(TALLOC_CTX *ctx,
+                                         const char *name,
+                                         SMB_STRUCT_STAT *psbuf,
+                                         struct security_descriptor **ppdesc)
+{
+        struct dom_sid owner_sid, group_sid;
+        size_t size = 0;
+        struct security_ace aces[4];
+        uint32_t access_mask = 0;
+        mode_t mode = psbuf->st_ex_mode;
+        struct security_acl *new_dacl = NULL;
+        int idx = 0;
+        DBG_DEBUG("file [%s] mode [0%o]\n", name, (int)mode);
+        uid_to_sid(&owner_sid, psbuf->st_ex_uid);
+        gid_to_sid(&group_sid, psbuf->st_ex_gid);
+        /*
+         * We provide 2 ACEs:
+         * - Owner
+         * - NT System
+         */
+        if (mode & S_IRUSR) {
+                if (mode & S_IWUSR) {
+                        access_mask |= SEC_RIGHTS_FILE_ALL;
+                } else {
+                        access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+                }
+        }
+        if (mode & S_IWUSR) {
+                access_mask |= SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
+        }
+        init_sec_ace(&aces[idx],
+                     &owner_sid,
+                     SEC_ACE_TYPE_ACCESS_ALLOWED,
+                     access_mask,
+);
+        idx++;
+        init_sec_ace(&aces[idx],
+                     &global_sid_System,
+                     SEC_ACE_TYPE_ACCESS_ALLOWED,
+                     SEC_RIGHTS_FILE_ALL,
+);
+        idx++;
+        new_dacl = make_sec_acl(ctx,
+                                NT4_ACL_REVISION,
+                                idx,
+                                aces);
+        if (!new_dacl) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        *ppdesc = make_sec_desc(ctx,
+                                SECURITY_DESCRIPTOR_REVISION_1,
+                                SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
+                                &owner_sid,
+                                &group_sid,
+                                NULL,
+                                new_dacl,
+                                &size);
+        if (!*ppdesc) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS make_default_filesystem_acl(TALLOC_CTX *ctx,
+                                            struct acl_common_config *config,
+                                            const char *name,
+                                            SMB_STRUCT_STAT *psbuf,
+                                            struct security_descriptor **ppdesc)
+{
+        NTSTATUS status;
+        switch (config->default_acl_style) {
+        case DEFAULT_ACL_POSIX:
+                status =  make_default_acl_posix(ctx, name, psbuf, ppdesc);
+                break;
+        case DEFAULT_ACL_WINDOWS:
+                status =  make_default_acl_windows(ctx, name, psbuf, ppdesc);
+                break;
+        default:
+                DBG_ERR("unknown acl style %d", config->default_acl_style);
+                status = NT_STATUS_INTERNAL_ERROR;
+                break;
+        }
+        return status;
+}
+/**
+ * Validate an ACL blob
+ *
+ * This validates an ACL blob against the underlying filesystem ACL. If this
+ * function returns NT_STATUS_OK ppsd can be
+ *
+ * 1. the ACL from the blob (psd_from_fs=false), or
+ * 2. the ACL from the fs (psd_from_fs=true), or
+ * 3. NULL (!)
+ *
+ * If the return value is anything else then NT_STATUS_OK, ppsd is set to NULL
+ * and psd_from_fs set to false.
+ *
+ * Returning the underlying filesystem ACL in case no. 2 is really just an
+ * optimisation, because some validations have to fetch the filesytem ACL as
+ * part of the validation, so we already have it available and callers might
+ * need it as well.
+ **/
+static NTSTATUS validate_nt_acl_blob(TALLOC_CTX *mem_ctx,
+                                     vfs_handle_struct *handle,
+                                     files_struct *fsp,
+                                     const char *name,
+                                     const DATA_BLOB *blob,
+                                     struct security_descriptor **ppsd,
+                                     bool *psd_is_from_fs)
+{
         NTSTATUS status;
         uint16_t hash_type = XATTR_SD_HASH_TYPE_NONE;
 …
         uint8_t sys_acl_hash_tmp[XATTR_SD_HASH_SIZE];
         struct security_descriptor *psd = NULL;
+        struct security_descriptor *pdesc_next = NULL;
+        bool ignore_file_system_acl = lp_parm_bool(SNUM(handle->conn),
+                                                ACL_MODULE_NAME,
+                                                "ignore system acls",
+                                                false);
+        TALLOC_CTX *frame = talloc_stackframe();
+        if (fsp && name == NULL) {
+                name = fsp->fsp_name->base_name;
+        }
+        DEBUG(10, ("get_nt_acl_internal: name=%s\n", name));
+        status = get_acl_blob(frame, handle, fsp, name, &blob);
+        struct security_descriptor *psd_blob = NULL;
+        struct security_descriptor *psd_fs = NULL;
+        char *sys_acl_blob_description = NULL;
+        DATA_BLOB sys_acl_blob = { 0 };
+        struct acl_common_config *config = NULL;
+        *ppsd = NULL;
+        *psd_is_from_fs = false;
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct acl_common_config,
+                                return NT_STATUS_UNSUCCESSFUL);
+        status = parse_acl_blob(blob,
+                                mem_ctx,
+                                &psd_blob,
+                                &hash_type,
+                                &xattr_version,
+                                &hash[0],
+                                &sys_acl_hash[0]);
         if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("get_nt_acl_internal: get_acl_blob returned %s\n",
+                        nt_errstr(status)));
+                psd = NULL;
+                goto out;
+        } else {
+                status = parse_acl_blob(&blob, mem_ctx, &psd,
+                                        &hash_type, &xattr_version, &hash[0], &sys_acl_hash[0]);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(10, ("parse_acl_blob returned %s\n",
+                                   nt_errstr(status)));
+                        psd = NULL;
+                        goto out;
+                }
+        }
+        /* Ensure we don't leak psd if we don't choose it.
+         *
+         * We don't allocate it onto frame as it is preferred not to
+         * steal from a talloc pool.
+         */
+        talloc_steal(frame, psd);
+                DBG_DEBUG("parse_acl_blob returned %s\n", nt_errstr(status));
+                goto fail;
+        }
         /* determine which type of xattr we got */
 …
                  * the NTVFS file server uses version 1, but
                  * 'samba-tool ntacl' can set these as well */
+                goto out;
+                *ppsd = psd_blob;
+                return NT_STATUS_OK;
         case 3:
         case 4:
+                if (ignore_file_system_acl) {
+                        goto out;
+                if (config->ignore_system_acls) {
+                        *ppsd = psd_blob;
+                        return NT_STATUS_OK;
+                }
                 break;
         default:
+                DEBUG(10, ("get_nt_acl_internal: ACL blob revision "
+                           "mismatch (%u) for file %s\n",
+                           (unsigned int)hash_type,
+                           name));
+                TALLOC_FREE(psd);
+                psd = NULL;
+                goto out;
+                DBG_DEBUG("ACL blob revision mismatch (%u) for file %s\n",
+                          (unsigned int)hash_type, name);
+                TALLOC_FREE(psd_blob);
+                return NT_STATUS_OK;
+        }
         /* determine which type of xattr we got */
         if (hash_type != XATTR_SD_HASH_TYPE_SHA256) {
+                DEBUG(10, ("get_nt_acl_internal: ACL blob hash type "
+                           "(%u) unexpected for file %s\n",
+                           (unsigned int)hash_type,
+                           name));
+                TALLOC_FREE(psd);
+                psd = NULL;
+                goto out;
+                DBG_DEBUG("ACL blob hash type (%u) unexpected for file %s\n",
+                          (unsigned int)hash_type, name);
+                TALLOC_FREE(psd_blob);
+                return NT_STATUS_OK;
+        }
 …
+        {
                 int ret;
-                char *sys_acl_blob_description;
-                DATA_BLOB sys_acl_blob;
                 if (fsp) {
                         /* Get the full underlying sd, then hash. */
                         ret = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle,
                                                                fsp,
                                                                frame,
+                                                               mem_ctx,
                                                                &sys_acl_blob_description,
                                                                &sys_acl_blob);
 …
                         ret = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle,
                                                                  name,
                                                                  frame,
+                                                                 mem_ctx,
                                                                  &sys_acl_blob_description,
                                                                  &sys_acl_blob);
 …
                         status = hash_blob_sha256(sys_acl_blob, sys_acl_hash_tmp);
                         if (!NT_STATUS_IS_OK(status)) {
+                                TALLOC_FREE(frame);
+                                return status;
+                                goto fail;
+                        }
+                        TALLOC_FREE(sys_acl_blob_description);
+                        TALLOC_FREE(sys_acl_blob.data);
                         if (memcmp(&sys_acl_hash[0], &sys_acl_hash_tmp[0],
                                    XATTR_SD_HASH_SIZE) == 0) {
                                 /* Hash matches, return blob sd. */
                                 DEBUG(10, ("get_nt_acl_internal: blob hash "
                                            "matches for file %s\n",
                                            name ));
                                 goto out;
+                                DBG_DEBUG("blob hash matches for file %s\n",
+                                          name);
+                                *ppsd = psd_blob;
+                                return NT_STATUS_OK;
+                        }
+                }
 …
                                                           HASH_SECURITY_INFO,
                                                           mem_ctx,
                                                           &pdesc_next);
+                                                          &psd_fs);
                 } else {
                         status = SMB_VFS_NEXT_GET_NT_ACL(handle,
 …
                                                          HASH_SECURITY_INFO,
                                                          mem_ctx,
                                                          &pdesc_next);
+                                                         &psd_fs);
+                }
                 if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(10, ("get_nt_acl_internal: get_next_acl for file %s "
+                                   "returned %s\n",
+                                   name,
+                                   nt_errstr(status)));
+                        TALLOC_FREE(frame);
+                        return status;
+                }
+                /* Ensure we don't leak psd_next if we don't choose it.
+                 *
+                 * We don't allocate it onto frame as it is preferred not to
+                 * steal from a talloc pool.
+                 */
+                talloc_steal(frame, pdesc_next);
+                status = hash_sd_sha256(pdesc_next, hash_tmp);
+                        DBG_DEBUG("get_next_acl for file %s returned %s\n",
+                                  name, nt_errstr(status));
+                        goto fail;
+                }
+                status = hash_sd_sha256(psd_fs, hash_tmp);
                 if (!NT_STATUS_IS_OK(status)) {
+                        TALLOC_FREE(psd);
+                        psd = pdesc_next;
+                        goto out;
+                        TALLOC_FREE(psd_blob);
+                        *ppsd = psd_fs;
+                        *psd_is_from_fs = true;
+                        return NT_STATUS_OK;
+                }
                 if (memcmp(&hash[0], &hash_tmp[0], XATTR_SD_HASH_SIZE) == 0) {
                         /* Hash matches, return blob sd. */
+                        DEBUG(10, ("get_nt_acl_internal: blob hash "
+                                   "matches for file %s\n",
+                                   name ));
+                        goto out;
+                        DBG_DEBUG("blob hash matches for file %s\n", name);
+                        *ppsd = psd_blob;
+                        return NT_STATUS_OK;
+                }
                 /* Hash doesn't match, return underlying sd. */
+                DEBUG(10, ("get_nt_acl_internal: blob hash "
+                           "does not match for file %s - returning "
+                           "file system SD mapping.\n",
+                           name ));
+                DBG_DEBUG("blob hash does not match for file %s - returning "
+                          "file system SD mapping.\n", name);
                 if (DEBUGLEVEL >= 10) {
+                        DEBUG(10,("get_nt_acl_internal: acl for blob hash for %s is:\n",
+                                  name ));
+                        NDR_PRINT_DEBUG(security_descriptor, pdesc_next);
+                }
+                TALLOC_FREE(psd);
+                psd = pdesc_next;
+        }
+  out:
+                        DBG_DEBUG("acl for blob hash for %s is:\n", name);
+                        NDR_PRINT_DEBUG(security_descriptor, psd_fs);
+                }
+                TALLOC_FREE(psd_blob);
+                *ppsd = psd_fs;
+                *psd_is_from_fs = true;
+        }
+        return NT_STATUS_OK;
+fail:
+        TALLOC_FREE(psd);
+        TALLOC_FREE(psd_blob);
+        TALLOC_FREE(psd_fs);
+        TALLOC_FREE(sys_acl_blob_description);
+        TALLOC_FREE(sys_acl_blob.data);
+        return status;
+}
+static NTSTATUS stat_fsp_or_name(vfs_handle_struct *handle,
+                                 files_struct *fsp,
+                                 const char *name,
+                                 SMB_STRUCT_STAT *sbuf,
+                                 SMB_STRUCT_STAT **psbuf)
+{
+        NTSTATUS status;
+        int ret;
+        if (fsp) {
+                status = vfs_stat_fsp(fsp);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+                *psbuf = &fsp->fsp_name->st;
+        } else {
+                /*
+                 * https://bugzilla.samba.org/show_bug.cgi?id=11249
+                 *
+                 * We are currently guaranteed that 'name' here is a
+                 * smb_fname->base_name, which *cannot* contain a stream name
+                 * (':'). vfs_stat_smb_fname() splits a name into a base name +
+                 * stream name, which when we get here we know we've already
+                 * done.  So we have to call the stat or lstat VFS calls
+                 * directly here. Else, a base_name that contains a ':' (from a
+                 * demangled name) will get split again.
+                 *
+                 * FIXME.
+                 * This uglyness will go away once smb_fname is fully plumbed
+                 * through the VFS.
+                 */
+                ret = vfs_stat_smb_basename(handle->conn,
+                                            name,
+                                            sbuf);
+                if (ret == -1) {
+                        return map_nt_error_from_unix(errno);
+                }
+        }
+        return NT_STATUS_OK;
+}
+/*******************************************************************
+ Pull a DATA_BLOB from an xattr given a pathname.
+ If the hash doesn't match, or doesn't exist - return the underlying
+ filesystem sd.
+*******************************************************************/
+static NTSTATUS get_nt_acl_internal(vfs_handle_struct *handle,
+                                    files_struct *fsp,
+                                    const char *name,
+                                    uint32_t security_info,
+                                    TALLOC_CTX *mem_ctx,
+                                    struct security_descriptor **ppdesc)
+{
+        DATA_BLOB blob = data_blob_null;
+        NTSTATUS status;
+        struct security_descriptor *psd = NULL;
+        bool psd_is_from_fs = false;
+        struct acl_common_config *config = NULL;
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct acl_common_config,
+                                return NT_STATUS_UNSUCCESSFUL);
+        if (fsp && name == NULL) {
+                name = fsp->fsp_name->base_name;
+        }
+        DBG_DEBUG("name=%s\n", name);
+        status = get_acl_blob(mem_ctx, handle, fsp, name, &blob);
+        if (NT_STATUS_IS_OK(status)) {
+                status = validate_nt_acl_blob(mem_ctx,
+                                              handle,
+                                              fsp,
+                                              name,
+                                              &blob,
+                                              &psd,
+                                              &psd_is_from_fs);
+                TALLOC_FREE(blob.data);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DBG_DEBUG("ACL validation for [%s] failed\n",
+                                  name);
+                        goto fail;
+                }
+        }
         if (psd == NULL) {
 …
                  * blob for the hash, or the revision/hash type wasn't
                  * known */
+                if (fsp) {
+                        status = SMB_VFS_NEXT_FGET_NT_ACL(handle,
+                                                          fsp,
+                                                          security_info,
+                                                          mem_ctx,
+                                                          &pdesc_next);
+                if (config->ignore_system_acls) {
+                        SMB_STRUCT_STAT sbuf;
+                        SMB_STRUCT_STAT *psbuf = &sbuf;
+                        status = stat_fsp_or_name(handle, fsp, name,
+                                                  &sbuf, &psbuf);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                goto fail;
+                        }
+                        status = make_default_filesystem_acl(
+                                mem_ctx,
+                                config,
+                                name,
+                                psbuf,
+                                &psd);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                goto fail;
+                        }
                 } else {
+                        status = SMB_VFS_NEXT_GET_NT_ACL(handle,
+                                                         name,
+                                                         security_info,
+                                                         mem_ctx,
+                                                         &pdesc_next);
+                }
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(10, ("get_nt_acl_internal: get_next_acl for file %s "
+                                   "returned %s\n",
+                                   name,
+                                   nt_errstr(status)));
+                        TALLOC_FREE(frame);
+                        return status;
+                }
+                /* Ensure we don't leak psd_next if we don't choose it.
+                 *
+                 * We don't allocate it onto frame as it is preferred not to
+                 * steal from a talloc pool.
+                 */
+                talloc_steal(frame, pdesc_next);
+                psd = pdesc_next;
+        }
+        if (psd != pdesc_next) {
+                /* We're returning the blob, throw
+                 * away the filesystem SD. */
+                TALLOC_FREE(pdesc_next);
+        } else {
+                        if (fsp) {
+                                status = SMB_VFS_NEXT_FGET_NT_ACL(handle,
+                                                                  fsp,
+                                                                  security_info,
+                                                                  mem_ctx,
+                                                                  &psd);
+                        } else {
+                                status = SMB_VFS_NEXT_GET_NT_ACL(handle,
+                                                                 name,
+                                                                 security_info,
+                                                                 mem_ctx,
+                                                                 &psd);
+                        }
+                        if (!NT_STATUS_IS_OK(status)) {
+                                DBG_DEBUG("get_next_acl for file %s "
+                                          "returned %s\n", name,
+                                          nt_errstr(status));
+                                goto fail;
+                        }
+                        psd_is_from_fs = true;
+                }
+        }
+        if (psd_is_from_fs) {
                 SMB_STRUCT_STAT sbuf;
                 SMB_STRUCT_STAT *psbuf = &sbuf;
                 bool is_directory = false;
                 /*
                  * We're returning the underlying ACL from the
 …
                  * inheritable ACE entries we have to fake them.
                  */
+                if (fsp) {
+                        status = vfs_stat_fsp(fsp);
+                status = stat_fsp_or_name(handle, fsp, name,
+                                          &sbuf, &psbuf);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto fail;
+                }
+                is_directory = S_ISDIR(psbuf->st_ex_mode);
+                if (is_directory && !sd_has_inheritable_components(psd, true)) {
+                        status = add_directory_inheritable_components(
+                                handle,
+                                name,
+                                psbuf,
+                                psd);
                         if (!NT_STATUS_IS_OK(status)) {
+                                TALLOC_FREE(frame);
+                                return status;
+                                goto fail;
+                        }
+                        psbuf = &fsp->fsp_name->st;
+                } else {
+                        /*
+                         * https://bugzilla.samba.org/show_bug.cgi?id=11249
+                         *
+                         * We are currently guaranteed that 'name' here is
+                         * a smb_fname->base_name, which *cannot* contain
+                         * a stream name (':'). vfs_stat_smb_fname() splits
+                         * a name into a base name + stream name, which
+                         * when we get here we know we've already done.
+                         * So we have to call the stat or lstat VFS
+                         * calls directly here. Else, a base_name that
+                         * contains a ':' (from a demangled name) will
+                         * get split again.
+                         *
+                         * FIXME.
+                         * This uglyness will go away once smb_fname
+                         * is fully plumbed through the VFS.
+                         */
+                        int ret = vfs_stat_smb_basename(handle->conn,
+                                                name,
+                                                &sbuf);
+                        if (ret == -1) {
+                                TALLOC_FREE(frame);
+                                return map_nt_error_from_unix(errno);
+                        }
+                }
+                is_directory = S_ISDIR(psbuf->st_ex_mode);
+                if (ignore_file_system_acl) {
+                        TALLOC_FREE(pdesc_next);
+                        status = make_default_filesystem_acl(mem_ctx,
+                                                name,
+                                                psbuf,
+                                                &psd);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                TALLOC_FREE(frame);
+                                return status;
+                        }
+                } else {
+                        if (is_directory &&
+                                !sd_has_inheritable_components(psd,
+                                                        true)) {
+                                status = add_directory_inheritable_components(
+                                                        handle,
+                                                        name,
+                                                        psbuf,
+                                                        psd);
+                                if (!NT_STATUS_IS_OK(status)) {
+                                        TALLOC_FREE(frame);
+                                        return status;
+                                }
+                        }
+                        /* The underlying POSIX module always sets
+                           the ~SEC_DESC_DACL_PROTECTED bit, as ACLs
+                           can't be inherited in this way under POSIX.
+                           Remove it for Windows-style ACLs. */
+                        psd->type &= ~SEC_DESC_DACL_PROTECTED;
+                }
+                }
+                /*
+                 * The underlying POSIX module always sets the
+                 * ~SEC_DESC_DACL_PROTECTED bit, as ACLs can't be inherited in
+                 * this way under POSIX. Remove it for Windows-style ACLs.
+                 */
+                psd->type &= ~SEC_DESC_DACL_PROTECTED;
+        }
 …
+        }
-        TALLOC_FREE(blob.data);
         if (DEBUGLEVEL >= 10) {
+                DEBUG(10,("get_nt_acl_internal: returning acl for %s is:\n",
+                        name ));
+                DBG_DEBUG("returning acl for %s is:\n", name);
                 NDR_PRINT_DEBUG(security_descriptor, psd);
+        }
+        /* The VFS API is that the ACL is expected to be on mem_ctx */
+        *ppdesc = talloc_move(mem_ctx, &psd);
+        TALLOC_FREE(frame);
+        *ppdesc = psd;
         return NT_STATUS_OK;
+fail:
+        TALLOC_FREE(psd);
+        return status;
+}
 …
+        }
+        DEBUG(10, ("fset_nt_acl_common: overriding chown on file %s "
+                   "for sid %s\n",
+                   fsp_str_dbg(fsp), sid_string_tos(psd->owner_sid)));
+        DBG_DEBUG("overriding chown on file %s for sid %s\n",
+                   fsp_str_dbg(fsp), sid_string_tos(psd->owner_sid));
         /* Ok, we failed to chown and we have
 …
         if (DEBUGLEVEL >= 10) {
                 DEBUG(10, ("fset_nt_acl_xattr: storing xattr sd for file %s\n",
                            fsp_str_dbg(fsp)));
+                DBG_DEBUG("storing xattr sd for file %s\n",
+                          fsp_str_dbg(fsp));
                 NDR_PRINT_DEBUG(
                     security_descriptor,
 …
                 if (pdesc_next != NULL) {
+                        DEBUG(10, ("fset_nt_acl_xattr: storing has in xattr sd "
+                                   "based on \n"));
+                        DBG_DEBUG("storing xattr sd based on \n");
                         NDR_PRINT_DEBUG(
                             security_descriptor,
 …
                                             pdesc_next));
                 } else {
+                        DEBUG(10,
+                              ("fset_nt_acl_xattr: ignoring underlying sd\n"));
+                        DBG_DEBUG("ignoring underlying sd\n");
+                }
+        }
         status = create_acl_blob(psd, &blob, XATTR_SD_HASH_TYPE_SHA256, hash);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("fset_nt_acl_xattr: create_acl_blob failed\n"));
+                DBG_DEBUG("create_acl_blob failed\n");
                 return status;
+        }
 …
         if (DEBUGLEVEL >= 10) {
+                DEBUG(10,("fset_nt_acl_xattr: incoming sd for file %s\n",
+                          fsp_str_dbg(fsp)));
+                DBG_DEBUG("incoming sd for file %s\n", fsp_str_dbg(fsp));
                 NDR_PRINT_DEBUG(security_descriptor,
                         discard_const_p(struct security_descriptor, orig_psd));
 …
         if (DEBUGLEVEL >= 10) {
                 DEBUG(10,("fset_nt_acl_xattr: storing xattr sd for file %s based on system ACL\n",
                           fsp_str_dbg(fsp)));
+                DBG_DEBUG("storing xattr sd for file %s based on system ACL\n",
+                          fsp_str_dbg(fsp));
                 NDR_PRINT_DEBUG(security_descriptor,
                                 discard_const_p(struct security_descriptor, psd));
                 DEBUG(10,("fset_nt_acl_xattr: storing hash in xattr sd based on system ACL and:\n"));
+                DBG_DEBUG("storing hash in xattr sd based on system ACL and:\n");
                 NDR_PRINT_DEBUG(security_descriptor,
                                 discard_const_p(struct security_descriptor, pdesc_next));
 …
                                      sys_acl_description, sys_acl_hash);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("fset_nt_acl_xattr: create_sys_acl_blob failed\n"));
+                DBG_DEBUG("create_sys_acl_blob failed\n");
                 TALLOC_FREE(frame);
                 return status;
 …
+        }
+        DEBUG(10,("acl_common_remove_object: removing %s %s/%s\n",
+                is_directory ? "directory" : "file",
+                parent_dir, final_component ));
+        DBG_DEBUG("removing %s %s/%s\n", is_directory ? "directory" : "file",
+                  parent_dir, final_component);
         /* cd into the parent dir to pin it. */
 …
         if (!fsp) {
+                DEBUG(10,("acl_common_remove_object: %s %s/%s "
+                        "not an open file\n",
+                        is_directory ? "directory" : "file",
+                        parent_dir, final_component ));
+                DBG_DEBUG("%s %s/%s not an open file\n",
+                          is_directory ? "directory" : "file",
+                          parent_dir, final_component);
                 saved_errno = EACCES;
                 goto out;
 …
+        }
+        DEBUG(10,("rmdir_acl_common: unlink of %s failed %s\n",
+                path,
+                strerror(errno) ));
+        DBG_DEBUG("unlink of %s failed %s\n", path, strerror(errno));
         return -1;
+}
 …
+        }
         DEBUG(10,("unlink_acl_common: unlink of %s failed %s\n",
                 smb_fname->base_name,
                 strerror(errno) ));
+        DBG_DEBUG("unlink of %s failed %s\n",
+                  smb_fname->base_name,
+                  strerror(errno));
         return -1;
+}

vendor/current/source3/modules/vfs_acl_tdb.c

-              r988
+              r989
+{
         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
+        bool ok;
+        struct acl_common_config *config = NULL;
         if (ret < 0) {
 …
         if (!acl_tdb_init()) {
                 SMB_VFS_NEXT_DISCONNECT(handle);
+                return -1;
+        }
+        ok = init_acl_common_config(handle);
+        if (!ok) {
+                DBG_ERR("init_acl_common_config failed\n");
                 return -1;
+        }
 …
         lp_do_parameter(SNUM(handle->conn), "dos filemode", "true");
         lp_do_parameter(SNUM(handle->conn), "force unknown acl user", "true");
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct acl_common_config,
+                                return -1);
+        if (config->ignore_system_acls) {
+                DBG_NOTICE("setting 'create mask = 0666', "
+                           "'directory mask = 0777', "
+                           "'store dos attributes = yes' and all "
+                           "'map ...' options to 'no'\n");
+                lp_do_parameter(SNUM(handle->conn), "create mask", "0666");
+                lp_do_parameter(SNUM(handle->conn), "directory mask", "0777");
+                lp_do_parameter(SNUM(handle->conn), "map archive", "no");
+                lp_do_parameter(SNUM(handle->conn), "map hidden", "no");
+                lp_do_parameter(SNUM(handle->conn), "map readonly", "no");
+                lp_do_parameter(SNUM(handle->conn), "map system", "no");
+                lp_do_parameter(SNUM(handle->conn), "store dos attributes",
+                                "yes");
+        }
         return 0;

vendor/current/source3/modules/vfs_acl_xattr.c

-              r988
+              r989
+{
         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
+        bool ok;
+        struct acl_common_config *config = NULL;
         if (ret < 0) {
                 return ret;
+        }
+        ok = init_acl_common_config(handle);
+        if (!ok) {
+                DBG_ERR("init_acl_common_config failed\n");
+                return -1;
+        }
 …
         lp_do_parameter(SNUM(handle->conn), "dos filemode", "true");
         lp_do_parameter(SNUM(handle->conn), "force unknown acl user", "true");
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct acl_common_config,
+                                return -1);
+        if (config->ignore_system_acls) {
+                DBG_NOTICE("setting 'create mask = 0666', "
+                           "'directory mask = 0777', "
+                           "'store dos attributes = yes' and all "
+                           "'map ...' options to 'no'\n");
+                lp_do_parameter(SNUM(handle->conn), "create mask", "0666");
+                lp_do_parameter(SNUM(handle->conn), "directory mask", "0777");
+                lp_do_parameter(SNUM(handle->conn), "map archive", "no");
+                lp_do_parameter(SNUM(handle->conn), "map hidden", "no");
+                lp_do_parameter(SNUM(handle->conn), "map readonly", "no");
+                lp_do_parameter(SNUM(handle->conn), "map system", "no");
+                lp_do_parameter(SNUM(handle->conn), "store dos attributes",
+                                "yes");
+        }
         return 0;

vendor/current/source3/modules/vfs_ceph.c

-              r988
+              r989
         /* available disk space is enough or not? */
+        space_avail = get_dfree_info(fsp->conn,
+                                     fsp->fsp_name->base_name,
+                                     &bsize, &dfree, &dsize);
+        space_avail =
+            get_dfree_info(fsp->conn, fsp->fsp_name, &bsize, &dfree, &dsize);
         /* space_avail is 1k blocks */
         if (space_avail == (uint64_t)-1 ||

vendor/current/source3/modules/vfs_default.c

-              r988
+              r989
         /* available disk space is enough or not? */
+        space_avail = get_dfree_info(fsp->conn,
+                                     fsp->fsp_name->base_name,
+                                     &bsize, &dfree, &dsize);
+        space_avail =
+            get_dfree_info(fsp->conn, fsp->fsp_name, &bsize, &dfree, &dsize);
         /* space_avail is 1k blocks */
         if (space_avail == (uint64_t)-1 ||

vendor/current/source3/modules/vfs_fake_dfq.c

-              r988
+              r989
                                           (unsigned long long)id.gid);
                 break;
+        case SMB_USER_FS_QUOTA_TYPE:
+                section = talloc_strdup(talloc_tos(), "udflt");
+                break;
+        case SMB_GROUP_FS_QUOTA_TYPE:
+                section = talloc_strdup(talloc_tos(), "gdflt");
+                break;
         default:
                 break;
 …
+        }
         bsize = dfq_load_param(snum, rpath, section, "block size", 0);
+        bsize = dfq_load_param(snum, rpath, section, "block size", 4096);
         if (bsize == 0) {
                 goto dflt;
 …
         if (dfq_load_param(snum, rpath, section, "err", 0) != 0) {
                 errno = ENOTSUP;
+                rc = -1;
+                goto out;
+        }
+        if (dfq_load_param(snum, rpath, section, "nosys", 0) != 0) {
+                errno = ENOSYS;
                 rc = -1;
                 goto out;
 …
             dfq_load_param(snum, rpath, section, "inode soft limit", 0);
         qt->curinodes = dfq_load_param(snum, rpath, section, "cur inodes", 0);
+        qt->qflags = dfq_load_param(snum, rpath, section, "qflags", QUOTAS_DENY_DISK);
         if (dfq_load_param(snum, rpath, section, "edquot", 0) != 0) {

vendor/current/source3/modules/vfs_fruit.c

-              r988
+              r989
         bool copyfile_enabled;
         bool veto_appledouble;
+        bool posix_rename;
         /*
 …
                                            "copyfile", false);
+        config->posix_rename = lp_parm_bool(
+                SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
         config->readdir_attr_rsize = lp_parm_bool(
                 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
 …
+                }
                 if (fsp->is_directory) {
+                if (config->posix_rename && fsp->is_directory) {
                         /*
                          * Enable POSIX directory rename behaviour

vendor/current/source3/modules/vfs_glusterfs.c

-              r988
+              r989
 #include "lib/util/dlinklist.h"
 #include "lib/util/tevent_unix.h"
-#include "lib/tevent/tevent_internal.h"
 #include "smbd/globals.h"
 #include "lib/util/sys_rw.h"
 …
                 DEBUG(0, ("%s: Failed to set xlator option:"
                           " snapdir-entry-path\n", volume));
+                glfs_fini(fs);
+                return -1;
+                goto done;
+        }

vendor/current/source3/modules/vfs_shadow_copy2.c

-              r988
+              r989
         char *tmp = NULL;
         char *result = NULL;
+        char *parent_dir = NULL;
         int saved_errno;
         size_t rootpath_len = 0;
 …
                                       &rootpath_len);
         if (tmp == NULL) {
+                goto done;
+                if (errno != ENOENT) {
+                        goto done;
+                }
+                /*
+                 * If the converted path does not exist, and converting
+                 * the parent yields something that does exist, then
+                 * this path refers to something that has not been
+                 * created yet, relative to the parent path.
+                 * The snapshot finding is relative to the parent.
+                 * (usually snapshots are read/only but this is not
+                 * necessarily true).
+                 * This code also covers getting a wildcard in the
+                 * last component, because this function is called
+                 * prior to sanitizing the path, and in SMB1 we may
+                 * get wildcards in path names.
+                 */
+                if (!parent_dirname(talloc_tos(), stripped, &parent_dir,
+                                    NULL)) {
+                        errno = ENOMEM;
+                        goto done;
+                }
+                tmp = shadow_copy2_do_convert(talloc_tos(), handle, parent_dir,
+                                              timestamp, &rootpath_len);
+                if (tmp == NULL) {
+                        goto done;
+                }
+        }
 …
         TALLOC_FREE(tmp);
         TALLOC_FREE(stripped);
+        TALLOC_FREE(parent_dir);
         errno = saved_errno;
         return result;

vendor/current/source3/nmbd/nmbd_packets.c

-              r988
+              r989
         enum packet_type type;
         bool broadcast;
+        int fd;
+        bool triggered;
 };
+static bool create_listen_pollfds(struct pollfd **pfds,
+                                  struct socket_attributes **pattrs,
+static bool create_listen_array(struct socket_attributes **pattrs,
                                   int *pnum_sockets)
+{
 …
         int count = 0;
         int num = 0;
-        struct pollfd *fds;
         struct socket_attributes *attrs;
 …
+        }
         fds = talloc_zero_array(NULL, struct pollfd, count);
         if (fds == NULL) {
                 DEBUG(1, ("create_listen_pollfds: malloc fail for fds. "
+        attrs = talloc_zero_array(NULL, struct socket_attributes, count);
+        if (attrs == NULL) {
+                DEBUG(1, ("talloc fail for attrs. "
                           "size %d\n", count));
                 return true;
+        }
-        attrs = talloc_array(NULL, struct socket_attributes, count);
-        if (fds == NULL) {
-                DEBUG(1, ("create_listen_pollfds: malloc fail for attrs. "
-                          "size %d\n", count));
-                TALLOC_FREE(fds);
-                return true;
+        }
         num = 0;
         fds[num].fd = ClientNMB;
+        attrs[num].fd = ClientNMB;
         attrs[num].type = NMB_PACKET;
         attrs[num].broadcast = false;
         num += 1;
         fds[num].fd = ClientDGRAM;
+        attrs[num].fd = ClientDGRAM;
         attrs[num].type = DGRAM_PACKET;
         attrs[num].broadcast = false;
 …
                 if (subrec->nmb_sock != -1) {
                         fds[num].fd = subrec->nmb_sock;
+                        attrs[num].fd = subrec->nmb_sock;
                         attrs[num].type = NMB_PACKET;
                         attrs[num].broadcast = false;
 …
                 if (subrec->nmb_bcast != -1) {
                         fds[num].fd = subrec->nmb_bcast;
+                        attrs[num].fd = subrec->nmb_bcast;
                         attrs[num].type = NMB_PACKET;
                         attrs[num].broadcast = true;
 …
                 if (subrec->dgram_sock != -1) {
                         fds[num].fd = subrec->dgram_sock;
+                        attrs[num].fd = subrec->dgram_sock;
                         attrs[num].type = DGRAM_PACKET;
                         attrs[num].broadcast = false;
 …
                 if (subrec->dgram_bcast != -1) {
                         fds[num].fd = subrec->dgram_bcast;
+                        attrs[num].fd = subrec->dgram_bcast;
                         attrs[num].type = DGRAM_PACKET;
                         attrs[num].broadcast = true;
 …
+                }
+        }
-        TALLOC_FREE(*pfds);
-        *pfds = fds;
         TALLOC_FREE(*pattrs);
 …
 /****************************************************************************
+ Timeout callback - just notice we timed out.
+***************************************************************************/
+static void nmbd_timeout_handler(struct tevent_context *ev,
+                        struct tevent_timer *te,
+                        struct timeval current_time,
+                        void *private_data)
+{
+        bool *got_timeout = private_data;
+        *got_timeout = true;
+}
+/****************************************************************************
+ fd callback - remember the fd that triggered.
+***************************************************************************/
+static void nmbd_fd_handler(struct tevent_context *ev,
+                                struct tevent_fd *fde,
+                                uint16_t flags,
+                                void *private_data)
+{
+        struct socket_attributes *attr = private_data;
+        attr->triggered = true;
+}
+/****************************************************************************
   Listens for NMB or DGRAM packets, and queues them.
   return True if the socket is dead
 …
 bool listen_for_packets(struct messaging_context *msg, bool run_election)
+{
-        static struct pollfd *fds = NULL;
         static struct socket_attributes *attrs = NULL;
         static int listen_number = 0;
         int num_sockets;
         int i;
         int pollrtn;
+        int timeout;
+        int loop_rtn;
+        int timeout_secs;
 #ifndef SYNC_DNS
         int dns_fd;
 …
 #endif
         struct processed_packet *processed_packet_list = NULL;
+        if ((fds == NULL) || rescan_listen_set) {
+                if (create_listen_pollfds(&fds, &attrs, &listen_number)) {
+        struct tevent_timer *te = NULL;
+        bool got_timeout = false;
+        TALLOC_CTX *frame = talloc_stackframe();
+        if ((attrs == NULL) || rescan_listen_set) {
+                if (create_listen_array(&attrs, &listen_number)) {
                         DEBUG(0,("listen_for_packets: Fatal error. unable to create listen set. Exiting.\n"));
+                        TALLOC_FREE(frame);
                         return True;
+                }
 …
+        }
-        /*
-         * "fds" can be enlarged by event_add_to_poll_args
-         * below. Shrink it again to what was given to us by
-         * create_listen_pollfds.
-         */
-        fds = talloc_realloc(NULL, fds, struct pollfd, listen_number);
-        if (fds == NULL) {
-                return true;
+        }
         num_sockets = listen_number;
 …
         dns_fd = asyncdns_fd();
         if (dns_fd != -1) {
+                fds = talloc_realloc(NULL, fds, struct pollfd, num_sockets+1);
+                if (fds == NULL) {
+                attrs = talloc_realloc(NULL,
+                                        attrs,
+                                        struct socket_attributes,
+                                        num_sockets + 1);
+                if (attrs == NULL) {
+                        TALLOC_FREE(frame);
                         return true;
+                }
                 dns_pollidx = num_sockets;
+                fds[num_sockets].fd = dns_fd;
+                attrs[dns_pollidx].fd = dns_fd;
+                /*
+                 * dummy values, we only need
+                 * fd and triggered.
+                 */
+                attrs[dns_pollidx].type = NMB_PACKET;
+                attrs[dns_pollidx].broadcast = false;
                 num_sockets += 1;
+        }
 …
         for (i=0; i<num_sockets; i++) {
+                fds[i].events = POLLIN|POLLHUP;
+        }
+        /* Process a signal and timer events now... */
+        if (run_events_poll(nmbd_event_context(), 0, NULL, 0)) {
+                return False;
+                struct tevent_fd *tfd = tevent_add_fd(nmbd_event_context(),
+                                                        frame,
+                                                        attrs[i].fd,
+                                                        TEVENT_FD_READ,
+                                                        nmbd_fd_handler,
+                                                        &attrs[i]);
+                if (tfd == NULL) {
+                        TALLOC_FREE(frame);
+                        return true;
+                }
+                attrs[i].triggered = false;
+        }
 …
          */
+        timeout = ((run_election||num_response_packets)
+                   ? 1 : NMBD_SELECT_LOOP) * 1000;
+        event_add_to_poll_args(nmbd_event_context(), NULL,
+                               &fds, &num_sockets, &timeout);
+        pollrtn = poll(fds, num_sockets, timeout);
+        if (run_events_poll(nmbd_event_context(), pollrtn, fds, num_sockets)) {
+                return False;
+        }
+        if (pollrtn == -1) {
+                return False;
+        if (run_election||num_response_packets) {
+                timeout_secs = 1;
+        } else {
+                timeout_secs = NMBD_SELECT_LOOP;
+        }
+        te = tevent_add_timer(nmbd_event_context(),
+                                frame,
+                                tevent_timeval_current_ofs(timeout_secs, 0),
+                                nmbd_timeout_handler,
+                                &got_timeout);
+        if (te == NULL) {
+                TALLOC_FREE(frame);
+                return true;
+        }
+        loop_rtn = tevent_loop_once(nmbd_event_context());
+        if (loop_rtn == -1) {
+                TALLOC_FREE(frame);
+                return true;
+        }
+        if (got_timeout) {
+                TALLOC_FREE(frame);
+                return false;
+        }
 #ifndef SYNC_DNS
         if ((dns_fd != -1) && (dns_pollidx != -1) &&
             (fds[dns_pollidx].revents & (POLLIN|POLLHUP|POLLERR))) {
+            attrs[dns_pollidx].triggered){
                 run_dns_queue(msg);
+                TALLOC_FREE(frame);
+                return false;
+        }
 #endif
 …
                 int client_port;
                 if ((fds[i].revents & (POLLIN|POLLHUP|POLLERR)) == 0) {
+                if (!attrs[i].triggered) {
                         continue;
+                }
 …
+                }
                 packet = read_packet(fds[i].fd, packet_type);
+                packet = read_packet(attrs[i].fd, packet_type);
                 if (!packet) {
                         continue;
 …
                  */
                 if (lp_bind_interfaces_only() &&
                     (fds[i].fd == client_fd) &&
+                    (attrs[i].fd == client_fd) &&
                     (!is_local_net_v4(packet->ip))) {
                         DEBUG(7,("discarding %s packet sent to broadcast socket from %s:%d\n",
 …
                 if (attrs[i].broadcast) {
                         /* this is a broadcast socket */
                         packet->send_fd = fds[i-1].fd;
+                        packet->send_fd = attrs[i-1].fd;
                 } else {
                         /* this is already a unicast socket */
                         packet->send_fd = fds[i].fd;
+                        packet->send_fd = attrs[i].fd;
+                }
 …
         free_processed_packet_list(&processed_packet_list);
+        TALLOC_FREE(frame);
         return False;
+}

vendor/current/source3/param/loadparm.c

-              r988
+              r989
         Globals.server_services = str_list_make_v3_const(NULL, "s3fs rpc nbt wrepl ldap cldap kdc drepl winbindd ntp_signd kcc dnsupdate dns", NULL);
         Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
+        Globals.dcerpc_endpoint_servers = str_list_make_v3_const(NULL, "epmapper wkssvc rpcecho samr netlogon lsarpc drsuapi dssetup unixinfo browser eventlog6 backupkey dnsserver", NULL);
         Globals.tls_enabled = true;
 …
 /*******************************************************************
+ Change everything needed to ensure POSIX pathname processing (currently
+ not much).
+ Set posix pathnames to new value. Returns old value.
 ********************************************************************/
+void lp_set_posix_pathnames(void)
+{
+        posix_pathnames = true;
+bool lp_set_posix_pathnames(bool newval)
+{
+        bool oldval = posix_pathnames;
+        posix_pathnames = newval;
+        return oldval;
+}

vendor/current/source3/passdb/pdb_ldap.c

-              r988
+              r989
                                 "gecos",
                                 ctx);
                 if (unix_pw.pw_gecos) {
+                if (unix_pw.pw_gecos == NULL) {
                         unix_pw.pw_gecos = fullname;
+                }
 …
                                 "homeDirectory",
                                 ctx);
                 if (unix_pw.pw_dir) {
+                if (unix_pw.pw_dir == NULL) {
                         unix_pw.pw_dir = discard_const_p(char, "");
+                }
 …
                                 "loginShell",
                                 ctx);
                 if (unix_pw.pw_shell) {
+                if (unix_pw.pw_shell == NULL) {
                         unix_pw.pw_shell = discard_const_p(char, "");
+                }

vendor/current/source3/printing/nt_printing_migrate.c

-              r988
+              r989
+ *
  *  Copyright (c) Andreas Schneider            2010.
+ *  Copyright (C) Bjoern Baumbach <bb@sernet.de> 2011
+ *
  *  This program is free software; you can redistribute it and/or modify
 …
 #include "rpc_client/cli_winreg_spoolss.h"
+static const char *driver_file_basename(const char *file)
+{
+        const char *basefile;
+        basefile = strrchr(file, '\\');
+        if (basefile == NULL) {
+                basefile = file;
+        } else {
+                basefile++;
+        }
+        return basefile;
+}
 NTSTATUS printing_tdb_migrate_form(TALLOC_CTX *mem_ctx,
                                    struct rpc_pipe_client *winreg_pipe,
 …
         const char *driver_name;
         uint32_t driver_version;
+        int i;
         blob = data_blob_const(data, length);
 …
         ZERO_STRUCT(a);
+        /* remove paths from file names */
+        if (r.dependent_files != NULL) {
+                for (i = 0 ; r.dependent_files[i] != NULL; i++) {
+                        r.dependent_files[i] = driver_file_basename(r.dependent_files[i]);
+                }
+        }
         a.string = r.dependent_files;
+        r.driverpath = driver_file_basename(r.driverpath);
+        r.configfile = driver_file_basename(r.configfile);
+        r.datafile = driver_file_basename(r.datafile);
+        r.helpfile = driver_file_basename(r.helpfile);
         d3.architecture = r.environment;

vendor/current/source3/rpc_client/cli_winreg_spoolss.c

-              r988
+              r989
         char *str;
+        /* FIXME: check format is right,
+         *      this needs to be something like: 6.1.7600.16385 */
+        /*
+         * this needs to be something like: 6.1.7600.16385
+         */
         str = talloc_asprintf(mem_ctx, "%u.%u.%u.%u",
                               (unsigned)((data >> 48) & 0xFFFF),
 …
                 ((uint64_t)(v2 & 0xFFFF) << 32) +
                 ((uint64_t)(v3 & 0xFFFF) << 16) +
                 (uint64_t)(v2 & 0xFFFF);
+                (uint64_t)(v4 & 0xFFFF);
         return WERR_OK;

vendor/current/source3/rpc_server/mdssd.c

r988	r989
668	668	}
669	669
670		status = reinit_after_fork(msg_ctx, ev_ctx, true, "mdssd-master");
	670	status = smbd_reinit_after_fork(msg_ctx, ev_ctx, true, "mdssd-master");
671	671	if (!NT_STATUS_IS_OK(status)) {
672	672	DEBUG(0,("reinit_after_fork() failed\n"));

vendor/current/source3/rpc_server/mdssvc/mdssvc.c

-              r988
+              r989
 /**
  * Init callbacks at startup, nothing to do here really
+ * Init callbacks at startup
  **/
 bool mds_init(struct messaging_context *msg_ctx)
+{
+#if (GLIB_MAJOR_VERSION < 3) && (GLIB_MINOR_VERSION < 36)
+        g_type_init();
+#endif
         return true;
+}

vendor/current/source3/rpc_server/mdssvc/sparql_parser.c

-              r988
+              r989
 #ifndef YY_ATTRIBUTE
+# if (defined __GNUC__                                               \
+      && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
+     || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# if HAVE___ATTRIBUTE__
 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
 # else

vendor/current/source3/rpc_server/rpc_ncacn_np.c

-              r988
+              r989
+        }
         ev_ctx = s3_tevent_context_init(tmp_ctx);
+        ev_ctx = samba_tevent_context_init(tmp_ctx);
         if (ev_ctx == NULL) {
                 DEBUG(0, ("s3_tevent_context_init failed\n"));
+                DEBUG(0, ("samba_tevent_context_init failed\n"));
                 status = NT_STATUS_NO_MEMORY;
                 goto out;
 …
+        }
         ev = s3_tevent_context_init(talloc_tos());
+        ev = samba_tevent_context_init(talloc_tos());
         if (ev == NULL) {
                 DEBUG(0, ("s3_tevent_context_init failed\n"));
+                DEBUG(0, ("samba_tevent_context_init failed\n"));
                 goto fail;
+        }

vendor/current/source3/rpc_server/spoolss/srv_spoolss_nt.c

-              r988
+              r989
         if (!found) {
                 gencache_set(cache_key, printer_not_found,
                              time_mono(NULL) + 300);
+                             time(NULL) + 300);
                 TALLOC_FREE(cache_key);
                 DEBUGADD(4,("Printer not found\n"));
 …
+        }
         gencache_set(cache_key, sname, time_mono(NULL) + 300);
+        gencache_set(cache_key, sname, time(NULL) + 300);
         TALLOC_FREE(cache_key);

vendor/current/source3/rpcclient/rpcclient.c

-              r988
+              r989
         char *user, *domain, *q;
         const char *host;
+        int signing_state = SMB_SIGNING_IPC_DEFAULT;
         /* make sure the vars that get altered (4th field) are in
 …
+        }
+        signing_state = get_cmdline_auth_info_signing_state(rpcclient_auth_info);
+        switch (signing_state) {
+        case SMB_SIGNING_OFF:
+                lp_set_cmdline("client ipc signing", "no");
+                break;
+        case SMB_SIGNING_REQUIRED:
+                lp_set_cmdline("client ipc signing", "required");
+                break;
+        }
         if (get_cmdline_auth_info_use_kerberos(rpcclient_auth_info)) {
                 flags |= CLI_FULL_CONNECTION_USE_KERBEROS |
 …
         if (get_cmdline_auth_info_use_ccache(rpcclient_auth_info)) {
                 flags |= CLI_FULL_CONNECTION_USE_CCACHE;
+        }
+        if (get_cmdline_auth_info_use_pw_nt_hash(rpcclient_auth_info)) {
+                flags |= CLI_FULL_CONNECTION_USE_NT_HASH;
+        }
 …
                                         get_cmdline_auth_info_password(rpcclient_auth_info),
                                         flags,
                                         get_cmdline_auth_info_signing_state(rpcclient_auth_info));
+                                        SMB_SIGNING_IPC_DEFAULT);
         if (!NT_STATUS_IS_OK(nt_status)) {

vendor/current/source3/script/tests/test_dfree_quota.sh

-              r988
+              r989
 if [ $# -lt 6 ]; then
 cat <<EOF
 Usage: test_dfree_quota.sh SERVER DOMAIN USERNAME PASSWORD LOCAL_PATH SMBCLIENT SMBCQUOTAS
+Usage: test_dfree_quota.sh SERVER DOMAIN USERNAME PASSWORD LOCAL_PATH SMBCLIENT SMBCQUOTAS SMBCACLS
 EOF
 exit 1;
 …
 smbclient=$6
 smbcquotas=$7
+shift 7
+smbcacls=$8
+shift 8
 failed=0
 …
     uid=$(id -u $USERNAME)
     gid=$(id -g $USERNAME)
+    uid1=$(id -u user1)
+    uid2=$(id -u user2)
 cat <<ABC
 conf1:df:block size = 512:disk free = 10:disk size = 20
 …
 trygrp2:u$uid:block size = 4096:hard limit = 0:soft limit = 0:cur blocks = 41
 trygrp2:g$gid:block size = 4096:hard limit = 60:soft limit = 60:cur blocks = 56
+notenforce:df:block size = 4096:disk free = 10:disk size = 80
+notenforce:u$uid:block size = 4096:hard limit = 40:soft limit = 40:cur blocks = 37
+notenforce:udflt:block size = 4096:qflags = 0
+nfs:df:block size = 4096:disk free = 10:disk size = 80
+nfs:u$uid:block size = 4096:hard limit = 40:soft limit = 40:cur blocks = 37
+nfs:udflt:nosys = 1
+confdfqp:df:block size = 4096:disk free = 10:disk size = 80
+confdfqp:u$uid1:block size = 4096:hard limit = 40:soft limit = 40:cur blocks = 36
+confdfqp:u$uid2:block size = 4096:hard limit = 41:soft limit = 41:cur blocks = 36
 ABC
+}
 …
 test_smbclient_dfree() {
         name="$1"
+        dir="$2"
+    confs="$3"
+    expected="$4"
+        shift
+    share="$2"
+    dir="$3"
+    confs="$4"
+    expected="$5"
+    shift
     shift
     shift
 …
     subunit_start_test "$name"
     setup_conf $confs
         output=$($VALGRIND $smbclient //$SERVER/dfq -c "cd $dir; l" $@ 2>&1)
+    output=$($VALGRIND $smbclient //$SERVER/$share -c "cd $dir; l" $@ 2>&1)
     status=$?
     if [ "$status" = "0" ]; then
 …
 #basic disk-free tests
 test_smbclient_dfree "Test dfree share root SMB3 no quota" "." "conf1 ." "10 1024. 5" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 test_smbclient_dfree "Test dfree subdir SMB3 no quota" "subdir1" "conf1 . conf2 subdir1" "20 1024. 10" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 test_smbclient_dfree "Test dfree subdir NT1 no quota" "subdir1" "conf1 . conf2 subdir1" "10 1024. 5" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=NT1 || failed=`expr $failed + 1`
 test_smbclient_dfree "Test large disk" "." "conf3 ." "1125899906842624 1024. 3000" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree share root SMB3 no quota" dfq "." "conf1 ." "10 1024. 5" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree subdir SMB3 no quota" dfq "subdir1" "conf1 . conf2 subdir1" "20 1024. 10" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree subdir NT1 no quota" dfq "subdir1" "conf1 . conf2 subdir1" "10 1024. 5" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=NT1 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test large disk" dfq "." "conf3 ." "1125899906842624 1024. 3000" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 #basic quota test (SMB1 only)
 test_smbcquotas "Test user quota" confq1 $USERNAME "40960/4096000/3072000" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=NT1 || failed=`expr $failed + 1`
 #quota limit > disk size, remaining quota > disk free
 test_smbclient_dfree "Test dfree share root df vs quota case 1" "." "confdfq1 ." "80 1024. 40" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree share root df vs quota case 1" dfq "." "confdfq1 ." "80 1024. 40" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 #quota limit > disk size, remaining quota < disk free
 test_smbclient_dfree "Test dfree share root df vs quota case 2" "." "confdfq2 ." "80 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree share root df vs quota case 2" dfq "." "confdfq2 ." "80 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 #quota limit < disk size, remaining quota > disk free
 test_smbclient_dfree "Test dfree share root df vs quota case 3" "." "confdfq3 ." "160 1024. 40" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree share root df vs quota case 3" dfq "." "confdfq3 ." "160 1024. 40" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 #quota limit < disk size, remaining quota < disk free
 test_smbclient_dfree "Test dfree share root df vs quota case 4" "." "confdfq4 ." "160 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 test_smbclient_dfree "Test dfree subdir df vs quota case 4" "subdir1" "confdfq4 subdir1" "160 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree share root df vs quota case 4" dfq "." "confdfq4 ." "160 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree subdir df vs quota case 4" dfq "subdir1" "confdfq4 subdir1" "160 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 #quota-->disk free special cases
+test_smbclient_dfree "Test quota->dfree edquot" "subdir1" "edquot subdir1" "164 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree soft limit" "subdir1" "slimit subdir1" "168 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree hard limit" "subdir1" "hlimit subdir1" "180 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree inode soft limit" "subdir1" "islimit subdir1" "148 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree inode hard limit" "subdir1" "ihlimit subdir1" "148 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree err try group" "subdir1" "trygrp1 subdir1" "240 1024. 20" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree no-quota try group" "subdir1" "trygrp2 subdir1" "240 1024. 16" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree edquot" dfq "subdir1" "edquot subdir1" "164 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree soft limit" dfq "subdir1" "slimit subdir1" "168 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree hard limit" dfq "subdir1" "hlimit subdir1" "180 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree inode soft limit" dfq "subdir1" "islimit subdir1" "148 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree inode hard limit" dfq "subdir1" "ihlimit subdir1" "148 1024. 0" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree err try group" dfq "subdir1" "trygrp1 subdir1" "240 1024. 20" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test quota->dfree no-quota try group" dfq "subdir1" "trygrp2 subdir1" "240 1024. 16" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+#quota configured but not enforced
+test_smbclient_dfree "Test dfree share root quota not enforced" dfq "." "notenforce ." "320 1024. 40" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+#FS quota not implemented (NFS case)
+test_smbclient_dfree "Test dfree share root FS quota not implemented" dfq "." "nfs ." "160 1024. 12" -U$USERNAME%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+#test for dfree when owner is inherited
+#setup two folders with different owners
+rm -rf $WORKDIR/subdir3/*
+for d in / subdir3
+do
+    $VALGRIND $smbcacls -U$USERNAME%$PASSWORD -D "ACL:$SERVER\user1:ALLOWED/0x0/FULL" //$SERVER/dfq $d > /dev/null 2>&1
+    $VALGRIND $smbcacls -U$USERNAME%$PASSWORD -a "ACL:$SERVER\user1:ALLOWED/0x0/FULL" //$SERVER/dfq $d || failed=`expr $failed + 1`
+    $VALGRIND $smbcacls -U$USERNAME%$PASSWORD -D "ACL:$SERVER\user2:ALLOWED/0x0/FULL" //$SERVER/dfq $d > /dev/null 2>&1
+    $VALGRIND $smbcacls -U$USERNAME%$PASSWORD -a "ACL:$SERVER\user2:ALLOWED/0x0/FULL" //$SERVER/dfq $d || failed=`expr $failed + 1`
+done
+$VALGRIND $smbclient //$SERVER/dfq -c "cd subdir3; mkdir user1" -Uuser1%$PASSWORD --option=clientmaxprotocol=SMB3 > /dev/null 2>&1 || failed=`expr $failed + 1`
+$VALGRIND $smbclient //$SERVER/dfq -c "cd subdir3; mkdir user2" -Uuser2%$PASSWORD --option=clientmaxprotocol=SMB3 > /dev/null 2>&1 || failed=`expr $failed + 1`
+#test quotas
+test_smbclient_dfree "Test dfree without inherit owner - user1 at user1" \
+    dfq "subdir3/user1" "confdfqp subdir3/user1 confdfqp subdir3/user2" "160 1024. 16" \
+    -Uuser1%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree without inherit owner - user1 at user2" \
+    dfq "subdir3/user2" "confdfqp subdir3/user1 confdfqp subdir3/user2" "160 1024. 16" \
+    -Uuser1%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree with inherit owner - user1 at user1" \
+    dfq_owner "subdir3/user1" "confdfqp subdir3/user1 confdfqp subdir3/user2" "160 1024. 16" \
+    -Uuser1%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
+test_smbclient_dfree "Test dfree with inherit owner - user1 at user2" \
+    dfq_owner "subdir3/user2" "confdfqp subdir3/user1 confdfqp subdir3/user2" "164 1024. 20" \
+    -Uuser1%$PASSWORD --option=clientmaxprotocol=SMB3 || failed=`expr $failed + 1`
 setup_conf

vendor/current/source3/script/tests/test_shadow_copy.sh

-              r988
+              r989
     local version
     local destdir
+    local content
     rootdir=$1
     prefix=$2
     version=$3
+    content=$4
     if [ -n "$prefix" ] ; then
         destdir=$rootdir/$prefix
 …
         # for non-snapshot version, create legit files
         # so that wide-link checks focus on snapshot files
         touch $destdir/foo
+        echo "$content" > $destdir/foo
         mkdir -p $destdir/bar
         touch $destdir/bar/baz
         touch $destdir/bar/lfoo
         touch $destdir/bar/letcpasswd
         touch $destdir/bar/loutside
+        echo "$content" > $destdir/bar/baz
+        echo "$content" > $destdir/bar/lfoo
+        echo "$content" > $destdir/bar/letcpasswd
+        echo "$content" > $destdir/bar/loutside
     elif [ "$version" = "fullsnap" ] ; then
         #snapshot files
         touch $destdir/foo
+        echo "$content" > $destdir/foo
         mkdir -p $destdir/bar
         touch $destdir/bar/baz
+        echo "$content" > $destdir/bar/baz
         ln -fs ../foo $destdir/bar/lfoo
         ln -fs /etc/passwd $destdir/bar/letcpasswd
         ln -fs ../../outside $destdir/bar/loutside
         touch `dirname $destdir`/outside
+        echo "$content" > `dirname $destdir`/outside
     else #subshare snapshot - at bar
         touch $destdir/baz
+        echo "$content" > $destdir/baz
         ln -fs ../foo $destdir/lfoo
         ln -fs /etc/passwd $destdir/letcpasswd
         ln -fs ../../outside $destdir/loutside
         touch `dirname $destdir`/../outside
+        echo "$content" > `dirname $destdir`/../outside
     fi
 …
         snapname=${SNAPSHOTS[$i]}
         mkdir $snapdir/$snapname
         build_files $snapdir/$snapname "$prefix" $version
+        build_files $snapdir/$snapname "$prefix" $version "$snapname"
     done
+}
 …
     local path
     local expected_count
+    local skip_content
     local versions
+    local tstamps
+    local tstamp
+    local content
+    local is_dir
     share=$1
     path=$2
     expected_count=$3
+    skip_content=$4
     versions=`$SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "allinfo $path" | grep "^create_time:" | wc -l`
+    if [ "$versions" = "$expected_count" ] ; then
+        true
+    else
+    if [ "$versions" != "$expected_count" ] ; then
         echo "expected $expected_count versions of $path, got $versions"
+        false
+    fi
+        return 1
+    fi
+    is_dir=0
+    $SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "allinfo $path" | grep "^attributes:.*D" && is_dir=1
+    if [ $is_dir = 1 ] ; then
+        skip_content=1
+    fi
+    #readable snapshots
+    tstamps=`$SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "allinfo $path" | awk '/^@GMT-/ {snapshot=$1} /^create_time:/ {printf "%s\n", snapshot}'`
+    for tstamp in $tstamps ; do
+        if [ $is_dir = 0 ] ;
+        then
+            if ! $SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "get $tstamp\\$path $WORKDIR/foo" ; then
+                echo "Failed getting \\\\$SERVER\\$share\\$tstamp\\$path"
+                return 1
+            fi
+        else
+            if ! $SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "ls $tstamp\\$path\\*" ; then
+                echo "Failed listing \\\\$SERVER\\$share\\$tstamp\\$path"
+                return 1
+            fi
+        fi
+        #also check the content, but not for wide links
+        if [ "x$skip_content" != "x1" ] ; then
+            content=`cat $WORKDIR/foo`
+            if [ "$content" != "$tstamp" ] ; then
+                echo "incorrect content of \\\\$SERVER\\$share\\$tstamp\\$path expected [$tstamp]  got [$content]"
+                return 1
+            fi
+        fi
+    done
+    #non-readable snapshots
+    tstamps=`$SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "allinfo $path" | \
+        awk '/^@GMT-/ {if (snapshot!=""){printf "%s\n", snapshot} ; snapshot=$1} /^create_time:/ {snapshot=""} END {if (snapshot!=""){printf "%s\n", snapshot}}'`
+    for tstamp in $tstamps ; do
+        if [ $is_dir = 0 ] ;
+        then
+            if $SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "get $tstamp\\$path $WORKDIR/foo" ; then
+                echo "Unexpected success getting \\\\$SERVER\\$share\\$tstamp\\$path"
+                return 1
+            fi
+        else
+            if $SMBCLIENT -U$USERNAME%$PASSWORD "//$SERVER/$share" -I $SERVER_IP -c "ls $tstamp\\$path\\*" ; then
+                echo "Unexpected success listing \\\\$SERVER\\$share\\$tstamp\\$path"
+                return 1
+            fi
+        fi
+    done
+}
 …
     testit "$msg - abs symlink outside" \
         test_count_versions $share bar/letcpasswd $ncopies_blocked || \
+        test_count_versions $share bar/letcpasswd $ncopies_blocked  1 || \
         failed=`expr $failed + 1`
     testit "$msg - rel symlink outside" \
+        test_count_versions $share bar/loutside $ncopies_blocked || \
+        test_count_versions $share bar/loutside $ncopies_blocked 1 || \
+        failed=`expr $failed + 1`
+    testit "$msg - list directory" \
+        test_count_versions $share bar $ncopies_allowed || \
         failed=`expr $failed + 1`
+}
 …
 #build "latest" files
 build_files $WORKDIR/mount base/share "latest"
+build_files $WORKDIR/mount base/share "latest" "latest"
 failed=0

vendor/current/source3/script/tests/test_smbclient_ntlm.sh

-              r988
+              r989
         testit "smbclient baduser.badpassword.NT1NEW.guest" $SMBCLIENT //$SERVER/IPC\$ $CONFIGURATION -Ubaduser%badpassword -mNT1 -c quit $ADDARGS
         testit "smbclient baduser.badpassword.SMB3.guest" $SMBCLIENT //$SERVER/IPC\$ $CONFIGURATION -Ubaduser%badpassword -mSMB3 -c quit $ADDARGS
+        testit_expect_failure "smbclient baduser.badpassword.NT1OLD.signfail" $SMBCLIENT //$SERVER/IPC\$ $CONFIGURATION -Ubaduser%badpassword -mNT1 --option=clientusespnego=no --option=clientntlmv2auth=no --signing=required -c quit $ADDARGS
+        testit_expect_failure "smbclient baduser.badpassword.NT1NEW.signfail" $SMBCLIENT //$SERVER/IPC\$ $CONFIGURATION -Ubaduser%badpassword -mNT1 --signing=required -c quit $ADDARGS
+        testit_expect_failure "smbclient baduser.badpassword.SMB3.signfail" $SMBCLIENT //$SERVER/IPC\$ $CONFIGURATION -Ubaduser%badpassword -mSMB3 --signing=required -c quit $ADDARGS
 fi

vendor/current/source3/selftest/tests.py

-              r988
+              r989
     plantestsuite("samba3.blackbox.preserve_case (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_preserve_case.sh"), '$SERVER', '$DOMAIN', '$USERNAME', '$PASSWORD', '$PREFIX', smbclient3])
     plantestsuite("samba3.blackbox.dfree_command (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_dfree_command.sh"), '$SERVER', '$DOMAIN', '$USERNAME', '$PASSWORD', '$PREFIX', smbclient3])
     plantestsuite("samba3.blackbox.dfree_quota (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_dfree_quota.sh"), '$SERVER', '$DOMAIN', '$USERNAME', '$PASSWORD', '$LOCAL_PATH', smbclient3, smbcquotas])
+    plantestsuite("samba3.blackbox.dfree_quota (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_dfree_quota.sh"), '$SERVER', '$DOMAIN', '$USERNAME', '$PASSWORD', '$LOCAL_PATH', smbclient3, smbcquotas, smbcacls])
     plantestsuite("samba3.blackbox.valid_users (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_valid_users.sh"), '$SERVER', '$SERVER_IP', '$DOMAIN', '$USERNAME', '$PASSWORD', '$PREFIX', smbclient3])
     plantestsuite("samba3.blackbox.offline (%s)" % env, env, [os.path.join(samba3srcdir, "script/tests/test_offline.sh"), '$SERVER', '$SERVER_IP', '$DOMAIN', '$USERNAME', '$PASSWORD', '$LOCAL_PATH/offline', smbclient3])
 …
 local = ["local.nss", "local.ndr"]
 idmap = [ "idmap.rfc2307" ]
+idmap = ["idmap.rfc2307", "idmap.alloc"]
 rap = ["rap.basic", "rap.rpc", "rap.printing", "rap.sam"]
 …
 libsmbclient = ["libsmbclient"]
 vfs = ["vfs.fruit"]
+vfs = ["vfs.fruit", "vfs.acl_xattr"]
 tests= base + raw + smb2 + rpc + unix + local + rap + nbt + libsmbclient + idmap + vfs
 …
     elif t == "idmap.rfc2307":
         plantestsuite(t, "ad_member_rfc2307", [os.path.join(samba3srcdir, "../nsswitch/tests/test_idmap_rfc2307.sh"), '$DOMAIN', 'Administrator', '2000000', 'Guest', '2000001', '"Domain Users"', '2000002', 'DnsAdmins', '2000003', 'ou=idmap,dc=samba,dc=example,dc=com', '$DC_SERVER', '$DC_USERNAME', '$DC_PASSWORD'])
+    elif t == "idmap.alloc":
+        plantestsuite(t, "ad_member_rfc2307", [os.path.join(samba3srcdir, "../nsswitch/tests/test_idmap_nss.sh"), '$DOMAIN'])
     elif t == "raw.acls":
         plansmbtorture4testsuite(t, "nt4_dc", '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD')
 …
         plansmbtorture4testsuite(t, "nt4_dc", '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD --signing=required')
         plansmbtorture4testsuite(t, "ad_dc", '//$SERVER/tmp -U$USERNAME%$PASSWORD --signing=required')
+    elif t == "smb2.dosmode":
+        plansmbtorture4testsuite(t, "simpleserver", '//$SERVER/dosmode -U$USERNAME%$PASSWORD')
+    elif t == "vfs.acl_xattr":
+        plansmbtorture4testsuite(t, "nt4_dc", '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD')
     else:
         plansmbtorture4testsuite(t, "nt4_dc", '//$SERVER_IP/tmp -U$USERNAME%$PASSWORD')
 …
                os.path.join(bindir(), "rpcclient"), "tmp"])
+plantestsuite("samba3.blackbox.rpcclient.pw-nt-hash", "simpleserver",
+              [os.path.join(samba3srcdir, "script/tests/test_rpcclient_pw_nt_hash.sh"),
+               "$USERNAME", "$PASSWORD", "$SERVER",
+               os.path.join(bindir(), "rpcclient")])
 options_list = ["", "-e"]
 for options in options_list:

vendor/current/source3/smbd/aio.c

-              r988
+              r989
         int outsize;
         char *outbuf = (char *)aio_ex->outbuf.data;
-        char *data = smb_buf(outbuf) + 1 /* padding byte */;
         ssize_t nread;
         int err;
 …
                 outsize = srv_set_message(outbuf,0,0,true);
         } else {
+                outsize = srv_set_message(outbuf, 12,
+                                          nread + 1 /* padding byte */, false);
+                SSVAL(outbuf,smb_vwv2, 0xFFFF); /* Remaining - must be * -1. */
+                SSVAL(outbuf,smb_vwv5, nread);
+                SSVAL(outbuf,smb_vwv6, smb_offset(data,outbuf));
+                SSVAL(outbuf,smb_vwv7, ((nread >> 16) & 1));
+                SSVAL(smb_buf(outbuf), -2, nread);
+                outsize = setup_readX_header(outbuf, nread);
                 aio_ex->fsp->fh->pos = aio_ex->offset + nread;

vendor/current/source3/smbd/close.c

-              r988
+              r989
         TALLOC_CTX *frame = talloc_stackframe();
         NTSTATUS status;
+        bool saved_posix_pathnames;
         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
 …
                 return NT_STATUS_OK;
+        }
+        /*
+         * Any stream names *must* be treated as Windows
+         * pathnames, even if we're using UNIX extensions.
+         */
+        saved_posix_pathnames = lp_set_posix_pathnames(false);
         for (i=0; i<num_streams; i++) {
 …
  fail:
+        (void)lp_set_posix_pathnames(saved_posix_pathnames);
         TALLOC_FREE(frame);
         return status;
 …
         bool got_tokens = false;
         bool normal_close;
-        int ret_flock;
         /* Ensure any pending write time updates are done. */
 …
                           "lock for file %s\n", fsp_str_dbg(fsp)));
                 return NT_STATUS_INVALID_PARAMETER;
+        }
+        /* Remove the oplock before potentially deleting the file. */
+        if(fsp->oplock_type) {
+                remove_oplock_under_lock(fsp, lck);
+        }
 …
+        }
+        /* remove filesystem sharemodes */
+        ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, 0, 0);
+        if (ret_flock == -1) {
+                DEBUG(2, ("close_remove_share_mode: removing kernel flock for "
+                                        "%s failed: %s\n", fsp_str_dbg(fsp),
+                                        strerror(errno)));
+        if (fsp->kernel_share_modes_taken) {
+                int ret_flock;
+                /* remove filesystem sharemodes */
+                ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, 0, 0);
+                if (ret_flock == -1) {
+                        DEBUG(2, ("close_remove_share_mode: removing kernel "
+                                  "flock for %s failed: %s\n",
+                                  fsp_str_dbg(fsp), strerror(errno)));
+                }
+        }
 …
                 file_free(req, fsp);
                 return NT_STATUS_OK;
+        }
-        /* Remove the oplock before potentially deleting the file. */
-        if(fsp->oplock_type) {
-                remove_oplock(fsp);
+        }

vendor/current/source3/smbd/dfree.c

-              r988
+              r989
 ****************************************************************************/
 uint64_t sys_disk_free(connection_struct *conn, const char *path,
+uint64_t sys_disk_free(connection_struct *conn, struct smb_filename *fname,
                        uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
 …
         const char *dfree_command;
         static bool dfree_broken = false;
+        const char *path = fname->base_name;
         (*dfree) = (*dsize) = 0;
 …
+        }
         if (disk_quotas(conn, path, &bsize_q, &dfree_q, &dsize_q)) {
+        if (disk_quotas(conn, fname, &bsize_q, &dfree_q, &dsize_q)) {
                 uint64_t min_bsize = MIN(*bsize, bsize_q);
 …
 ****************************************************************************/
+uint64_t get_dfree_info(connection_struct *conn,
+                        const char *path,
+                        uint64_t *bsize,
+                        uint64_t *dfree,
+                        uint64_t *dsize)
+uint64_t get_dfree_info(connection_struct *conn, struct smb_filename *fname,
+                        uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
         int dfree_cache_time = lp_dfree_cache_time(SNUM(conn));
 …
         if (!dfree_cache_time) {
                 return sys_disk_free(conn, path, bsize, dfree, dsize);
+                return sys_disk_free(conn, fname, bsize, dfree, dsize);
+        }
 …
+        }
         dfree_ret = sys_disk_free(conn, path, bsize, dfree, dsize);
+        dfree_ret = sys_disk_free(conn, fname, bsize, dfree, dsize);
         if (dfree_ret == (uint64_t)-1) {

vendor/current/source3/smbd/dosmode.c

-              r988
+              r989
 ****************************************************************************/
 static bool get_ea_dos_attribute(connection_struct *conn,
                                  struct smb_filename *smb_fname,
                                  uint32_t *pattr)
+bool get_ea_dos_attribute(connection_struct *conn,
+                          struct smb_filename *smb_fname,
+                          uint32_t *pattr)
+{
         struct xattr_DOSATTRIB dosattrib;
 …
+}
+static uint32_t dos_mode_from_name(connection_struct *conn,
+                                   const struct smb_filename *smb_fname,
+                                   uint32_t dosmode)
+{
+        const char *p = NULL;
+        uint32_t result = dosmode;
+        if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
+            lp_hide_dot_files(SNUM(conn)))
+        {
+                p = strrchr_m(smb_fname->base_name, '/');
+                if (p) {
+                        p++;
+                } else {
+                        p = smb_fname->base_name;
+                }
+                /* Only . and .. are not hidden. */
+                if ((p[0] == '.') &&
+                    !((p[1] == '\0') || (p[1] == '.' && p[2] == '\0')))
+                {
+                        result |= FILE_ATTRIBUTE_HIDDEN;
+                }
+        }
+        if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
+            IS_HIDDEN_PATH(conn, smb_fname->base_name))
+        {
+                result |= FILE_ATTRIBUTE_HIDDEN;
+        }
+        return result;
+}
 /****************************************************************************
  Change a unix mode to a dos mode.
 …
         if (!VALID_STAT(smb_fname->st)) {
                 return 0;
+        }
-        /* First do any modifications that depend on the path name. */
-        /* hide files with a name starting with a . */
-        if (lp_hide_dot_files(SNUM(conn))) {
-                const char *p = strrchr_m(smb_fname->base_name,'/');
-                if (p) {
-                        p++;
-                } else {
-                        p = smb_fname->base_name;
+                }
-                /* Only . and .. are not hidden. */
-                if (p[0] == '.' && !((p[1] == '\0') ||
-                                (p[1] == '.' && p[2] == '\0'))) {
-                        result |= FILE_ATTRIBUTE_HIDDEN;
+                }
+        }
 …
+        }
+        /* Optimization : Only call is_hidden_path if it's not already
+           hidden. */
+        if (!(result & FILE_ATTRIBUTE_HIDDEN) &&
+            IS_HIDDEN_PATH(conn, smb_fname->base_name)) {
+                result |= FILE_ATTRIBUTE_HIDDEN;
+        }
+        result |= dos_mode_from_name(conn, smb_fname, result);
         if (result == 0) {
+                result = FILE_ATTRIBUTE_NORMAL;
+                if (S_ISDIR(smb_fname->st.st_ex_mode)) {
+                        result = FILE_ATTRIBUTE_DIRECTORY;
+                } else {
+                        result = FILE_ATTRIBUTE_NORMAL;
+                }
+        }

vendor/current/source3/smbd/filename.c

-              r988
+              r989
                         TALLOC_FREE(found_name);
                 } /* end else */
-#ifdef DEVELOPER
-                /*
-                 * This sucks!
-                 * We should never provide different behaviors
-                 * depending on DEVELOPER!!!
-                 */
-                if (VALID_STAT(smb_fname->st)) {
-                        bool delete_pending;
-                        uint32_t name_hash;
-                        status = file_name_hash(conn,
-                                        smb_fname_str_dbg(smb_fname),
-                                        &name_hash);
-                        if (!NT_STATUS_IS_OK(status)) {
-                                goto fail;
+                        }
-                        get_file_infos(vfs_file_id_from_sbuf(conn,
-                                                             &smb_fname->st),
-                                       name_hash,
-                                       &delete_pending, NULL);
-                        if (delete_pending) {
-                                status = NT_STATUS_DELETE_PENDING;
-                                goto fail;
+                        }
+                }
-#endif
                 /*

vendor/current/source3/smbd/globals.h

-              r988
+              r989
         /*
+         * Keep track of whether the outstanding request counters
+         * had been updated in dispatch, so that they need to be
+         * adapted again in reply.
+         */
+        bool request_counters_updated;
+        /*
          * The sub request for async backend calls.
          * This is used for SMB2 Cancel.

vendor/current/source3/smbd/notifyd/notifyd.c

-              r988
+              r989
         size_t i;
+        dbwrap_traverse_read(p->db, notifyd_db_del_syswatches, NULL, NULL);
+        if (p->db != NULL) {
+                dbwrap_traverse_read(p->db, notifyd_db_del_syswatches,
+                                     NULL, NULL);
+        }
         for (i = 0; i<state->num_peers; i++) {

vendor/current/source3/smbd/open.c

-              r988
+              r989
+                }
+                if (local_flags & O_NONBLOCK) {
+                        /*
+                         * GPFS can return ETIMEDOUT for pread on
+                         * nonblocking file descriptors when files
+                         * migrated to tape need to be recalled. I
+                         * could imagine this happens elsehwere
+                         * too. With blocking file descriptors this
+                         * does not happen.
+                         */
+                        ret = set_blocking(fsp->fh->fd, true);
+                        if (ret == -1) {
+                                status = map_nt_error_from_unix(errno);
+                                DBG_WARNING("Could not set fd to blocking: "
+                                            "%s\n", strerror(errno));
+                                fd_close(fsp);
+                                return status;
+                        }
+                }
                 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
                 if (ret == -1) {
 …
                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
                 if (file_existed) {
+                        existing_dos_attributes = dos_mode(conn, smb_fname);
+                        /*
+                         * Only use strored DOS attributes for checks
+                         * against requested attributes (below via
+                         * open_match_attributes()), cf bug #11992
+                         * for details. -slow
+                         */
+                        bool ok;
+                        uint32_t attr = 0;
+                        ok = get_ea_dos_attribute(conn, smb_fname, &attr);
+                        if (ok) {
+                                existing_dos_attributes = attr;
+                        }
+                }
+        }
 …
                         return NT_STATUS_SHARING_VIOLATION;
+                }
+                fsp->kernel_share_modes_taken = true;
+        }
 …
         TALLOC_CTX *frame = talloc_stackframe();
         NTSTATUS status;
+        bool saved_posix_pathnames;
         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
 …
                 goto fail;
+        }
+        /*
+         * Any stream names *must* be treated as Windows
+         * pathnames, even if we're using UNIX extensions.
+         */
+        saved_posix_pathnames = lp_set_posix_pathnames(false);
         for (i=0; i<num_streams; i++) {
 …
  fail:
+        (void)lp_set_posix_pathnames(saved_posix_pathnames);
         TALLOC_FREE(frame);
         return status;

vendor/current/source3/smbd/oplock.c

-              r988
+              r989
                  * If we're the only one, we don't need a brlock entry
                  */
+                remove_stale_share_mode_entries(d);
                 SMB_ASSERT(d->num_share_modes == 1);
                 SMB_ASSERT(EXCLUSIVE_OPLOCK_TYPE(d->share_modes[0].op_type));
 …
         TALLOC_FREE(br_lck);
         return true;
+}
+/****************************************************************************
+ Remove a file oplock with lock already held. Copes with level II and exclusive.
+****************************************************************************/
+bool remove_oplock_under_lock(files_struct *fsp, struct share_mode_lock *lck)
+{
+        bool ret;
+        ret = remove_share_oplock(lck, fsp);
+        if (!ret) {
+                DBG_ERR("failed to remove share oplock for "
+                        "file %s, %s, %s\n",
+                        fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                        file_id_string_tos(&fsp->file_id));
+        }
+        release_file_oplock(fsp);
+        ret = update_num_read_oplocks(fsp, lck);
+        if (!ret) {
+                DBG_ERR("update_num_read_oplocks failed for "
+                        "file %s, %s, %s\n",
+                        fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                        file_id_string_tos(&fsp->file_id));
+        }
+        return ret;
+}
 …
         struct share_mode_lock *lck;
+        DEBUG(10, ("remove_oplock called for %s\n",
+                   fsp_str_dbg(fsp)));
+        DBG_DEBUG("remove_oplock called for %s\n", fsp_str_dbg(fsp));
         /* Remove the oplock flag from the sharemode. */
         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
         if (lck == NULL) {
+                DEBUG(0,("remove_oplock: failed to lock share entry for "
+                         "file %s\n", fsp_str_dbg(fsp)));
+                return False;
+        }
+        ret = remove_share_oplock(lck, fsp);
+        if (!ret) {
+                DEBUG(0,("remove_oplock: failed to remove share oplock for "
+                         "file %s, %s, %s\n",
+                         fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                         file_id_string_tos(&fsp->file_id)));
+        }
+        release_file_oplock(fsp);
+        ret = update_num_read_oplocks(fsp, lck);
+        if (!ret) {
+                DEBUG(0, ("%s: update_num_read_oplocks failed for "
+                         "file %s, %s, %s\n",
+                          __func__, fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                         file_id_string_tos(&fsp->file_id)));
+        }
+                DBG_ERR("failed to lock share entry for "
+                         "file %s\n", fsp_str_dbg(fsp));
+                return false;
+        }
+        ret = remove_oplock_under_lock(fsp, lck);
         TALLOC_FREE(lck);

vendor/current/source3/smbd/pipes.c

r988	r989
493	493	+ 2 /* the buflen field */
494	494	+ 1); /* padding byte */
495		~~SSVAL(req->outbuf,smb_vwv11,state->smb_maxcnt);~~
496	495
497	496	DEBUG(3,("readX-IPC min=%d max=%d nread=%d\n",

vendor/current/source3/smbd/posix_acls.c

-              r988
+              r989
+}
-/* Stolen shamelessly from pvfs_default_acl() in source4 :-). */
-NTSTATUS make_default_filesystem_acl(TALLOC_CTX *ctx,
-                                        const char *name,
-                                        SMB_STRUCT_STAT *psbuf,
-                                        struct security_descriptor **ppdesc)
+{
-        struct dom_sid owner_sid, group_sid;
-        size_t size = 0;
-        struct security_ace aces[4];
-        uint32_t access_mask = 0;
-        mode_t mode = psbuf->st_ex_mode;
-        struct security_acl *new_dacl = NULL;
-        int idx = 0;
-        DEBUG(10,("make_default_filesystem_acl: file %s mode = 0%o\n",
-                name, (int)mode ));
-        uid_to_sid(&owner_sid, psbuf->st_ex_uid);
-        gid_to_sid(&group_sid, psbuf->st_ex_gid);
-        /*
-         We provide up to 4 ACEs
-                - Owner
-                - Group
-                - Everyone
-                - NT System
-        */
-        if (mode & S_IRUSR) {
-                if (mode & S_IWUSR) {
-                        access_mask |= SEC_RIGHTS_FILE_ALL;
-                } else {
-                        access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+                }
+        }
-        if (mode & S_IWUSR) {
-                access_mask |= SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
+        }
-        init_sec_ace(&aces[idx],
-                        &owner_sid,
-                        SEC_ACE_TYPE_ACCESS_ALLOWED,
-                        access_mask,
-);
-        idx++;
-        access_mask = 0;
-        if (mode & S_IRGRP) {
-                access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+        }
-        if (mode & S_IWGRP) {
-                /* note that delete is not granted - this matches posix behaviour */
-                access_mask |= SEC_RIGHTS_FILE_WRITE;
+        }
-        if (access_mask) {
-                init_sec_ace(&aces[idx],
-                        &group_sid,
-                        SEC_ACE_TYPE_ACCESS_ALLOWED,
-                        access_mask,
-);
-                idx++;
+        }
-        access_mask = 0;
-        if (mode & S_IROTH) {
-                access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
+        }
-        if (mode & S_IWOTH) {
-                access_mask |= SEC_RIGHTS_FILE_WRITE;
+        }
-        if (access_mask) {
-                init_sec_ace(&aces[idx],
-                        &global_sid_World,
-                        SEC_ACE_TYPE_ACCESS_ALLOWED,
-                        access_mask,
-);
-                idx++;
+        }
-        init_sec_ace(&aces[idx],
-                        &global_sid_System,
-                        SEC_ACE_TYPE_ACCESS_ALLOWED,
-                        SEC_RIGHTS_FILE_ALL,
-);
-        idx++;
-        new_dacl = make_sec_acl(ctx,
-                        NT4_ACL_REVISION,
-                        idx,
-                        aces);
-        if (!new_dacl) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        *ppdesc = make_sec_desc(ctx,
-                        SECURITY_DESCRIPTOR_REVISION_1,
-                        SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
-                        &owner_sid,
-                        &group_sid,
-                        NULL,
-                        new_dacl,
-                        &size);
-        if (!*ppdesc) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        return NT_STATUS_OK;
+}
 int posix_sys_acl_blob_get_file(vfs_handle_struct *handle,
                                 const char *path_p,

vendor/current/source3/smbd/process.c

-              r988
+              r989
         state->xconn = xconn;
         state->parent_pipe = parent_pipe;
         state->ev = s3_tevent_context_init(state);
+        state->ev = samba_tevent_context_init(state);
         if (state->ev == NULL) {
                 DEBUG(1, ("tevent_context_init failed\n"));
+                DEBUG(1, ("samba_tevent_context_init failed\n"));
                 TALLOC_FREE(state);
                 return;

vendor/current/source3/smbd/proto.h

-              r988
+              r989
 /* The following definitions come from smbd/dfree.c  */
+uint64_t sys_disk_free(connection_struct *conn, const char *path,
+                              uint64_t *bsize,uint64_t *dfree,uint64_t *dsize);
+uint64_t get_dfree_info(connection_struct *conn,
+                        const char *path,
+                        uint64_t *bsize,
+                        uint64_t *dfree,
+                        uint64_t *dsize);
+uint64_t sys_disk_free(connection_struct *conn, struct smb_filename *fname,
+                       uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
+uint64_t get_dfree_info(connection_struct *conn, struct smb_filename *fname,
+                        uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
 /* The following definitions come from smbd/dir.c  */
 …
 int file_set_dosmode(connection_struct *conn, struct smb_filename *smb_fname,
                      uint32_t dosmode, const char *parent_dir, bool newfile);
+bool get_ea_dos_attribute(connection_struct *conn,
+                          struct smb_filename *smb_fname,
+                          uint32_t *pattr);
 NTSTATUS file_set_sparse(connection_struct *conn,
                          struct files_struct *fsp,
 …
 void break_kernel_oplock(struct messaging_context *msg_ctx, files_struct *fsp);
 NTSTATUS set_file_oplock(files_struct *fsp);
+bool remove_oplock_under_lock(files_struct *fsp, struct share_mode_lock *lck);
 bool remove_oplock(files_struct *fsp);
 bool downgrade_oplock(files_struct *fsp);
 …
                              uint32_t security_info_wanted,
                              struct security_descriptor **sd);
-NTSTATUS make_default_filesystem_acl(TALLOC_CTX *ctx,
-                                        const char *name,
-                                        SMB_STRUCT_STAT *psbuf,
-                                        struct security_descriptor **ppdesc);
 int posix_sys_acl_blob_get_file(vfs_handle_struct *handle,
                                 const char *path_p,
 …
 /* The following definitions come from smbd/quotas.c  */
+bool disk_quotas(connection_struct *conn, const char *path, uint64_t *bsize,
+                 uint64_t *dfree, uint64_t *dsize);
+bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
+bool disk_quotas(connection_struct *conn, struct smb_filename *fname,
+                 uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
 /* The following definitions come from smbd/reply.c  */
 …
 void reply_readbraw(struct smb_request *req);
 void reply_lockread(struct smb_request *req);
+int setup_readX_header(char *outbuf, size_t smb_maxcnt);
 void reply_read(struct smb_request *req);
 void reply_read_and_X(struct smb_request *req);

vendor/current/source3/smbd/quotas.c

-              r988
+              r989
 ****************************************************************************/
 bool disk_quotas(connection_struct *conn, const char *path, uint64_t *bsize,
                  uint64_t *dfree, uint64_t *dsize)
+bool disk_quotas(connection_struct *conn, struct smb_filename *fname,
+                 uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
         uid_t euser_id;
 …
         SMB_DEV_T devno;
         bool found = false;
+        const char *path = fname->base_name;
         euser_id = geteuid();
+        if (sys_stat(path, &sbuf, false) == -1) {
+                return false;
+        }
+        devno = sbuf.st_ex_dev ;
+        devno = fname->st.st_ex_dev;
         DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
                 path, (unsigned int)devno));
 …
 ****************************************************************************/
 bool disk_quotas(connection_struct *conn, const char *path, uint64_t *bsize,
                  uint64_t *dfree, uint64_t *dsize)
+bool disk_quotas(connection_struct *conn, struct smb_filename *fname,
+                 uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
   int r;
   struct dqblk D;
   uid_t euser_id;
+  const char *path = fname->base_name;
 #if !defined(AIX)
   char dev_disk[256];
   SMB_STRUCT_STAT S;
+  SMB_STRUCT_STAT S = fname->st;
   /* find the block device file */
 …
 #else /* WITH_QUOTAS */
 bool disk_quotas(connection_struct *conn, const char *path, uint64_t *bsize,
                  uint64_t *dfree, uint64_t *dsize)
+bool disk_quotas(connection_struct *conn, struct smb_filename *fname,
+                 uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
         (*bsize) = 512; /* This value should be ignored */
 …
    this file should be removed later
    */
 bool disk_quotas(connection_struct *conn, const char *path, uint64_t *bsize,
                  uint64_t *dfree, uint64_t *dsize)
+bool disk_quotas(connection_struct *conn, struct smb_filename *fname,
+                 uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
+{
         int r;
 …
         unid_t id;
+        /*
+         * First of all, check whether user quota is
+         * enforced. If the call fails, assume it is
+         * not enforced.
+         */
+        ZERO_STRUCT(D);
+        id.uid = -1;
+        r = SMB_VFS_GET_QUOTA(conn, fname->base_name, SMB_USER_FS_QUOTA_TYPE,
+                              id, &D);
+        if (r == -1 && errno != ENOSYS) {
+                goto try_group_quota;
+        }
+        if (r == 0 && (D.qflags & QUOTAS_DENY_DISK) == 0) {
+                goto try_group_quota;
+        }
+        ZERO_STRUCT(D);
         id.uid = geteuid();
+        ZERO_STRUCT(D);
+        r = SMB_VFS_GET_QUOTA(conn, path, SMB_USER_QUOTA_TYPE, id, &D);
+        /* if new files created under this folder get this
+         * folder's UID, then available space is governed by
+         * the quota of the folder's UID, not the creating user.
+         */
+        if (lp_inherit_owner(SNUM(conn)) &&
+            id.uid != fname->st.st_ex_uid && id.uid != sec_initial_uid()) {
+                int save_errno;
+                id.uid = fname->st.st_ex_uid;
+                become_root();
+                r = SMB_VFS_GET_QUOTA(conn, fname->base_name,
+                                      SMB_USER_QUOTA_TYPE, id, &D);
+                save_errno = errno;
+                unbecome_root();
+                errno = save_errno;
+        } else {
+                r = SMB_VFS_GET_QUOTA(conn, fname->base_name,
+                                      SMB_USER_QUOTA_TYPE, id, &D);
+        }
         /* Use softlimit to determine disk space, except when it has been exceeded */
 …
 try_group_quota:
+        /*
+         * First of all, check whether group quota is
+         * enforced. If the call fails, assume it is
+         * not enforced.
+         */
+        ZERO_STRUCT(D);
+        id.gid = -1;
+        r = SMB_VFS_GET_QUOTA(conn, fname->base_name, SMB_GROUP_FS_QUOTA_TYPE,
+                              id, &D);
+        if (r == -1 && errno != ENOSYS) {
+                return false;
+        }
+        if (r == 0 && (D.qflags & QUOTAS_DENY_DISK) == 0) {
+                return false;
+        }
         id.gid = getegid();
         ZERO_STRUCT(D);
+        r = SMB_VFS_GET_QUOTA(conn, path, SMB_GROUP_QUOTA_TYPE, id, &D);
+        r = SMB_VFS_GET_QUOTA(conn, fname->base_name, SMB_GROUP_QUOTA_TYPE, id,
+                              &D);
         /* Use softlimit to determine disk space, except when it has been exceeded */

vendor/current/source3/smbd/reply.c

-              r988
+              r989
         uint64_t ret;
         uint64_t dfree,dsize,bsize;
+        struct smb_filename smb_fname;
         START_PROFILE(SMBdskattr);
+        ret = get_dfree_info(conn, ".", &bsize, &dfree, &dsize);
+        ZERO_STRUCT(smb_fname);
+        smb_fname.base_name = discard_const_p(char, ".");
+        if (SMB_VFS_STAT(conn, &smb_fname) != 0) {
+                reply_nterror(req, map_nt_error_from_unix(errno));
+                DBG_WARNING("stat of . failed (%s)\n", strerror(errno));
+                END_PROFILE(SMBdskattr);
+                return;
+        }
+        ret = get_dfree_info(conn, &smb_fname, &bsize, &dfree, &dsize);
         if (ret == (uint64_t)-1) {
                 reply_nterror(req, map_nt_error_from_unix(errno));
 …
 ****************************************************************************/
+static int setup_readX_header(struct smb_request *req, char *outbuf,
+                              size_t smb_maxcnt)
+int setup_readX_header(char *outbuf, size_t smb_maxcnt)
+{
         int outsize;
 …
               + 1);             /* padding byte */
         SSVAL(outbuf,smb_vwv7,(smb_maxcnt >> 16));
-        SSVAL(outbuf,smb_vwv11,smb_maxcnt);
         SCVAL(smb_buf(outbuf), 0, 0); /* padding byte */
         /* Reset the outgoing length, set_message truncates at 0x1FFFF. */
 …
                 construct_reply_common_req(req, (char *)headerbuf);
                 setup_readX_header(req, (char *)headerbuf, smb_maxcnt);
+                setup_readX_header((char *)headerbuf, smb_maxcnt);
                 nread = SMB_VFS_SENDFILE(xconn->transport.sock, fsp, &header,
 …
                 construct_reply_common_req(req, (char *)headerbuf);
                 setup_readX_header(req, (char *)headerbuf, smb_maxcnt);
+                setup_readX_header((char *)headerbuf, smb_maxcnt);
                 /* Send out the header. */
 …
+        }
         setup_readX_header(req, (char *)req->outbuf, nread);
+        setup_readX_header((char *)req->outbuf, nread);
         DEBUG(3, ("send_file_readX %s max=%d nread=%d\n",

vendor/current/source3/smbd/server.c

-              r988
+              r989
+        }
         status = reinit_after_fork(msg, ev, true, "smbd-notifyd");
+        status = smbd_reinit_after_fork(msg, ev, true, "smbd-notifyd");
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("%s: reinit_after_fork failed: %s\n",
 …
         close(up_pipe[0]);
         status = reinit_after_fork(msg, ev, true, "cleanupd");
+        status = smbd_reinit_after_fork(msg, ev, true, "cleanupd");
         if (!NT_STATUS_IS_OK(status)) {
                 DBG_WARNING("reinit_after_fork failed: %s\n",
 …
          * initialized before the messaging context, cause the messaging
          * context holds an event context.
-         * FIXME: This should be s3_tevent_context_init()
          */
         ev_ctx = server_event_context();

vendor/current/source3/smbd/service.c

-              r988
+              r989
+{
         int snum;
+        enum remote_arch_types ra_type;
         if (!conn)  {
 …
         last_flags = flags;
+        /* Obey the client case sensitivity requests - only for clients that support it. */
+        /*
+         * Obey the client case sensitivity requests - only for clients that
+         * support it. */
         switch (lp_case_sensitive(snum)) {
+                case Auto:
+                        {
+                                /* We need this uglyness due to DOS/Win9x clients that lie about case insensitivity. */
+                                enum remote_arch_types ra_type = get_remote_arch();
+                                if ((ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
+                                        /* Client can't support per-packet case sensitive pathnames. */
+                                        conn->case_sensitive = False;
+                                } else {
+                                        conn->case_sensitive = !(flags & FLAG_CASELESS_PATHNAMES);
+                                }
+                        }
+                        break;
+                case True:
+                        conn->case_sensitive = True;
+                        break;
+                default:
+                        conn->case_sensitive = False;
+                        break;
+        }
+        return(True);
+        case Auto:
+                /*
+                 * We need this uglyness due to DOS/Win9x clients that lie
+                 * about case insensitivity. */
+                ra_type = get_remote_arch();
+                if (conn->sconn->using_smb2) {
+                        conn->case_sensitive = false;
+                } else if ((ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
+                        /*
+                         * Client can't support per-packet case sensitive
+                         * pathnames. */
+                        conn->case_sensitive = false;
+                } else {
+                        conn->case_sensitive =
+                                        !(flags & FLAG_CASELESS_PATHNAMES);
+                }
+        break;
+        case True:
+                conn->case_sensitive = true;
+                break;
+        default:
+                conn->case_sensitive = false;
+                break;
+        }
+        return true;
+}

vendor/current/source3/smbd/sesssetup.c

-              r988
+              r989
         struct smbd_server_connection *sconn = req->sconn;
         uint16_t action = 0;
+        bool is_authenticated = false;
         NTTIME now = timeval_to_nttime(&req->request_time);
         struct smbXsrv_session *session = NULL;
 …
                 if (security_session_user_level(session_info, NULL) >= SECURITY_USER) {
+                        is_authenticated = true;
                         session->compat->homes_snum =
                                 register_homes_share(session_info->unix_info->unix_name);
 …
                 if (srv_is_signing_negotiated(xconn) &&
                     action == 0 &&
+                    is_authenticated &&
                     session->global->signing_key.length > 0)
+                {
 …
         uint16_t smb_flag2 = req->flags2;
         uint16_t action = 0;
+        bool is_authenticated = false;
         NTTIME now = timeval_to_nttime(&req->request_time);
         struct smbXsrv_session *session = NULL;
 …
         if (security_session_user_level(session_info, NULL) >= SECURITY_USER) {
+                is_authenticated = true;
                 session->compat->homes_snum =
                         register_homes_share(session_info->unix_info->unix_name);
 …
         if (srv_is_signing_negotiated(xconn) &&
             action == 0 &&
+            is_authenticated &&
             session->global->signing_key.length > 0)
+        {

vendor/current/source3/smbd/smb2_glue.c

-              r988
+              r989
                          FLAGS2_LONG_PATH_COMPONENTS |
                          FLAGS2_IS_LONG_NAME;
+        /* This is not documented in revision 49 of [MS-SMB2] but should be
+         * added in a later revision (and torture test smb2.read.access
+         * as well as smb2.ioctl_copy_chunk_bad_access against
+         * Server 2012R2 confirms this)
+         *
+         * If FILE_EXECUTE is granted to a handle then the SMB2 server
+         * acts as if FILE_READ_DATA has also been granted. We must still
+         * keep the original granted mask, because with ioctl requests,
+         * access checks are made on the file handle, "below" the SMB2
+         * server, and the object store below the SMB layer is not aware
+         * of this arrangement (see smb2.ioctl.copy_chunk_bad_access
+         * torture test).
+         */
+        smbreq->flags2 |= FLAGS2_READ_PERMIT_EXECUTE;
         if (IVAL(inhdr, SMB2_HDR_FLAGS) & SMB2_HDR_FLAG_DFS) {
                 smbreq->flags2 |= FLAGS2_DFS_PATHNAMES;

vendor/current/source3/smbd/smb2_ioctl_filesys.c

-              r988
+              r989
         /* Windows doesn't check for SEC_FILE_READ_ATTRIBUTE permission here */
-        if ((fsp->conn->fs_capabilities & FILE_FILE_COMPRESSION) == 0) {
-                DEBUG(4, ("FS does not advertise compression support\n"));
-                return NT_STATUS_NOT_SUPPORTED;
+        }
         ZERO_STRUCT(cmpr_state);
+        status = SMB_VFS_GET_COMPRESSION(fsp->conn,
+                                         mem_ctx,
+                                         fsp,
+                                         NULL,
+                                         &cmpr_state.format);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        if (fsp->conn->fs_capabilities & FILE_FILE_COMPRESSION) {
+                status = SMB_VFS_GET_COMPRESSION(fsp->conn,
+                                                 mem_ctx,
+                                                 fsp,
+                                                 NULL,
+                                                 &cmpr_state.format);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+        } else {
+                /*
+                 * bso#12144: The underlying filesystem doesn't support
+                 * compression, so we should respond with "not-compressed"
+                 * (like WS2016 ReFS) instead of STATUS_NOT_SUPPORTED or
+                 * NT_STATUS_INVALID_DEVICE_REQUEST.
+                 */
+                cmpr_state.format = COMPRESSION_FORMAT_NONE;
+        }

vendor/current/source3/smbd/smb2_ioctl_network_fs.c

-              r988
+              r989
          *   FILE_READ_DATA, and the CtlCode is FSCTL_SRV_COPYCHUNK.
          */
         if ((ctl_code == FSCTL_SRV_COPYCHUNK)
           && !CHECK_READ(dst_fsp, smb1req)) {
+        if ((ctl_code == FSCTL_SRV_COPYCHUNK) &&
+            !CHECK_READ_IOCTL(dst_fsp, smb1req)) {
                 DEBUG(5, ("copy chunk no read on dest handle (%s).\n",
                         smb_fname_str_dbg(dst_fsp->fsp_name) ));

vendor/current/source3/smbd/smb2_server.c

-              r988
+              r989
         uint16_t fileid_ofs;
         bool allow_invalid_fileid;
+        bool modify;
 } smbd_smb2_table[] = {
 #define _OP(o) .opcode = o, .name = #o
 …
                 .need_tcon = true,
                 .fileid_ofs = 0x10,
+                .modify = true,
         },{
                 _OP(SMB2_OP_LOCK),
 …
                 .fileid_ofs = 0x08,
                 .allow_invalid_fileid = true,
+                .modify = true,
         },{
                 _OP(SMB2_OP_CANCEL),
 …
                 .need_tcon = true,
                 .fileid_ofs = 0x10,
+                .modify = true,
         },{
                 _OP(SMB2_OP_BREAK),
 …
+}
+static NTSTATUS smbd_smb2_request_dispatch_update_counts(
+                                struct smbd_smb2_request *req,
+                                bool modify_call)
+{
+        struct smbXsrv_connection *xconn = req->xconn;
+        const uint8_t *inhdr;
+        uint16_t channel_sequence;
+        uint32_t flags;
+        int cmp;
+        struct smbXsrv_open *op;
+        bool update_open = false;
+        NTSTATUS status = NT_STATUS_OK;
+        req->request_counters_updated = false;
+        if (xconn->protocol < PROTOCOL_SMB2_22) {
+                return NT_STATUS_OK;
+        }
+        if (req->compat_chain_fsp == NULL) {
+                return NT_STATUS_OK;
+        }
+        op = req->compat_chain_fsp->op;
+        if (op == NULL) {
+                return NT_STATUS_OK;
+        }
+        inhdr = SMBD_SMB2_IN_HDR_PTR(req);
+        flags = IVAL(inhdr, SMB2_HDR_FLAGS);
+        channel_sequence = SVAL(inhdr, SMB2_HDR_CHANNEL_SEQUENCE);
+        cmp = channel_sequence - op->global->channel_sequence;
+        if (abs(cmp) > INT16_MAX) {
+                /*
+                 * [MS-SMB2] 3.3.5.2.10 - Verifying the Channel Sequence Number:
+                 *
+                 * If the channel sequence number of the request and the one
+                 * known to the server are not equal, the channel sequence
+                 * number and outstanding request counts are only updated
+                 * "... if the unsigned difference using 16-bit arithmetic
+                 * between ChannelSequence and Open.ChannelSequence is less than
+                 * or equal to 0x7FFF ...".
+                 * Otherwise, an error is returned for the modifying
+                 * calls write, set_info, and ioctl.
+                 *
+                 * There are currently two issues with the description:
+                 *
+                 * * For the other calls, the document seems to imply
+                 *   that processing continues without adapting the
+                 *   counters (if the sequence numbers are not equal).
+                 *
+                 *   TODO: This needs clarification!
+                 *
+                 * * Also, the behaviour if the difference is larger
+                 *   than 0x7FFF is not clear. The document seems to
+                 *   imply that if such a difference is reached,
+                 *   the server starts to ignore the counters or
+                 *   in the case of the modifying calls, return errors.
+                 *
+                 *   TODO: This needs clarification!
+                 *
+                 * At this point Samba tries to be a little more
+                 * clever than the description in the MS-SMB2 document
+                 * by heuristically detecting and properly treating
+                 * a 16 bit overflow of the client-submitted sequence
+                 * number:
+                 *
+                 * If the stored channel squence number is more than
+                 * 0x7FFF larger than the one from the request, then
+                 * the client-provided sequence number has likely
+                 * overflown. We treat this case as valid instead
+                 * of as failure.
+                 *
+                 * The MS-SMB2 behaviour would be setting cmp = -1.
+                 */
+                cmp *= -1;
+        }
+        if (!(flags & SMB2_HDR_FLAG_REPLAY_OPERATION)) {
+                if (cmp == 0) {
+                        op->request_count += 1;
+                        req->request_counters_updated = true;
+                } else if (cmp > 0) {
+                        op->pre_request_count += op->request_count;
+                        op->request_count = 1;
+                        op->global->channel_sequence = channel_sequence;
+                        update_open = true;
+                        req->request_counters_updated = true;
+                } else if (modify_call) {
+                        return NT_STATUS_FILE_NOT_AVAILABLE;
+                }
+        } else {
+                if (cmp == 0 && op->pre_request_count == 0) {
+                        op->request_count += 1;
+                        req->request_counters_updated = true;
+                } else if (cmp > 0 && op->pre_request_count == 0) {
+                        op->pre_request_count += op->request_count;
+                        op->request_count = 1;
+                        op->global->channel_sequence = channel_sequence;
+                        update_open = true;
+                        req->request_counters_updated = true;
+                } else if (modify_call) {
+                        return NT_STATUS_FILE_NOT_AVAILABLE;
+                }
+        }
+        if (update_open) {
+                status = smbXsrv_open_update(op);
+        }
+        return status;
+}
 NTSTATUS smbd_smb2_request_dispatch(struct smbd_smb2_request *req)
+{
 …
+        }
+        status = smbd_smb2_request_dispatch_update_counts(req, call->modify);
+        if (!NT_STATUS_IS_OK(status)) {
+                return smbd_smb2_request_error(req, status);
+        }
         if (call->as_root) {
                 SMB_ASSERT(call->fileid_ofs == 0);
 …
+}
+static void smbd_smb2_request_reply_update_counts(struct smbd_smb2_request *req)
+{
+        struct smbXsrv_connection *xconn = req->xconn;
+        const uint8_t *inhdr;
+        uint16_t channel_sequence;
+        struct smbXsrv_open *op;
+        if (!req->request_counters_updated) {
+                return;
+        }
+        if (xconn->protocol < PROTOCOL_SMB2_22) {
+                return;
+        }
+        if (req->compat_chain_fsp == NULL) {
+                return;
+        }
+        op = req->compat_chain_fsp->op;
+        if (op == NULL) {
+                return;
+        }
+        inhdr = SMBD_SMB2_IN_HDR_PTR(req);
+        channel_sequence = SVAL(inhdr, SMB2_HDR_CHANNEL_SEQUENCE);
+        if (op->global->channel_sequence == channel_sequence) {
+                SMB_ASSERT(op->request_count > 0);
+                op->request_count -= 1;
+        } else {
+                SMB_ASSERT(op->pre_request_count > 0);
+                op->pre_request_count -= 1;
+        }
+}
 static NTSTATUS smbd_smb2_request_reply(struct smbd_smb2_request *req)
+{
 …
         req->subreq = NULL;
         TALLOC_FREE(req->async_te);
+        /* MS-SMB2: 3.3.4.1 Sending Any Outgoing Message */
+        smbd_smb2_request_reply_update_counts(req);
         if (req->do_encryption &&

vendor/current/source3/smbd/trans2.c

-              r988
+              r989
                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
                         data_len = 18;
                         df_ret = get_dfree_info(conn, filename, &bsize, &dfree,
                                                 &dsize);
+                        df_ret = get_dfree_info(conn, &smb_fname, &bsize,
+                                                &dfree, &dsize);
                         if (df_ret == (uint64_t)-1) {
                                 return map_nt_error_from_unix(errno);
 …
                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
                         data_len = 24;
                         df_ret = get_dfree_info(conn, filename, &bsize, &dfree,
                                                 &dsize);
+                        df_ret = get_dfree_info(conn, &smb_fname, &bsize,
+                                                &dfree, &dsize);
                         if (df_ret == (uint64_t)-1) {
                                 return map_nt_error_from_unix(errno);
 …
                         uint64_t dfree,dsize,bsize,block_size,sectors_per_unit;
                         data_len = 32;
                         df_ret = get_dfree_info(conn, filename, &bsize, &dfree,
                                                 &dsize);
+                        df_ret = get_dfree_info(conn, &smb_fname, &bsize,
+                                                &dfree, &dsize);
                         if (df_ret == (uint64_t)-1) {
                                 return map_nt_error_from_unix(errno);
 …
                         /* Here is where we must switch to posix pathname processing... */
                         if (xconn->smb1.unix_info.client_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
                                 lp_set_posix_pathnames();
+                                (void)lp_set_posix_pathnames(true);
                                 mangle_change_to_posix();
+                        }
 …
                         if (info_level == SMB_QUERY_FILE_UNIX_BASIC ||
                                         info_level == SMB_QUERY_FILE_UNIX_INFO2 ||
+                                        info_level == SMB_QUERY_FILE_UNIX_LINK) {
+                                        info_level == SMB_QUERY_FILE_UNIX_LINK ||
+                                        req->posix_pathnames) {
                                 ucf_flags |= UCF_UNIX_NAME_LOOKUP;
+                        }
 …
+                        }
                         if (INFO_LEVEL_IS_UNIX(info_level)) {
+                        if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
                                 /* Always do lstat for UNIX calls. */
                                 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
 …
+                }
                 if (INFO_LEVEL_IS_UNIX(info_level)) {
+                if (INFO_LEVEL_IS_UNIX(info_level) || req->posix_pathnames) {
                         /* Always do lstat for UNIX calls. */
                         if (SMB_VFS_LSTAT(conn, smb_fname)) {

vendor/current/source3/smbd/vfs.c

-              r988
+              r989
         len -= fsp->fsp_name->st.st_ex_size;
         len /= 1024; /* Len is now number of 1k blocks needed. */
         space_avail = get_dfree_info(conn, fsp->fsp_name->base_name,
                                      &bsize, &dfree, &dsize);
+        space_avail =
+            get_dfree_info(conn, fsp->fsp_name, &bsize, &dfree, &dsize);
         if (space_avail == (uint64_t)-1) {
                 return -1;

vendor/current/source3/utils/net_ads.c

-              r988
+              r989
+        }
+        /* print out informative error string in case there is one */
+        if (r->out.error_string != NULL) {
+                d_printf("%s\n", r->out.error_string);
+        }
         /*
          * We try doing the dns update (if it was compiled in

vendor/current/source3/utils/net_printing.c

-              r988
+              r989
                 if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
+                        dump_form(ctx, (const char *)kbuf.dptr+strlen(FORMS_PREFIX), dbuf.dptr, dbuf.dsize);
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
+                        dump_form(ctx, key_name, dbuf.dptr, dbuf.dsize);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;
 …
                 if (strncmp((const char *)kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
                         dump_driver(ctx,
                                     (const char *)kbuf.dptr+strlen(DRIVERS_PREFIX),
+                                    key_name,
                                     dbuf.dptr,
                                     dbuf.dsize,
                                     do_string_conversion);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;
 …
                 if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
                         dump_printer(ctx,
                                      (const char *)kbuf.dptr+strlen(PRINTERS_PREFIX),
+                                     key_name,
                                      dbuf.dptr,
                                      dbuf.dsize,
                                      do_string_conversion);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;
 …
                 if (strncmp((const char *) kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(tmp_ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
                         printing_tdb_migrate_form(tmp_ctx,
                                      winreg_pipe,
                                      (const char *) kbuf.dptr + strlen(FORMS_PREFIX),
+                                     key_name,
                                      dbuf.dptr,
                                      dbuf.dsize);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;
 …
                 if (strncmp((const char *) kbuf.dptr, DRIVERS_PREFIX, strlen(DRIVERS_PREFIX)) == 0) {
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(tmp_ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
                         printing_tdb_migrate_driver(tmp_ctx,
                                        winreg_pipe,
                                        (const char *) kbuf.dptr + strlen(DRIVERS_PREFIX),
+                                       key_name,
                                        dbuf.dptr,
                                        dbuf.dsize,
                                        do_string_conversion);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;
 …
                 if (strncmp((const char *) kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
+                        char *key_name = NULL;
+                        size_t converted_size = 0;
+                        bool ok;
+                        ok = pull_ascii_talloc(tmp_ctx,
+                                               &key_name,
+                                               (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
+                                               &converted_size);
+                        if (!ok) {
+                                continue;
+                        }
                         printing_tdb_migrate_printer(tmp_ctx,
                                         winreg_pipe,
                                         (const char *) kbuf.dptr + strlen(PRINTERS_PREFIX),
+                                        key_name,
                                         dbuf.dptr,
                                         dbuf.dsize,
                                         do_string_conversion);
+                        TALLOC_FREE(key_name);
                         SAFE_FREE(dbuf.dptr);
                         continue;

vendor/current/source3/utils/net_rpc.c

-              r988
+              r989
+        }
+        /* print out informative error string in case there is one */
+        if (r->out.error_string != NULL) {
+                d_printf("%s\n", r->out.error_string);
+        }
         TALLOC_FREE(mem_ctx);
 …
                 d_printf("Joined '%s' to domain '%s'\n", r->in.machine_name,
                         r->out.netbios_domain_name);
+        }
+        /* print out informative error string in case there is one */
+        if (r->out.error_string != NULL) {
+                d_printf("%s\n", r->out.error_string);
+        }

vendor/current/source3/utils/ntlm_auth.c

-              r988
+              r989
 #include "lib/param/param.h"
 #include "popt_common.h"
+#include "libcli/security/security.h"
 #include "utils/ntlm_auth.h"
 #include "../libcli/auth/libcli_auth.h"
 …
                                                 struct auth_session_info **session_info_out)
+{
+        char *unix_username = (char *)server_returned_info;
+        struct auth_session_info *session_info = talloc_zero(mem_ctx, struct auth_session_info);
+        if (!session_info) {
+        const char *unix_username = (const char *)server_returned_info;
+        bool ok;
+        struct dom_sid *sids = NULL;
+        struct auth_session_info *session_info = NULL;
+        session_info = talloc_zero(mem_ctx, struct auth_session_info);
+        if (session_info == NULL) {
                 return NT_STATUS_NO_MEMORY;
+        }
         session_info->unix_info = talloc_zero(session_info, struct auth_user_info_unix);
         if (!session_info->unix_info) {
+        if (session_info->unix_info == NULL) {
                 TALLOC_FREE(session_info);
                 return NT_STATUS_NO_MEMORY;
+        }
+        session_info->unix_info->unix_name = talloc_steal(session_info->unix_info, unix_username);
+        session_info->unix_info->unix_name = talloc_strdup(session_info->unix_info,
+                                                           unix_username);
+        if (session_info->unix_info->unix_name == NULL) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_NO_MEMORY;
+        }
+        session_info->security_token = talloc_zero(session_info, struct security_token);
+        if (session_info->security_token == NULL) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_NO_MEMORY;
+        }
+        sids = talloc_zero_array(session_info->security_token,
+                                 struct dom_sid, 3);
+        if (sids == NULL) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ok = dom_sid_parse(SID_WORLD, &sids[0]);
+        if (!ok) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        ok = dom_sid_parse(SID_NT_NETWORK, &sids[1]);
+        if (!ok) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        ok = dom_sid_parse(SID_NT_AUTHENTICATED_USERS, &sids[2]);
+        if (!ok) {
+                TALLOC_FREE(session_info);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        session_info->security_token->num_sids = talloc_array_length(sids);
+        session_info->security_token->sids = sids;
         *session_info_out = session_info;

vendor/current/source3/utils/smbcquotas.c

-              r988
+              r989
         struct cli_state *cli;
         bool fix_user = False;
+        bool ok;
         SMB_NTQUOTA_STRUCT qt;
         TALLOC_CTX *frame = talloc_stackframe();
 …
         fault_setup();
-        lp_load_global(get_dyn_CONFIGFILE());
-        load_interfaces();
         smbcquotas_auth_info = user_auth_info_init(frame);
         if (smbcquotas_auth_info == NULL) {
 …
         popt_burn_cmdline_password(argc, argv);
+        ok = lp_load_global(get_dyn_CONFIGFILE());
+        if (!ok) {
+                DBG_ERR("ERROR: Loading config file %s - "
+                        "run testparm to debug it\n",
+                        get_dyn_CONFIGFILE());
+                exit(EXIT_PARSE_ERROR);
+        }
+        /* We must load interfaces after we load the smb.conf */
+        load_interfaces();
         string_replace(path, '/', '\\');

vendor/current/source3/utils/smbget.c

-              r988
+              r989
         static char *savedun;
         static char *savedpw;
-        char tmp[128];
         if (hasasked) {
 …
         hasasked = true;
+        if (!opt.nonprompt && !opt.username_specified) {
+                printf("Username for %s at %s [guest] ", shr, srv);
+                if (fgets(tmp, sizeof(tmp), stdin) == NULL) {
+                        return;
+                }
+                if ((strlen(tmp) > 0) && (tmp[strlen(tmp) - 1] == '\n')) {
+                        tmp[strlen(tmp) - 1] = '\0';
+                }
+                strncpy(un, tmp, unlen - 1);
+        } else if (opt.username != NULL) {
+        /*
+         * If no user has been specified un is initialized with the current
+         * username of the user who started smbget.
+         */
+        if (opt.username_specified) {
                 strncpy(un, opt.username, unlen - 1);
+        }
         if (!opt.nonprompt && !opt.password_specified) {
+        if (!opt.nonprompt && !opt.password_specified && pw[0] == '\0') {
                 char *prompt;
+                if (asprintf(&prompt, "Password for %s at %s: ", shr, srv) ==
+                    -1) {
+                int rc;
+                rc = asprintf(&prompt,
+                              "Password for [%s] connecting to //%s/%s: ",
+                              un, shr, srv);
+                if (rc == -1) {
                         return;
+                }

vendor/current/source3/winbindd/idmap_rfc2307.c

-              r988
+              r989
                 default:
+                        DEBUG(10, ("Nothing to do for SID %s, "
+                                   "previous name lookup failed\n",
+                                   sid_string_dbg(map->map->sid)));
+                        break;
+                }

vendor/current/source3/winbindd/idmap_util.c

-              r988
+              r989
 bool idmap_unix_id_is_in_range(uint32_t id, struct idmap_domain *dom)
+{
-        if (id == 0) {
-                /* 0 is not an allowed unix id for id mapping */
-                return false;
+        }
         if ((dom->low_id && (id < dom->low_id)) ||
             (dom->high_id && (id > dom->high_id)))

vendor/current/source3/winbindd/wb_lookupsids.c

-              r988
+              r989
          */
         uint32_t *single_sids;
+        /* Pointer into the "domains" array above*/
+        struct wb_lookupsids_domain **single_domains;
         uint32_t num_single_sids;
         uint32_t single_sids_done;
 …
         state->single_sids = talloc_array(state, uint32_t, num_sids);
         if (tevent_req_nomem(state->single_sids, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->single_domains = talloc_zero_array(state,
+                                                  struct wb_lookupsids_domain *,
+                                                  num_sids);
+        if (tevent_req_nomem(state->single_domains, req)) {
                 return tevent_req_post(req, ev);
+        }
 …
                         state->single_sids[state->num_single_sids] =
                                 res_sid_index;
+                        state->single_domains[state->num_single_sids] = d;
                         state->num_single_sids += 1;
+                }
 …
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
+                struct wb_lookupsids_domain *wb_domain;
+                const char *tmpname;
                 type = SID_NAME_UNKNOWN;
+                domain_name = talloc_strdup(talloc_tos(), "");
+                wb_domain = state->single_domains[state->single_sids_done];
+                if (wb_domain != NULL) {
+                        /*
+                         * If the lookupsid failed because the rid not
+                         * found in a domain and we have a reference
+                         * to the lookup domain, use the name from
+                         * there.
+                         *
+                         * Callers like sid2xid will use the domain
+                         * name in the idmap backend to figure out
+                         * which domain to use in processing.
+                         */
+                        tmpname = wb_domain->domain->name;
+                } else {
+                        tmpname = "";
+                }
+                domain_name = talloc_strdup(talloc_tos(), tmpname);
                 if (tevent_req_nomem(domain_name, req)) {
                         return;

vendor/current/source3/winbindd/winbindd_cache.c

-              r988
+              r989
 /*
+  refresh the domain sequence number. If force is true
+  then always refresh it, no matter how recently we fetched it
+  refresh the domain sequence number on timeout.
 */
 static void refresh_sequence_number(struct winbindd_domain *domain, bool force)
+static void refresh_sequence_number(struct winbindd_domain *domain)
+{
         NTSTATUS status;
 …
         /* see if we have to refetch the domain sequence number */
         if (!force && (time_diff < cache_time) &&
+        if ((time_diff < cache_time) &&
                         (domain->sequence_number != DOM_SEQUENCE_NONE) &&
                         NT_STATUS_IS_OK(domain->last_status)) {
 …
+        }
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         va_start(ap, format);
 …
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (domain->online &&
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         for (i=0; i<num_rids; i++) {
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
 static NTSTATUS sequence_number(struct winbindd_domain *domain, uint32_t *seq)
+{
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         *seq = domain->sequence_number;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+        }
         /* and save it */
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
+}
+/*
+ * Cache a name to sid without checking the sequence number.
+ * Used when caching from a trusted PAC.
+ */
+void cache_name2sid_trusted(struct winbindd_domain *domain,
+                        const char *domain_name,
+                        const char *name,
+                        enum lsa_SidType type,
+                        const struct dom_sid *sid)
+{
+        /*
+         * Ensure we store the mapping with the
+         * existing sequence number from the cache.
+         */
+        get_cache(domain);
+        (void)fetch_cache_seqnum(domain, time(NULL));
+        wcache_save_name_to_sid(domain,
+                                NT_STATUS_OK,
+                                domain_name,
+                                name,
+                                sid,
+                                type);
+}
 void cache_name2sid(struct winbindd_domain *domain,
                     const char *domain_name, const char *name,
                     enum lsa_SidType type, const struct dom_sid *sid)
+{
         refresh_sequence_number(domain, false);
+        refresh_sequence_number(domain);
         wcache_save_name_to_sid(domain, NT_STATUS_OK, domain_name, name,
                                 sid, type);
 …
         NTSTATUS status;
         int ret;
         struct cred_list *cred, *oldest = NULL;
+        struct cred_list *cred, *next, *oldest = NULL;
         if (!cache->tdb) {
 …
+        }
 done:
+        SAFE_FREE(wcache_cred_list);
+        for (cred = wcache_cred_list; cred; cred = next) {
+                next = cred->next;
+                DLIST_REMOVE(wcache_cred_list, cred);
+                SAFE_FREE(cred);
+        }
         SAFE_FREE(oldest);

vendor/current/source3/winbindd/winbindd_dual.c

-              r988
+              r989
         DEBUG(10,("winbind_msg_dump_event_list received\n"));
         dump_event_list(winbind_event_context());
+        DBG_WARNING("dump event list no longer implemented\n");
         for (child = winbindd_children; child != NULL; child = child->next) {
 …
+{
         DEBUG(5,("child_msg_dump_event_list received\n"));
+        dump_event_list(winbind_event_context());
+        DBG_WARNING("dump_event_list no longer implemented\n");
+}

vendor/current/source3/winbindd/winbindd_dual_srv.c

-              r988
+              r989
                 for (j=0; j<num_ids; j++) {
                         struct wbint_TransID *id = &r->in.ids->ids[id_idx[j]];
+                        if (!idmap_unix_id_is_in_range(ids[j].xid.id, dom)) {
+                                ids[j].status = ID_UNMAPPED;
+                        }
                         if (ids[j].status != ID_MAPPED) {

vendor/current/source3/winbindd/winbindd_pam.c

-              r988
+              r989
         if (logon_info) {
+                /* Signature verification succeeded, trust the PAC */
+                /*
+                 * Signature verification succeeded, we can
+                 * trust the PAC and prime the netsamlogon
+                 * and name2sid caches. DO NOT DO THIS
+                 * in the signature verification failed
+                 * code path.
+                 */
+                struct winbindd_domain *domain = NULL;
                 result = create_info3_from_pac_logon_info(state->mem_ctx,
                                                         logon_info,
 …
+                }
                 netsamlogon_cache_store(NULL, info3_copy);
+                /*
+                 * We're in the parent here, so find the child
+                 * pointer from the PAC domain name.
+                 */
+                domain = find_domain_from_name_noinit(
+                                info3_copy->base.logon_domain.string);
+                if (domain && domain->primary ) {
+                        struct dom_sid user_sid;
+                        sid_compose(&user_sid,
+                                info3_copy->base.domain_sid,
+                                info3_copy->base.rid);
+                        cache_name2sid_trusted(domain,
+                                info3_copy->base.logon_domain.string,
+                                info3_copy->base.account_name.string,
+                                SID_NAME_USER,
+                                &user_sid);
+                        DBG_INFO("PAC for user %s\%s SID %s primed cache\n",
+                                info3_copy->base.logon_domain.string,
+                                info3_copy->base.account_name.string,
+                                sid_string_dbg(&user_sid));
+                }
         } else {

vendor/current/source3/winbindd/winbindd_proto.h

-              r988
+              r989
                         struct dom_sid *sid,
                         enum lsa_SidType *type);
+void cache_name2sid_trusted(struct winbindd_domain *domain,
+                        const char *domain_name,
+                        const char *name,
+                        enum lsa_SidType type,
+                        const struct dom_sid *sid);
 void cache_name2sid(struct winbindd_domain *domain,
                     const char *domain_name, const char *name,

vendor/current/source3/winbindd/winbindd_util.c

-              r988
+              r989
         if ( !p ) {
                 fstrcpy(user, domuser);
+                if ( assume_domain(lp_workgroup())) {
+                p = strchr(domuser, '@');
+                if ( assume_domain(lp_workgroup()) && p == NULL) {
                         fstrcpy(domain, lp_workgroup());
                 } else if ((p = strchr(domuser, '@')) != NULL) {
+                } else if (p != NULL) {
                         fstrcpy(domain, p + 1);
                         user[PTR_DIFF(p, domuser)] = 0;

vendor/current/source3/wscript

r988	r989
111	111	conf.CHECK_FUNCS('fdopendir')
112	112	conf.CHECK_FUNCS('fstatat')
113		conf.CHECK_FUNCS('getpwent_r setenv strcasecmp fcvt fcvtl')
	113	conf.CHECK_FUNCS('getpwent_r setenv clearenv strcasecmp fcvt fcvtl')
114	114	conf.CHECK_FUNCS('syslog vsyslog timegm setlocale')
115	115	conf.CHECK_FUNCS_IN('nanosleep', 'rt')

vendor/current/source3/wscript_build

r988	r989
331	331	intl/lang_tdb.c
332	332	lib/gencache.c
333		lib/~~events~~.c
	333	lib/util_event.c
334	334	lib/server_contexts.c
335	335	lib/server_prefork.c

Context Navigation

Legend:

Download in other formats: