Changeset 342 for branches/samba-3.3.x/source

Timestamp:

Oct 30, 2009, 9:39:05 AM (16 years ago)

Author:

Herwig Bauernfeind

Message:

Update 3.3 to 3.3.9

Location:

branches/samba-3.3.x/source

Files:

• Makefile.in (modified) (1 diff)
• VERSION (modified) (1 diff)
• auth/auth_domain.c (modified) (1 diff)
• client/mount.cifs.c (modified) (3 diffs)
• include/proto.h (modified) (7 diffs)
• include/rpc_dce.h (modified) (1 diff)
• include/version.h (modified) (1 diff)
• lib/smbldap.c (modified) (1 diff)
• lib/system_smbd.c (modified) (1 diff)
• libnet/libnet_join.c (modified) (1 diff)
• libsmb/async_smb.c (modified) (1 diff)
• libsmb/clireadwrite.c (modified) (11 diffs)
• libsmb/dsgetdcname.c (modified) (1 diff)
• libsmb/libsmb_context.c (modified) (1 diff)
• libsmb/libsmb_dir.c (modified) (1 diff)
• libsmb/namequery.c (modified) (1 diff)
• libsmb/passchange.c (modified) (1 diff)
• locking/brlock.c (modified) (17 diffs)
• modules/vfs_default.c (modified) (1 diff)
• nsswitch/libwbclient/wbc_pam.c (modified) (3 diffs)
• nsswitch/libwbclient/wbc_sid.c (modified) (1 diff)
• nsswitch/libwbclient/wbc_util.c (modified) (1 diff)
• nsswitch/pam_winbind.c (modified) (2 diffs)
• pam_smbpass/pam_smb_auth.c (modified) (2 diffs)
• pam_smbpass/pam_smb_passwd.c (modified) (1 diff)
• pam_smbpass/support.c (modified) (9 diffs)
• pam_smbpass/support.h (modified) (1 diff)
• passdb/lookup_sid.c (modified) (1 diff)
• passdb/pdb_ldap.c (modified) (2 diffs)
• profile/profile.c (modified) (1 diff)
• rpc_client/cli_lsarpc.c (modified) (10 diffs)
• rpc_client/cli_netlogon.c (modified) (1 diff)
• rpc_client/cli_pipe.c (modified) (20 diffs)
• rpc_client/init_netlogon.c (modified) (1 diff)
• rpc_server/srv_netlog_nt.c (modified) (1 diff)
• rpc_server/srv_samr_nt.c (modified) (1 diff)
• rpcclient/rpcclient.c (modified) (3 diffs)
• smbd/files.c (modified) (2 diffs)
• smbd/notify_inotify.c (modified) (2 diffs)
• smbd/posix_acls.c (modified) (10 diffs)
• smbd/reply.c (modified) (5 diffs)
• utils/net.h (modified) (1 diff)
• utils/net_join.c (modified) (1 diff)
• utils/net_rpc.c (modified) (5 diffs)
• utils/net_rpc_join.c (modified) (2 diffs)
• utils/net_rpc_samsync.c (modified) (1 diff)
• winbindd/winbindd.c (modified) (2 diffs)
• winbindd/winbindd.h (modified) (2 diffs)
• winbindd/winbindd_ads.c (modified) (3 diffs)
• winbindd/winbindd_cm.c (modified) (10 diffs)
• winbindd/winbindd_proto.h (modified) (2 diffs)
• winbindd/winbindd_rpc.c (modified) (7 diffs)

branches/samba-3.3.x/source/Makefile.in

@@ -1379 +1379 @@
                 $(KRB5LIBS) $(LDAP_LIBS) $(POPT_LIBS) $(LIBTALLOC_LIBS) $(LIBTDB_LIBS)
 
-bin/mount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_MOUNT_OBJ) @BUILD_POPT@
-        @echo Linking $@
-        @$(CC) $(FLAGS) -o $@ $(CIFS_MOUNT_OBJ) $(DYNEXP) $(LDFLAGS) $(POPT_LIBS)
-
-bin/umount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UMOUNT_OBJ) @BUILD_POPT@
-        @echo Linking $@
-        @$(CC) $(FLAGS) -o $@ $(CIFS_UMOUNT_OBJ) $(DYNEXP) $(LDFLAGS) $(POPT_LIBS)
+bin/mount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_MOUNT_OBJ)
+        @echo Linking $@
+        @$(CC) $(FLAGS) -o $@ $(CIFS_MOUNT_OBJ) $(DYNEXP) $(LDFLAGS)
+
+bin/umount.cifs@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UMOUNT_OBJ)
+        @echo Linking $@
+        @$(CC) $(FLAGS) -o $@ $(CIFS_UMOUNT_OBJ) $(DYNEXP) $(LDFLAGS)
 
 bin/cifs.upcall@EXEEXT@: $(BINARY_PREREQS) $(CIFS_UPCALL_OBJ) $(LIBSMBCLIENT_OBJ1) @BUILD_POPT@ @LIBTALLOC_SHARED@ @LIBTDB_SHARED@ @LIBWBCLIENT_SHARED@

branches/samba-3.3.x/source/VERSION

@@ -26 +26 @@
 SAMBA_VERSION_MAJOR=3
 SAMBA_VERSION_MINOR=3
-SAMBA_VERSION_RELEASE=8
+SAMBA_VERSION_RELEASE=9
 
 ########################################################

branches/samba-3.3.x/source/auth/auth_domain.c

@@ -176 +176 @@
                 /* We also setup the creds chain in the open_schannel call. */
                 result = cli_rpc_pipe_open_schannel(
-                        *cli, &ndr_table_netlogon.syntax_id,
+                        *cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
                         PIPE_AUTH_LEVEL_PRIVACY, domain, &netlogon_pipe);
         } else {

branches/samba-3.3.x/source/client/mount.cifs.c

@@ -1037 +1037 @@
 }
 
+static void print_cifs_mount_version(void)
+{
+        printf("mount.cifs version: %s.%s%s\n",
+                MOUNT_CIFS_VERSION_MAJOR,
+                MOUNT_CIFS_VERSION_MINOR,
+                MOUNT_CIFS_VENDOR_SUFFIX);
+}
+
 int main(int argc, char ** argv)
 {
@@ -1098 +1106 @@
                 }
                 mountpoint = argv[2];
+        } else if (argc == 2) {
+                if ((strcmp(argv[1], "-V") == 0) ||
+                    (strcmp(argv[1], "--version") == 0))
+                {
+                        print_cifs_mount_version();
+                        exit(0);
+                }
+
+                if ((strcmp(argv[1], "-h") == 0) ||
+                    (strcmp(argv[1], "-?") == 0) ||
+                    (strcmp(argv[1], "--help") == 0))
+                {
+                        mount_cifs_usage();
+                        exit(0);
+                }
+
+                mount_cifs_usage();
+                exit(EX_USAGE);
         } else {
-                if ((strcmp (argv[1], "--version") == 0) ||
-                    ((strcmp (argv[1], "-V") == 0))) {
-                        printf ("mount.cifs version: %s.%s%s\n",
-                        MOUNT_CIFS_VERSION_MAJOR,
-                        MOUNT_CIFS_VERSION_MINOR,
-                        MOUNT_CIFS_VENDOR_SUFFIX);
-                        exit (0);
-                }
                 mount_cifs_usage();
                 exit(EX_USAGE);
@@ -1162 +1180 @@
                         ++verboseflag;
                         break;
-                case 'V':          
-                        printf ("mount.cifs version: %s.%s%s\n",
-                        MOUNT_CIFS_VERSION_MAJOR,
-                        MOUNT_CIFS_VERSION_MINOR,
-                        MOUNT_CIFS_VENDOR_SUFFIX);
+                case 'V':
+                        print_cifs_mount_version();
                         exit (0);
                 case 'w':

branches/samba-3.3.x/source/include/proto.h

@@ -6892 +6892 @@
                                 char ***pnames,
                                 enum lsa_SidType **ptypes);
+NTSTATUS rpccli_lsa_lookup_sids3(struct rpc_pipe_client *cli,
+                                 TALLOC_CTX *mem_ctx,
+                                 struct policy_handle *pol,
+                                 int num_sids,
+                                 const DOM_SID *sids,
+                                 char ***pdomains,
+                                 char ***pnames,
+                                 enum lsa_SidType **ptypes);
 NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
                                  TALLOC_CTX *mem_ctx,
@@ -6900 +6908 @@
                                  DOM_SID **sids,
                                  enum lsa_SidType **types);
+NTSTATUS rpccli_lsa_lookup_names4(struct rpc_pipe_client *cli,
+                                  TALLOC_CTX *mem_ctx,
+                                  struct policy_handle *pol, int num_names,
+                                  const char **names,
+                                  const char ***dom_names,
+                                  int level,
+                                  DOM_SID **sids,
+                                  enum lsa_SidType **types);
+
 bool fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid);
 
@@ -6989 +7006 @@
                                   const struct ndr_syntax_id *interface,
                                   struct rpc_pipe_client **presult);
+NTSTATUS cli_rpc_pipe_open_noauth_transport(struct cli_state *cli,
+                                            enum dcerpc_transport_t transport,
+                                            const struct ndr_syntax_id *interface,
+                                            struct rpc_pipe_client **presult);
 NTSTATUS cli_rpc_pipe_open_ntlmssp(struct cli_state *cli,
                                    const struct ndr_syntax_id *interface,
+                                   enum dcerpc_transport_t transport,
                                    enum pipe_auth_level auth_level,
                                    const char *domain,
@@ -6998 +7020 @@
 NTSTATUS cli_rpc_pipe_open_spnego_ntlmssp(struct cli_state *cli,
                                           const struct ndr_syntax_id *interface,
+                                          enum dcerpc_transport_t transport,
                                           enum pipe_auth_level auth_level,
                                           const char *domain,
@@ -7009 +7032 @@
 NTSTATUS cli_rpc_pipe_open_schannel_with_key(struct cli_state *cli,
                                              const struct ndr_syntax_id *interface,
+                                             enum dcerpc_transport_t transport,
                                              enum pipe_auth_level auth_level,
                                              const char *domain,
@@ -7015 +7039 @@
 NTSTATUS cli_rpc_pipe_open_ntlmssp_auth_schannel(struct cli_state *cli,
                                                  const struct ndr_syntax_id *interface,
+                                                 enum dcerpc_transport_t transport,
                                                  enum pipe_auth_level auth_level,
                                                  const char *domain,
@@ -7022 +7047 @@
 NTSTATUS cli_rpc_pipe_open_schannel(struct cli_state *cli,
                                     const struct ndr_syntax_id *interface,
+                                    enum dcerpc_transport_t transport,
                                     enum pipe_auth_level auth_level,
                                     const char *domain,

branches/samba-3.3.x/source/include/rpc_dce.h

@@ -151 +151 @@
 
 /* Maximum size of the signing data in a fragment. */
-#define RPC_MAX_SIGN_SIZE 0x20 /* 32 */
+#define RPC_MAX_SIGN_SIZE 0x38 /* 56 */
 
 /* Maximum PDU fragment size. */

branches/samba-3.3.x/source/include/version.h

@@ -2 +2 @@
 #define SAMBA_VERSION_MAJOR 3
 #define SAMBA_VERSION_MINOR 3
-#define SAMBA_VERSION_RELEASE 8
-#define SAMBA_VERSION_OFFICIAL_STRING "3.3.8"
-#define SAMBA_VERSION_VENDOR_SUFFIX "eCS 1.1.x-TEST"
-#define SAMBA_VERSION_VENDOR_PATCH 20091006
-#define SAMBA_VERSION_VENDOR_PATCH_STRING "20091006"
+#define SAMBA_VERSION_RELEASE 9
+#define SAMBA_VERSION_OFFICIAL_STRING "3.3.9"
 #define SAMBA_VERSION_STRING samba_version_string()

branches/samba-3.3.x/source/lib/smbldap.c

@@ -1466 +1466 @@
         }
 
-        DEBUG(3,("smbldap_search_paged: search was successfull\n"));
+        DEBUG(3,("smbldap_search_paged: search was successful\n"));
 
         rc = ldap_parse_result(ldap_state->ldap_struct, *res, NULL, NULL, 

branches/samba-3.3.x/source/lib/system_smbd.c

@@ -160 +160 @@
         int i;
 
-        max_grp = MIN(32, groups_max());
+        max_grp = MIN(128, groups_max());
         temp_groups = SMB_MALLOC_ARRAY(gid_t, max_grp);
         if (! temp_groups) {

branches/samba-3.3.x/source/libnet/libnet_join.c

@@ -1071 +1071 @@
 
         status = cli_rpc_pipe_open_schannel_with_key(
-                cli, &ndr_table_netlogon.syntax_id, PIPE_AUTH_LEVEL_PRIVACY,
+                cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
+                PIPE_AUTH_LEVEL_PRIVACY,
                 netbios_domain_name, netlogon_pipe->dc, &pipe_hnd);
 

branches/samba-3.3.x/source/libsmb/async_smb.c

@@ -239 +239 @@
         }
 
+        if ((raw_pdu_len == 4) && (CVAL(pdu, 0) == SMBkeepalive)) {
+                DEBUG(10, ("Got keepalive\n"));
+                TALLOC_FREE(pdu);
+                return;
+        }
+
         /*
          * TODO: Handle oplock break requests

branches/samba-3.3.x/source/libsmb/clireadwrite.c

@@ -155 +155 @@
 }
 
+struct cli_readall_state {
+        struct cli_state *cli;
+        uint16_t fnum;
+        off_t start_offset;
+        size_t size;
+        size_t received;
+        uint8_t *buf;
+};
+
+static void cli_readall_done(struct async_req *subreq);
+
+static struct async_req *cli_readall_send(TALLOC_CTX *mem_ctx,
+                                          struct cli_state *cli,
+                                          uint16_t fnum,
+                                          off_t offset, size_t size)
+{
+        struct async_req *req, *subreq;
+        struct cli_readall_state *state;
+
+        req = async_req_new(mem_ctx, cli->event_ctx);
+        if (req == NULL) {
+                return NULL;
+        }
+        state = talloc(req, struct cli_readall_state);
+        if (state == NULL) {
+                TALLOC_FREE(req);
+                return NULL;
+        }
+        req->private_data = state;
+
+        state->cli = cli;
+        state->fnum = fnum;
+        state->start_offset = offset;
+        state->size = size;
+        state->received = 0;
+        state->buf = NULL;
+
+        subreq = cli_read_andx_send(state, cli, fnum, offset, size);
+        if (subreq == NULL) {
+                TALLOC_FREE(req);
+                return NULL;
+        }
+        subreq->async.fn = cli_readall_done;
+        subreq->async.priv = req;
+        return req;
+}
+
+static void cli_readall_done(struct async_req *subreq)
+{
+        struct async_req *req = talloc_get_type_abort(
+                subreq->async.priv, struct async_req);
+        struct cli_readall_state *state = talloc_get_type_abort(
+                req->private_data, struct cli_readall_state);
+        ssize_t received;
+        uint8_t *buf;
+        NTSTATUS status;
+
+        status = cli_read_andx_recv(subreq, &received, &buf);
+        if (!NT_STATUS_IS_OK(status)) {
+                async_req_error(req, status);
+                return;
+        }
+
+        if (received == 0) {
+                /* EOF */
+                async_req_done(req);
+                return;
+        }
+
+        if ((state->received == 0) && (received == state->size)) {
+                /* Ideal case: Got it all in one run */
+                state->buf = buf;
+                state->received += received;
+                async_req_done(req);
+                return;
+        }
+
+        /*
+         * We got a short read, issue a read for the
+         * rest. Unfortunately we have to allocate the buffer
+         * ourselves now, as our caller expects to receive a single
+         * buffer. cli_read_andx does it from the buffer received from
+         * the net, but with a short read we have to put it together
+         * from several reads.
+         */
+
+        if (state->buf == NULL) {
+                state->buf = talloc_array(state, uint8_t, state->size);
+                if (async_req_nomem(state->buf, req)) {
+                        return;
+                }
+        }
+        memcpy(state->buf + state->received, buf, received);
+        state->received += received;
+
+        TALLOC_FREE(subreq);
+
+        if (state->received >= state->size) {
+                async_req_done(req);
+                return;
+        }
+
+        subreq = cli_read_andx_send(state, state->cli, state->fnum,
+                                    state->start_offset + state->received,
+                                    state->size - state->received);
+        if (async_req_nomem(subreq, req)) {
+                return;
+        }
+        subreq->async.fn = cli_readall_done;
+        subreq->async.priv = req;
+}
+
+static NTSTATUS cli_readall_recv(struct async_req *req, ssize_t *received,
+                                 uint8_t **rcvbuf)
+{
+        struct cli_readall_state *state = talloc_get_type_abort(
+                req->private_data, struct cli_readall_state);
+
+        SMB_ASSERT(req->state >= ASYNC_REQ_DONE);
+        if (req->state == ASYNC_REQ_ERROR) {
+                return req->status;
+        }
+        *received = state->received;
+        *rcvbuf = state->buf;
+        return NT_STATUS_OK;
+}
+
 /*
  * Parallel read support.
@@ -163 +290 @@
  */
 
+struct cli_pull_subreq {
+        struct async_req *req;
+        size_t received;
+        uint8_t *buf;
+};
+
 struct cli_pull_state {
         struct async_req *req;
@@ -180 +313 @@
          */
         int num_reqs;
-        struct async_req **reqs;
+        struct cli_pull_subreq *reqs;
 
         /*
@@ -269 +402 @@
         state->num_reqs = MIN(state->num_reqs, cli->max_mux);
 
-        state->reqs = TALLOC_ZERO_ARRAY(state, struct async_req *,
+        state->reqs = TALLOC_ZERO_ARRAY(state, struct cli_pull_subreq,
                                         state->num_reqs);
         if (state->reqs == NULL) {
@@ -289 +422 @@
                 request_thistime = MIN(size_left, state->chunk_size);
 
-                state->reqs[i] = cli_read_andx_send(
+                state->reqs[i].req = cli_readall_send(
                         state->reqs, cli, fnum,
                         state->start_offset + state->requested,
                         request_thistime);
 
-                if (state->reqs[i] == NULL) {
+                if (state->reqs[i].req == NULL) {
                         goto failed;
                 }
 
-                state->reqs[i]->async.fn = cli_pull_read_done;
-                state->reqs[i]->async.priv = result;
+                state->reqs[i].req->async.fn = cli_pull_read_done;
+                state->reqs[i].req->async.priv = result;
 
                 state->requested += request_thistime;
@@ -321 +454 @@
         struct cli_pull_state *state = talloc_get_type_abort(
                 pull_req->private_data, struct cli_pull_state);
-        struct cli_request *read_state = cli_request_get(read_req);
+        ssize_t received;
+        uint8_t *buf;
         NTSTATUS status;
-
-        status = cli_read_andx_recv(read_req, &read_state->data.read.received,
-                                    &read_state->data.read.rcvbuf);
+        int i;
+
+        status = cli_readall_recv(read_req, &received, &buf);
         if (!NT_STATUS_IS_OK(status)) {
                 async_req_error(state->req, status);
                 return;
         }
+
+        for (i=0; i<state->num_reqs; i++) {
+                if (state->reqs[i].req == read_req) {
+                        break;
+                }
+        }
+
+        if (i == state->num_reqs) {
+                /* Got something we did not send. Just drop it. */
+                TALLOC_FREE(read_req);
+                return;
+        }
+
+        state->reqs[i].received = received;
+        state->reqs[i].buf = buf;
 
         /*
@@ -340 +489 @@
          */
 
-        while (state->reqs[state->top_req] != NULL) {
-                struct cli_request *top_read;
+        while (state->reqs[state->top_req].req != NULL) {
+                struct cli_pull_subreq *top_read;
 
                 DEBUG(11, ("cli_pull_read_done: top_req = %d\n",
                            state->top_req));
 
-                if (state->reqs[state->top_req]->state < ASYNC_REQ_DONE) {
+                if (state->reqs[state->top_req].req->state < ASYNC_REQ_DONE) {
                         DEBUG(11, ("cli_pull_read_done: top request not yet "
                                    "done\n"));
@@ -352 +501 @@
                 }
 
-                top_read = cli_request_get(state->reqs[state->top_req]);
+                top_read = &state->reqs[state->top_req];
 
                 DEBUG(10, ("cli_pull_read_done: Pushing %d bytes, %d already "
-                           "pushed\n", (int)top_read->data.read.received,
+                           "pushed\n", (int)top_read->received,
                            (int)state->pushed));
 
-                status = state->sink((char *)top_read->data.read.rcvbuf,
-                                     top_read->data.read.received,
+                status = state->sink((char *)top_read->buf, top_read->received,
                                      state->priv);
                 if (!NT_STATUS_IS_OK(status)) {
@@ -365 +513 @@
                         return;
                 }
-                state->pushed += top_read->data.read.received;
-
-                TALLOC_FREE(state->reqs[state->top_req]);
+                state->pushed += top_read->received;
+
+                TALLOC_FREE(state->reqs[state->top_req].req);
 
                 if (state->requested < state->size) {
@@ -384 +532 @@
                                    state->top_req));
 
-                        new_req = cli_read_andx_send(
+                        new_req = cli_readall_send(
                                 state->reqs, state->cli, state->fnum,
                                 state->start_offset + state->requested,
@@ -396 +544 @@
                         new_req->async.priv = pull_req;
 
-                        state->reqs[state->top_req] = new_req;
+                        state->reqs[state->top_req].req = new_req;
                         state->requested += request_thistime;
                 }

branches/samba-3.3.x/source/libsmb/dsgetdcname.c

@@ -627 +627 @@
                 struct ip_service_name *r = &dclist[count];
 
-                r->port = dcs[count].port;
-                r->hostname = dcs[count].hostname;
+                r->port = dcs[i].port;
+                r->hostname = dcs[i].hostname;
 
                 /* If we don't have an IP list for a name, lookup it up */

branches/samba-3.3.x/source/libsmb/libsmb_context.c

@@ -656 +656 @@
         const char *signing_state = "off";
         
-        if (!context ||
-            ! workgroup || ! *workgroup ||
-            ! user || ! *user ||
-            ! password || ! *password) {
+        if (! context) {
             
                 return;
         }
 
+        if (! workgroup || ! *workgroup) {
+                workgroup = smbc_getWorkgroup(context);
+        }
+
+        if (! user) {
+                user = smbc_getUser(context);
+        }
+
+        if (! password) {
+                password = "";
+        }
+
         if (smbc_getOptionUseKerberos(context)) {
                 use_kerberos = True;

branches/samba-3.3.x/source/libsmb/libsmb_dir.c

@@ -626 +626 @@
                                  * Get the backup list ...
                                  */
-                                if (!name_status_find(server, 0, 0,
+                                if (!name_status_find(server, 0x20, 0x20,
                                                       &rem_ss, buserver)) {
 

branches/samba-3.3.x/source/libsmb/namequery.c

@@ -409 +409 @@
 
         for (i=0;i<count;i++) {
-                if (status[i].type == type)
+                /* Find first one of the requested type that's not a GROUP. */
+                if (status[i].type == type && ! (status[i].flags & 0x80))
                         break;
         }

branches/samba-3.3.x/source/libsmb/passchange.c

@@ -153 +153 @@
                 result = cli_rpc_pipe_open_ntlmssp(cli,
                                                    &ndr_table_samr.syntax_id,
+                                                   NCACN_NP,
                                                    PIPE_AUTH_LEVEL_PRIVACY,
                                                    "", /* what domain... ? */

branches/samba-3.3.x/source/locking/brlock.c

@@ -372 +372 @@
 ****************************************************************************/
 
-static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,               /* Output array. */
-                                                const struct lock_struct *ex,           /* existing lock. */
-                                                const struct lock_struct *plock,        /* proposed lock. */
-                                                bool *lock_was_added)
+static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,       /* Output array. */
+                                                struct lock_struct *ex,         /* existing lock. */
+                                                struct lock_struct *plock)      /* proposed lock. */
 {
         bool lock_types_differ = (ex->lock_type != plock->lock_type);
@@ -392 +391 @@
 
 /*********************************************
-                                             +---------+
-                                             | ex      |
-                                             +---------+
-                              +-------+
-                              | plock |
-                              +-------+
+                                        +---------+
+                                        | ex      |
+                                        +---------+
+                         +-------+
+                         | plock |
+                         +-------+
 OR....
-             +---------+
-             |  ex     |
-             +---------+
+        +---------+
+        |  ex     |
+        +---------+
 **********************************************/
 
         if ( (ex->start > (plock->start + plock->size)) ||
-                        (plock->start > (ex->start + ex->size))) {
+                (plock->start > (ex->start + ex->size))) {
+
                 /* No overlap with this lock - copy existing. */
+
                 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
                 return 1;
@@ -418 +419 @@
         |       plock               | -> replace with plock.
         +---------------------------+
+OR
+             +---------------+
+             |       ex      |
+             +---------------+
+        +---------------------------+
+        |       plock               | -> replace with plock.
+        +---------------------------+
+
 **********************************************/
 
         if ( (ex->start >= plock->start) &&
-                        (ex->start + ex->size <= plock->start + plock->size) ) {
-                memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-                *lock_was_added = True;
-                return 1;
+                (ex->start + ex->size <= plock->start + plock->size) ) {
+
+                /* Replace - discard existing lock. */
+
+                return 0;
         }
 
 /*********************************************
+Adjacent after.
+                        +-------+
+                        |  ex   |
+                        +-------+
+        +---------------+
+        |   plock       |
+        +---------------+
+
+BECOMES....
+        +---------------+-------+
+        |   plock       | ex    | - different lock types.
+        +---------------+-------+
+OR.... (merge)
+        +-----------------------+
+        |   plock               | - same lock type.
+        +-----------------------+
+**********************************************/
+
+        if (plock->start + plock->size == ex->start) {
+
+                /* If the lock types are the same, we merge, if different, we
+                   add the remainder of the old lock. */
+
+                if (lock_types_differ) {
+                        /* Add existing. */
+                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
+                        return 1;
+                } else {
+                        /* Merge - adjust incoming lock as we may have more
+                         * merging to come. */
+                        plock->size += ex->size;
+                        return 0;
+                }
+        }
+
+/*********************************************
+Adjacent before.
+        +-------+
+        |  ex   |
+        +-------+
+                +---------------+
+                |   plock       |
+                +---------------+
+BECOMES....
+        +-------+---------------+
+        | ex    |   plock       | - different lock types
+        +-------+---------------+
+
+OR.... (merge)
+        +-----------------------+
+        |      plock            | - same lock type.
+        +-----------------------+
+
+**********************************************/
+
+        if (ex->start + ex->size == plock->start) {
+
+                /* If the lock types are the same, we merge, if different, we
+                   add the existing lock. */
+
+                if (lock_types_differ) {
+                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
+                        return 1;
+                } else {
+                        /* Merge - adjust incoming lock as we may have more
+                         * merging to come. */
+                        plock->start = ex->start;
+                        plock->size += ex->size;
+                        return 0;
+                }
+        }
+
+/*********************************************
+Overlap after.
         +-----------------------+
         |          ex           |
@@ -434 +518 @@
         |   plock       |
         +---------------+
-OR....
-                        +-------+
-                        |  ex   |
-                        +-------+
+OR
+               +----------------+
+               |       ex       |
+               +----------------+
         +---------------+
         |   plock       |
@@ -448 +532 @@
 OR.... (merge)
         +-----------------------+
-        |   ex                  | - same lock type.
+        |   plock               | - same lock type.
         +-----------------------+
 **********************************************/
 
         if ( (ex->start >= plock->start) &&
-                                (ex->start <= plock->start + plock->size) &&
-                                (ex->start + ex->size > plock->start + plock->size) ) {
-
-                *lock_was_added = True;
+                (ex->start <= plock->start + plock->size) &&
+                (ex->start + ex->size > plock->start + plock->size) ) {
 
                 /* If the lock types are the same, we merge, if different, we
-                   add the new lock before the old. */
+                   add the remainder of the old lock. */
 
                 if (lock_types_differ) {
-                        /* Add new. */
-                        memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-                        memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
+                        /* Add remaining existing. */
+                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
                         /* Adjust existing start and size. */
-                        lck_arr[1].start = plock->start + plock->size;
-                        lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
-                        return 2;
+                        lck_arr[0].start = plock->start + plock->size;
+                        lck_arr[0].size = (ex->start + ex->size) - (plock->start + plock->size);
+                        return 1;
                 } else {
-                        /* Merge. */
-                        memcpy(&lck_arr[0], plock, sizeof(struct lock_struct));
-                        /* Set new start and size. */
-                        lck_arr[0].start = plock->start;
-                        lck_arr[0].size = (ex->start + ex->size) - plock->start;
-                        return 1;
+                        /* Merge - adjust incoming lock as we may have more
+                         * merging to come. */
+                        plock->size += (ex->start + ex->size) - (plock->start + plock->size);
+                        return 0;
                 }
         }
 
 /*********************************************
-   +-----------------------+
-   |  ex                   |
-   +-----------------------+
-           +---------------+
-           |   plock       |
-           +---------------+
-OR....
-   +-------+        
-   |  ex   |
-   +-------+
-           +---------------+
-           |   plock       |
-           +---------------+
+Overlap before.
+        +-----------------------+
+        |  ex                   |
+        +-----------------------+
+                +---------------+
+                |   plock       |
+                +---------------+
+OR
+        +-------------+
+        |  ex         |
+        +-------------+
+                +---------------+
+                |   plock       |
+                +---------------+
+
 BECOMES....
-   +-------+---------------+
-   | ex    |   plock       | - different lock types
-   +-------+---------------+
+        +-------+---------------+
+        | ex    |   plock       | - different lock types
+        +-------+---------------+
 
 OR.... (merge)
-   +-----------------------+
-   | ex                    | - same lock type.
-   +-----------------------+
+        +-----------------------+
+        |      plock            | - same lock type.
+        +-----------------------+
 
 **********************************************/
@@ -509 +590 @@
                         (ex->start + ex->size <= plock->start + plock->size) ) {
 
-                *lock_was_added = True;
-
                 /* If the lock types are the same, we merge, if different, we
-                   add the new lock after the old. */
+                   add the truncated old lock. */
 
                 if (lock_types_differ) {
                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                        memcpy(&lck_arr[1], plock, sizeof(struct lock_struct));
                         /* Adjust existing size. */
                         lck_arr[0].size = plock->start - ex->start;
-                        return 2;
+                        return 1;
                 } else {
-                        /* Merge. */
-                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                        /* Adjust existing size. */
-                        lck_arr[0].size = (plock->start + plock->size) - ex->start;
-                        return 1;
+                        /* Merge - adjust incoming lock as we may have more
+                         * merging to come. MUST ADJUST plock SIZE FIRST ! */
+                        plock->size += (plock->start - ex->start);
+                        plock->start = ex->start;
+                        return 0;
                 }
         }
 
 /*********************************************
+Complete overlap.
         +---------------------------+
         |        ex                 |
@@ -542 +621 @@
 OR
         +---------------------------+
-        |        ex                 | - same lock type.
+        |        plock              | - same lock type.
         +---------------------------+
 **********************************************/
 
         if ( (ex->start < plock->start) && (ex->start + ex->size > plock->start + plock->size) ) {
-                *lock_was_added = True;
 
                 if (lock_types_differ) {
@@ -554 +632 @@
 
                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                        memcpy(&lck_arr[1], plock, sizeof(struct lock_struct));
-                        memcpy(&lck_arr[2], ex, sizeof(struct lock_struct));
+                        memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
 
                         /* Adjust first existing size. */
@@ -561 +638 @@
 
                         /* Adjust second existing start and size. */
-                        lck_arr[2].start = plock->start + plock->size;
-                        lck_arr[2].size = (ex->start + ex->size) - (plock->start + plock->size);
-                        return 3;
+                        lck_arr[1].start = plock->start + plock->size;
+                        lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
+                        return 2;
                 } else {
-                        /* Just eat plock. */
-                        memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
-                        return 1;
+                        /* Just eat the existing locks, merge them into plock. */
+                        plock->start = ex->start;
+                        plock->size = ex->size;
+                        return 0;
                 }
         }
@@ -591 +669 @@
         struct lock_struct *locks = br_lck->lock_data;
         struct lock_struct *tp;
-        bool lock_was_added = False;
         bool signal_pending_read = False;
 
@@ -613 +690 @@
                 return NT_STATUS_NO_MEMORY;
         }
-        
+
         count = 0;
+
         for (i=0; i < br_lck->num_locks; i++) {
                 struct lock_struct *curr_lock = &locks[i];
@@ -649 +727 @@
 
                         /* Work out overlaps. */
-                        count += brlock_posix_split_merge(&tp[count], curr_lock, plock, &lock_was_added);
-                }
-        }
-
-        if (!lock_was_added) {
-                memcpy(&tp[count], plock, sizeof(struct lock_struct));
-                count++;
-        }
+                        count += brlock_posix_split_merge(&tp[count], curr_lock, plock);
+                }
+        }
+
+        /* Try and add the lock in order, sorted by lock start. */
+        for (i=0; i < count; i++) {
+                struct lock_struct *curr_lock = &tp[i];
+
+                if (curr_lock->start <= plock->start) {
+                        continue;
+                }
+        }
+
+        if (i < count) {
+                memmove(&tp[i+1], &tp[i],
+                        (count - i)*sizeof(struct lock_struct));
+        }
+        memcpy(&tp[i], plock, sizeof(struct lock_struct));
+        count++;
 
         /* We can get the POSIX lock, now see if it needs to
@@ -688 +777 @@
         }
 
-        /* Realloc so we don't leak entries per lock call. */
-        tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
-        if (!tp) {
-                return NT_STATUS_NO_MEMORY;
-        }
+        /* If we didn't use all the allocated size,
+         * Realloc so we don't leak entries per lock call. */
+        if (count < br_lck->num_locks + 2) {
+                tp = (struct lock_struct *)SMB_REALLOC(tp, count * sizeof(*locks));
+                if (!tp) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+        }
+
         br_lck->num_locks = count;
         SAFE_FREE(br_lck->lock_data);
@@ -891 +984 @@
 static bool brl_unlock_posix(struct messaging_context *msg_ctx,
                              struct byte_range_lock *br_lck,
-                             const struct lock_struct *plock)
+                             struct lock_struct *plock)
 {
         unsigned int i, j, count;
@@ -923 +1016 @@
         for (i = 0; i < br_lck->num_locks; i++) {
                 struct lock_struct *lock = &locks[i];
-                struct lock_struct tmp_lock[3];
-                bool lock_was_added = False;
                 unsigned int tmp_count;
 
@@ -935 +1026 @@
                 }
 
-                /* Work out overlaps. */
-                tmp_count = brlock_posix_split_merge(&tmp_lock[0], &locks[i], plock, &lock_was_added);
-
-                if (tmp_count == 1) {
-                        /* Ether the locks didn't overlap, or the unlock completely
-                           overlapped this lock. If it didn't overlap, then there's
-                           no change in the locks. */
-                        if (tmp_lock[0].lock_type != UNLOCK_LOCK) {
-                                SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                                /* No change in this lock. */
-                                memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                                count++;
-                        } else {
-                                SMB_ASSERT(tmp_lock[0].lock_type == UNLOCK_LOCK);
-                                overlap_found = True;
+                if (lock->lock_flav == WINDOWS_LOCK) {
+                        /* Do any Windows flavour locks conflict ? */
+                        if (brl_conflict(lock, plock)) {
+                                SAFE_FREE(tp);
+                                return false;
                         }
-                        continue;
-                } else if (tmp_count == 2) {
-                        /* The unlock overlapped an existing lock. Copy the truncated
-                           lock into the lock array. */
-                        if (tmp_lock[0].lock_type != UNLOCK_LOCK) {
-                                SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                                SMB_ASSERT(tmp_lock[1].lock_type == UNLOCK_LOCK);
-                                memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                                if (tmp_lock[0].size != locks[i].size) {
-                                        overlap_found = True;
-                                }
-                        } else {
-                                SMB_ASSERT(tmp_lock[0].lock_type == UNLOCK_LOCK);
-                                SMB_ASSERT(tmp_lock[1].lock_type == locks[i].lock_type);
-                                memcpy(&tp[count], &tmp_lock[1], sizeof(struct lock_struct));
-                                if (tmp_lock[1].start != locks[i].start) {
-                                        overlap_found = True;
-                                }
-                        }
+                        /* Just copy the Windows lock into the new array. */
+                        memcpy(&tp[count], lock, sizeof(struct lock_struct));
                         count++;
                         continue;
-                } else {
-                        /* tmp_count == 3 - (we split a lock range in two). */
-                        SMB_ASSERT(tmp_lock[0].lock_type == locks[i].lock_type);
-                        SMB_ASSERT(tmp_lock[1].lock_type == UNLOCK_LOCK);
-                        SMB_ASSERT(tmp_lock[2].lock_type == locks[i].lock_type);
-
-                        memcpy(&tp[count], &tmp_lock[0], sizeof(struct lock_struct));
-                        count++;
-                        memcpy(&tp[count], &tmp_lock[2], sizeof(struct lock_struct));
-                        count++;
-                        overlap_found = True;
+                }
+
+                /* Work out overlaps. */
+                tmp_count = brlock_posix_split_merge(&tp[count], lock, plock);
+
+                if (tmp_count == 0) {
+                        /* plock overlapped the existing lock completely,
+                           or replaced it. Don't copy the existing lock. */
+                        overlap_found = true;
+                } else if (tmp_count == 1) {
+                        /* Either no overlap, (simple copy of existing lock) or
+                         * an overlap of an existing lock. */
+                        /* If the lock changed size, we had an overlap. */
+                        if (tp[count].size != lock->size) {
+                                overlap_found = true;
+                        }
+                        count += tmp_count;
+                } else if (tmp_count == 2) {
+                        /* We split a lock range in two. */
+                        overlap_found = true;
+                        count += tmp_count;
+
                         /* Optimisation... */
                         /* We know we're finished here as we can't overlap any
                            more POSIX locks. Copy the rest of the lock array. */
+
                         if (i < br_lck->num_locks - 1) {
-                                memcpy(&tp[count], &locks[i+1], 
+                                memcpy(&tp[count], &locks[i+1],
                                         sizeof(*locks)*((br_lck->num_locks-1) - i));
                                 count += ((br_lck->num_locks-1) - i);
@@ -993 +1069 @@
                         break;
                 }
+
         }
 

branches/samba-3.3.x/source/modules/vfs_default.c

@@ -994 +994 @@
         }
         else {
-                ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
+                if (lp_posix_pathnames()) {
+                        ret = SMB_VFS_LSTAT(handle->conn, fname, &sbuf);
+                } else {
+                        ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
+                }
         }
 

branches/samba-3.3.x/source/nsswitch/libwbclient/wbc_pam.c

@@ -440 +440 @@
                                 MIN(params->password.response.lm_length,
                                     sizeof(request.data.auth_crap.lm_resp));
-                request.data.auth_crap.nt_resp_len =
-                                MIN(params->password.response.nt_length,
-                                    sizeof(request.data.auth_crap.nt_resp));
                 if (params->password.response.lm_data) {
                         memcpy(request.data.auth_crap.lm_resp,
@@ -448 +445 @@
                                request.data.auth_crap.lm_resp_len);
                 }
-                if (params->password.response.nt_data) {
+                request.data.auth_crap.nt_resp_len = params->password.response.nt_length;
+                if (params->password.response.nt_length > sizeof(request.data.auth_crap.nt_resp)) {
+                        request.flags |= WBFLAG_BIG_NTLMV2_BLOB;
+                        request.extra_len = params->password.response.nt_length;
+                        request.extra_data.data = talloc_zero_array(NULL, char, request.extra_len);
+                        if (request.extra_data.data == NULL) {
+                                wbc_status = WBC_ERR_NO_MEMORY;
+                                BAIL_ON_WBC_ERROR(wbc_status);
+                        }
+                        memcpy(request.extra_data.data,
+                               params->password.response.nt_data,
+                               request.data.auth_crap.nt_resp_len);
+                } else if (params->password.response.nt_data) {
                         memcpy(request.data.auth_crap.nt_resp,
                                params->password.response.nt_data,
@@ -493 +502 @@
         if (response.extra_data.data)
                 free(response.extra_data.data);
+
+        talloc_free(request.extra_data.data);
 
         return wbc_status;

branches/samba-3.3.x/source/nsswitch/libwbclient/wbc_sid.c

@@ -282 +282 @@
                 if (pdomain != NULL) {
                         *pdomain = domain;
+                } else {
+                        talloc_free(domain);
                 }
                 if (pname != NULL) {
                         *pname = name;
+                } else {
+                        talloc_free(name);
                 }
                 if (pname_type != NULL) {

branches/samba-3.3.x/source/nsswitch/libwbclient/wbc_util.c

@@ -285 +285 @@
                 BAIL_ON_WBC_ERROR(wbc_status);
         }
+
+        ZERO_STRUCTP(info);
 
         r = info_string;

branches/samba-3.3.x/source/nsswitch/pam_winbind.c

@@ -3057 +3057 @@
                                                 pass_new, pwdlastset_update);
                 if (ret) {
-                        _pam_overwrite(pass_new);
-                        _pam_overwrite(pass_old);
                         pass_old = pass_new = NULL;
                         goto out;
@@ -3087 +3085 @@
                                                    &error, &info, &policy,
                                                    NULL, &username_ret);
-                        _pam_overwrite(pass_new);
-                        _pam_overwrite(pass_old);
                         pass_old = pass_new = NULL;
 

branches/samba-3.3.x/source/pam_smbpass/pam_smb_auth.c

@@ -180 +180 @@
         retval = PAM_SUCCESS;
 
-        pam_get_data(pamh, "smb_setcred_return", (const void **) &pretval);
+        _pam_get_data(pamh, "smb_setcred_return", &pretval);
         if(pretval) {
                 retval = *pretval;
@@ -200 +200 @@
 
         /* Get the authtok; if we don't have one, silently fail. */
-        retval = pam_get_item( pamh, PAM_AUTHTOK, (const void **) &pass );
+        retval = _pam_get_item( pamh, PAM_AUTHTOK, &pass );
 
         if (retval != PAM_SUCCESS) {

branches/samba-3.3.x/source/pam_smbpass/pam_smb_passwd.c

@@ -230 +230 @@
 
         if (off( SMB_NOT_SET_PASS, ctrl )) {
-            retval = pam_get_item( pamh, PAM_OLDAUTHTOK,
-                                   (const void **)&pass_old );
+            retval = _pam_get_item( pamh, PAM_OLDAUTHTOK,
+                                   &pass_old );
         } else {
-            retval = pam_get_data( pamh, _SMB_OLD_AUTHTOK,
-                                   (const void **)&pass_old );
+            retval = _pam_get_data( pamh, _SMB_OLD_AUTHTOK,
+                                   &pass_old );
             if (retval == PAM_NO_MODULE_DATA) {
                 pass_old = NULL;

branches/samba-3.3.x/source/pam_smbpass/support.c

@@ -84 +84 @@
         struct pam_conv *conv;
 
-        retval = pam_get_item(pamh, PAM_CONV, (const void **) &conv);
+        retval = _pam_get_item(pamh, PAM_CONV, &conv);
         if (retval == PAM_SUCCESS) {
 
@@ -277 +277 @@
             /* log the number of authentication failures */
             if (failure->count != 0) {
-                pam_get_item( pamh, PAM_SERVICE, (const void **) &service );
+                _pam_get_item( pamh, PAM_SERVICE, &service );
                 _log_err( LOG_NOTICE
                           , "%d authentication %s "
@@ -333 +333 @@
             const char *service;
 
-            pam_get_item( pamh, PAM_SERVICE, (const void **)&service );
+            _pam_get_item( pamh, PAM_SERVICE, &service );
             _log_err( LOG_NOTICE, "failed auth request by %s for service %s as %s",
                       uidtoname(getuid()), service ? service : "**unknown**", name);
@@ -368 +368 @@
         const char *service;
 
-        pam_get_item( pamh, PAM_SERVICE, (const void **)&service );
+        _pam_get_item( pamh, PAM_SERVICE, &service );
 
         if (data_name != NULL) {
@@ -381 +381 @@
 
                 /* any previous failures for this user ? */
-                pam_get_data(pamh, data_name, (const void **) &old);
+                _pam_get_data(pamh, data_name, &old);
 
                 if (old != NULL) {
@@ -486 +486 @@
 
     if (on(SMB_TRY_FIRST_PASS, ctrl) || on(SMB_USE_FIRST_PASS, ctrl)) {
-        retval = pam_get_item( pamh, authtok_flag, (const void **) &item );
+        retval = _pam_get_item( pamh, authtok_flag, &item );
         if (retval != PAM_SUCCESS) {
             /* very strange. */
@@ -579 +579 @@
         _pam_delete( token );           /* clean it up */
         if (retval != PAM_SUCCESS
-            || (retval = pam_get_item( pamh, authtok_flag
-                            ,(const void **)&item )) != PAM_SUCCESS)
+            || (retval = _pam_get_item( pamh, authtok_flag
+                            ,&item )) != PAM_SUCCESS)
         {
             _log_err( LOG_CRIT, "error manipulating password" );
@@ -593 +593 @@
         retval = pam_set_data( pamh, data_name, (void *) token, _cleanup );
         if (retval != PAM_SUCCESS
-            || (retval = pam_get_data( pamh, data_name, (const void **)&item ))
+            || (retval = _pam_get_data( pamh, data_name, &item ))
                              != PAM_SUCCESS)
         {
@@ -631 +631 @@
     return PAM_SUCCESS;
 }
+
+/*
+ * Work around the pam API that has functions with void ** as parameters
+ * These lead to strict aliasing warnings with gcc.
+ */
+int _pam_get_item(const pam_handle_t *pamh,
+                  int item_type,
+                  const void *_item)
+{
+        const void **item = (const void **)_item;
+        return pam_get_item(pamh, item_type, item);
+}
+
+int _pam_get_data(const pam_handle_t *pamh,
+                  const char *module_data_name,
+                  const void *_data)
+{
+        const void **data = (const void **)_data;
+        return pam_get_data(pamh, module_data_name, data);
+}

branches/samba-3.3.x/source/pam_smbpass/support.h

@@ -49 +49 @@
 extern int _pam_smb_approve_pass(pam_handle_t *, unsigned int, const char *,
                                  const char *);
+
+int _pam_get_item(const pam_handle_t *pamh,
+                  int item_type,
+                  const void *_item);
+int _pam_get_data(const pam_handle_t *pamh,
+                  const char *module_data_name,
+                  const void *_data);

branches/samba-3.3.x/source/passdb/lookup_sid.c

@@ -1086 +1086 @@
         DATA_BLOB cache_value;
 
-        if (!memcache_lookup(NULL, SID_UID_CACHE,
+        if (!memcache_lookup(NULL, SID_GID_CACHE,
                              data_blob_const(psid, ndr_size_dom_sid(psid, 0)),
                              &cache_value)) {

branches/samba-3.3.x/source/passdb/pdb_ldap.c

@@ -1701 +1701 @@
                 char *utf8_dn;
                 size_t converted_size;
+                int ret;
 
                 if (!ldap_state->is_nds_ldap) {
@@ -1732 +1733 @@
 
                 if ((ber_printf (ber, "{") < 0) ||
-                    (ber_printf (ber, "ts", LDAP_TAG_EXOP_MODIFY_PASSWD_ID, utf8_dn) < 0) ||
-                    (ber_printf (ber, "ts", LDAP_TAG_EXOP_MODIFY_PASSWD_NEW, utf8_password) < 0) ||
-                    (ber_printf (ber, "n}") < 0)) {
-                        DEBUG(0,("ldapsam_modify_entry: ber_printf returns a value <0\n"));
-                       ber_free(ber,1);
-                       SAFE_FREE(utf8_dn);
-                       SAFE_FREE(utf8_password);
-                       return NT_STATUS_UNSUCCESSFUL;
+                    (ber_printf (ber, "ts", LDAP_TAG_EXOP_MODIFY_PASSWD_ID,
+                                 utf8_dn) < 0)) {
+                        DEBUG(0,("ldapsam_modify_entry: ber_printf returns a "
+                                 "value <0\n"));
+                        ber_free(ber,1);
+                        SAFE_FREE(utf8_dn);
+                        SAFE_FREE(utf8_password);
+                        return NT_STATUS_UNSUCCESSFUL;
+                }
+
+                if ((utf8_password != NULL) && (*utf8_password != '\0')) {
+                        ret = ber_printf(ber, "ts}",
+                                         LDAP_TAG_EXOP_MODIFY_PASSWD_NEW,
+                                         utf8_password);
+                } else {
+                        ret = ber_printf(ber, "}");
+                }
+
+                if (ret < 0) {
+                        DEBUG(0,("ldapsam_modify_entry: ber_printf returns a "
+                                 "value <0\n"));
+                        ber_free(ber,1);
+                        SAFE_FREE(utf8_dn);
+                        SAFE_FREE(utf8_password);
+                        return NT_STATUS_UNSUCCESSFUL;
                 }
 

branches/samba-3.3.x/source/profile/profile.c

@@ -228 +228 @@
         profile_h = (struct profile_header *)shmat(shm_id, 0, 
                                                    read_only?SHM_RDONLY:0);
-        if ((long)profile_p == -1) {
+        if ((long)profile_h == -1) {
                 DEBUG(0,("Can't attach to IPC area. Error was %s\n", 
                          strerror(errno)));

branches/samba-3.3.x/source/rpc_client/cli_lsarpc.c

@@ -127 +127 @@
                                                char **domains,
                                                char **names,
-                                               enum lsa_SidType *types)
+                                               enum lsa_SidType *types,
+                                               bool use_lookupsids3)
 {
         NTSTATUS result = NT_STATUS_OK;
@@ -160 +161 @@
         }
 
-        result = rpccli_lsa_LookupSids(cli, mem_ctx,
-                                       pol,
-                                       &sid_array,
-                                       &ref_domains,
-                                       &lsa_names,
-                                       level,
-                                       &count);
+        if (use_lookupsids3) {
+                struct lsa_TransNameArray2 lsa_names2;
+                uint32_t n;
+
+                ZERO_STRUCT(lsa_names2);
+
+                result = rpccli_lsa_LookupSids3(cli, mem_ctx,
+                                                &sid_array,
+                                                &ref_domains,
+                                                &lsa_names2,
+                                                level,
+                                                &count,
+                                                0,
+                                                0);
+
+                if (!NT_STATUS_IS_ERR(result)) {
+                        lsa_names.count = lsa_names2.count;
+                        lsa_names.names = talloc_array(mem_ctx, struct lsa_TranslatedName, lsa_names.count);
+                        if (!lsa_names.names) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        for (n=0; n < lsa_names.count; n++) {
+                                lsa_names.names[n].sid_type     = lsa_names2.names[n].sid_type;
+                                lsa_names.names[n].name         = lsa_names2.names[n].name;
+                                lsa_names.names[n].sid_index    = lsa_names2.names[n].sid_index;
+                        }
+                }
+
+        } else {
+                result = rpccli_lsa_LookupSids(cli, mem_ctx,
+                                               pol,
+                                               &sid_array,
+                                               &ref_domains,
+                                               &lsa_names,
+                                               level,
+                                               &count);
+        }
 
         DEBUG(10, ("LSA_LOOKUPSIDS returned '%s', mapped count = %d'\n",
@@ -246 +277 @@
 #define LOOKUP_SIDS_HUNK_SIZE 1000
 
-NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli,
-                                TALLOC_CTX *mem_ctx,
-                                POLICY_HND *pol,
-                                int num_sids,
-                                const DOM_SID *sids,
-                                char ***pdomains,
-                                char ***pnames,
-                                enum lsa_SidType **ptypes)
+static NTSTATUS rpccli_lsa_lookup_sids_generic(struct rpc_pipe_client *cli,
+                                               TALLOC_CTX *mem_ctx,
+                                               struct policy_handle *pol,
+                                               int num_sids,
+                                               const DOM_SID *sids,
+                                               char ***pdomains,
+                                               char ***pnames,
+                                               enum lsa_SidType **ptypes,
+                                               bool use_lookupsids3)
 {
         NTSTATUS result = NT_STATUS_OK;
@@ -312 +344 @@
                                                              hunk_domains,
                                                              hunk_names,
-                                                             hunk_types);
+                                                             hunk_types,
+                                                             use_lookupsids3);
 
                 if (!NT_STATUS_IS_OK(hunk_result) &&
@@ -353 +386 @@
 }
 
+NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli,
+                                TALLOC_CTX *mem_ctx,
+                                struct policy_handle *pol,
+                                int num_sids,
+                                const DOM_SID *sids,
+                                char ***pdomains,
+                                char ***pnames,
+                                enum lsa_SidType **ptypes)
+{
+        return rpccli_lsa_lookup_sids_generic(cli, mem_ctx, pol, num_sids, sids,
+                                              pdomains, pnames, ptypes, false);
+}
+
+NTSTATUS rpccli_lsa_lookup_sids3(struct rpc_pipe_client *cli,
+                                 TALLOC_CTX *mem_ctx,
+                                 struct policy_handle *pol,
+                                 int num_sids,
+                                 const DOM_SID *sids,
+                                 char ***pdomains,
+                                 char ***pnames,
+                                 enum lsa_SidType **ptypes)
+{
+        return rpccli_lsa_lookup_sids_generic(cli, mem_ctx, pol, num_sids, sids,
+                                              pdomains, pnames, ptypes, true);
+}
+
 /** Lookup a list of names */
 
-NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
-                                 TALLOC_CTX *mem_ctx,
-                                 POLICY_HND *pol, int num_names,
-                                 const char **names,
-                                 const char ***dom_names,
-                                 int level,
-                                 DOM_SID **sids,
-                                 enum lsa_SidType **types)
+static NTSTATUS rpccli_lsa_lookup_names_generic(struct rpc_pipe_client *cli,
+                                                TALLOC_CTX *mem_ctx,
+                                                struct policy_handle *pol, int num_names,
+                                                const char **names,
+                                                const char ***dom_names,
+                                                int level,
+                                                DOM_SID **sids,
+                                                enum lsa_SidType **types,
+                                                bool use_lookupnames4)
 {
         NTSTATUS result;
@@ -369 +429 @@
         struct lsa_RefDomainList *domains = NULL;
         struct lsa_TransSidArray sid_array;
+        struct lsa_TransSidArray3 sid_array3;
         uint32_t count = 0;
 
         ZERO_STRUCT(sid_array);
+        ZERO_STRUCT(sid_array3);
 
         lsa_names = TALLOC_ARRAY(mem_ctx, struct lsa_String, num_names);
@@ -382 +444 @@
         }
 
-        result = rpccli_lsa_LookupNames(cli, mem_ctx,
-                                        pol,
-                                        num_names,
-                                        lsa_names,
-                                        &domains,
-                                        &sid_array,
-                                        level,
-                                        &count);
+        if (use_lookupnames4) {
+                result = rpccli_lsa_LookupNames4(cli, mem_ctx,
+                                                 num_names,
+                                                 lsa_names,
+                                                 &domains,
+                                                 &sid_array3,
+                                                 level,
+                                                 &count,
+                                                 0,
+                                                 0);
+        } else {
+                result = rpccli_lsa_LookupNames(cli, mem_ctx,
+                                                pol,
+                                                num_names,
+                                                lsa_names,
+                                                &domains,
+                                                &sid_array,
+                                                level,
+                                                &count);
+        }
 
         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
@@ -436 +510 @@
 
         for (i = 0; i < num_names; i++) {
-                uint32_t dom_idx = sid_array.sids[i].sid_index;
-                uint32_t dom_rid = sid_array.sids[i].rid;
+                uint32_t dom_idx;
                 DOM_SID *sid = &(*sids)[i];
+
+                if (use_lookupnames4) {
+                        dom_idx         = sid_array3.sids[i].sid_index;
+                        (*types)[i]     = sid_array3.sids[i].sid_type;
+                } else {
+                        dom_idx         = sid_array.sids[i].sid_index;
+                        (*types)[i]     = sid_array.sids[i].sid_type;
+                }
 
                 /* Translate optimised sid through domain index array */
@@ -449 +530 @@
                 }
 
-                sid_copy(sid, domains->domains[dom_idx].sid);
-
-                if (dom_rid != 0xffffffff) {
-                        sid_append_rid(sid, dom_rid);
-                }
-
-                (*types)[i] = sid_array.sids[i].sid_type;
+                if (use_lookupnames4) {
+                        sid_copy(sid, sid_array3.sids[i].sid);
+                } else {
+                        sid_copy(sid, domains->domains[dom_idx].sid);
+
+                        if (sid_array.sids[i].rid != 0xffffffff) {
+                                sid_append_rid(sid, sid_array.sids[i].rid);
+                        }
+                }
 
                 if (dom_names == NULL) {
@@ -468 +551 @@
         return result;
 }
+
+NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
+                                 TALLOC_CTX *mem_ctx,
+                                 struct policy_handle *pol, int num_names,
+                                 const char **names,
+                                 const char ***dom_names,
+                                 int level,
+                                 DOM_SID **sids,
+                                 enum lsa_SidType **types)
+{
+        return rpccli_lsa_lookup_names_generic(cli, mem_ctx, pol, num_names,
+                                               names, dom_names, level, sids,
+                                               types, false);
+}
+
+NTSTATUS rpccli_lsa_lookup_names4(struct rpc_pipe_client *cli,
+                                  TALLOC_CTX *mem_ctx,
+                                  struct policy_handle *pol, int num_names,
+                                  const char **names,
+                                  const char ***dom_names,
+                                  int level,
+                                  DOM_SID **sids,
+                                  enum lsa_SidType **types)
+{
+        return rpccli_lsa_lookup_names_generic(cli, mem_ctx, pol, num_names,
+                                               names, dom_names, level, sids,
+                                               types, true);
+}

branches/samba-3.3.x/source/rpc_client/cli_netlogon.c

@@ -602 +602 @@
                 struct samr_Password new_password;
 
-                cred_hash3(new_password.hash,
-                           new_trust_passwd_hash,
-                           cli->dc->sess_key, 1);
+                des_crypt112_16(new_password.hash,
+                                new_trust_passwd_hash,
+                                cli->dc->sess_key, 1);
 
                 result = rpccli_netr_ServerPasswordSet(cli, mem_ctx,

branches/samba-3.3.x/source/rpc_client/cli_pipe.c

@@ -491 +491 @@
         }
 
-        if (auth_len != RPC_AUTH_SCHANNEL_SIGN_OR_SEAL_CHK_LEN) {
+        if (auth_len < RPC_AUTH_SCHANNEL_SIGN_OR_SEAL_CHK_LEN) {
                 DEBUG(0,("cli_pipe_verify_schannel: auth_len %u.\n", (unsigned int)auth_len ));
                 return NT_STATUS_INVALID_PARAMETER;
@@ -2320 +2320 @@
         return NT_STATUS_OK;
 }
-
-unsigned int rpccli_set_timeout(struct rpc_pipe_client *cli,
+unsigned int rpccli_set_timeout(struct rpc_pipe_client *rpc_cli,
                                 unsigned int timeout)
 {
-        return cli_set_timeout(cli->trans.np.cli, timeout);
+        struct cli_state *cli = rpc_pipe_np_smb_conn(rpc_cli);
+
+        if (cli == NULL) {
+                return 0;
+        }
+        return cli_set_timeout(cli, timeout);
 }
 
@@ -2932 +2936 @@
 
 static NTSTATUS cli_rpc_pipe_open(struct cli_state *cli,
+                                  enum dcerpc_transport_t transport,
                                   const struct ndr_syntax_id *interface,
                                   struct rpc_pipe_client **presult)
 {
-        if (ndr_syntax_id_equal(interface, &ndr_table_drsuapi.syntax_id)) {
-                /*
-                 * We should have a better way to figure out this drsuapi
-                 * speciality...
-                 */
+        switch (transport) {
+        case NCACN_IP_TCP:
                 return rpc_pipe_open_tcp(NULL, cli->desthost, interface,
                                          presult);
-        }
-
-        return rpc_pipe_open_np(cli, interface, presult);
+        case NCACN_NP:
+                return rpc_pipe_open_np(cli, interface, presult);
+        default:
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
 }
 
@@ -2951 +2955 @@
  ****************************************************************************/
 
-NTSTATUS cli_rpc_pipe_open_noauth(struct cli_state *cli,
-                                  const struct ndr_syntax_id *interface,
-                                  struct rpc_pipe_client **presult)
+NTSTATUS cli_rpc_pipe_open_noauth_transport(struct cli_state *cli,
+                                            enum dcerpc_transport_t transport,
+                                            const struct ndr_syntax_id *interface,
+                                            struct rpc_pipe_client **presult)
 {
         struct rpc_pipe_client *result;
@@ -2959 +2964 @@
         NTSTATUS status;
 
-        status = cli_rpc_pipe_open(cli, interface, &result);
+        status = cli_rpc_pipe_open(cli, transport, interface, &result);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
@@ -3016 +3021 @@
 
 /****************************************************************************
+ ****************************************************************************/
+
+NTSTATUS cli_rpc_pipe_open_noauth(struct cli_state *cli,
+                                  const struct ndr_syntax_id *interface,
+                                  struct rpc_pipe_client **presult)
+{
+        return cli_rpc_pipe_open_noauth_transport(cli, NCACN_NP,
+                                                  interface, presult);
+}
+
+/****************************************************************************
  Open a named pipe to an SMB server and bind using NTLMSSP or SPNEGO NTLMSSP
  ****************************************************************************/
@@ -3021 +3037 @@
 static NTSTATUS cli_rpc_pipe_open_ntlmssp_internal(struct cli_state *cli,
                                                    const struct ndr_syntax_id *interface,
+                                                   enum dcerpc_transport_t transport,
                                                    enum pipe_auth_type auth_type,
                                                    enum pipe_auth_level auth_level,
@@ -3032 +3049 @@
         NTSTATUS status;
 
-        status = cli_rpc_pipe_open(cli, interface, &result);
+        status = cli_rpc_pipe_open(cli, transport, interface, &result);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
@@ -3074 +3091 @@
 NTSTATUS cli_rpc_pipe_open_ntlmssp(struct cli_state *cli,
                                    const struct ndr_syntax_id *interface,
+                                   enum dcerpc_transport_t transport,
                                    enum pipe_auth_level auth_level,
                                    const char *domain,
@@ -3082 +3100 @@
         return cli_rpc_pipe_open_ntlmssp_internal(cli,
                                                 interface,
+                                                transport,
                                                 PIPE_AUTH_TYPE_NTLMSSP,
                                                 auth_level,
@@ -3097 +3116 @@
 NTSTATUS cli_rpc_pipe_open_spnego_ntlmssp(struct cli_state *cli,
                                           const struct ndr_syntax_id *interface,
+                                          enum dcerpc_transport_t transport,
                                           enum pipe_auth_level auth_level,
                                           const char *domain,
@@ -3105 +3125 @@
         return cli_rpc_pipe_open_ntlmssp_internal(cli,
                                                 interface,
+                                                transport,
                                                 PIPE_AUTH_TYPE_SPNEGO_NTLMSSP,
                                                 auth_level,
@@ -3202 +3223 @@
 NTSTATUS cli_rpc_pipe_open_schannel_with_key(struct cli_state *cli,
                                              const struct ndr_syntax_id *interface,
+                                             enum dcerpc_transport_t transport,
                                              enum pipe_auth_level auth_level,
                                              const char *domain,
@@ -3211 +3233 @@
         NTSTATUS status;
 
-        status = cli_rpc_pipe_open(cli, interface, &result);
+        status = cli_rpc_pipe_open(cli, transport, interface, &result);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
@@ -3271 +3293 @@
 
         status = cli_rpc_pipe_open_spnego_ntlmssp(
-                cli, &ndr_table_netlogon.syntax_id, PIPE_AUTH_LEVEL_PRIVACY,
+                cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
+                PIPE_AUTH_LEVEL_PRIVACY,
                 domain, username, password, &netlogon_pipe);
         if (!NT_STATUS_IS_OK(status)) {
@@ -3296 +3319 @@
 NTSTATUS cli_rpc_pipe_open_ntlmssp_auth_schannel(struct cli_state *cli,
                                                  const struct ndr_syntax_id *interface,
+                                                 enum dcerpc_transport_t transport,
                                                  enum pipe_auth_level auth_level,
                                                  const char *domain,
@@ -3317 +3341 @@
 
         status = cli_rpc_pipe_open_schannel_with_key(
-                cli, interface, auth_level, domain, netlogon_pipe->dc,
+                cli, interface, transport, auth_level, domain, netlogon_pipe->dc,
                 &result);
 
@@ -3336 +3360 @@
 NTSTATUS cli_rpc_pipe_open_schannel(struct cli_state *cli,
                                     const struct ndr_syntax_id *interface,
+                                    enum dcerpc_transport_t transport,
                                     enum pipe_auth_level auth_level,
                                     const char *domain,
@@ -3355 +3380 @@
 
         status = cli_rpc_pipe_open_schannel_with_key(
-                cli, interface, auth_level, domain, netlogon_pipe->dc,
+                cli, interface, transport, auth_level, domain, netlogon_pipe->dc,
                 &result);
 
@@ -3387 +3412 @@
         NTSTATUS status;
 
-        status = cli_rpc_pipe_open(cli, interface, &result);
+        status = cli_rpc_pipe_open(cli, NCACN_NP, interface, &result);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;

branches/samba-3.3.x/source/rpc_client/init_netlogon.c

@@ -297 +297 @@
                            NETLOGON_EXTRA_SIDS,
                            user_session_key,
-                           my_name,
+                           talloc_strdup(sam3, my_name),
                            talloc_strdup(sam3, pdb_get_domain(sampw)),
                            sid,

branches/samba-3.3.x/source/rpc_server/srv_netlog_nt.c

@@ -670 +670 @@
         }
 
-        /* Woah - what does this to to the credential chain ? JRA */
-        cred_hash3(pwd, r->in.new_password->hash, p->dc->sess_key, 0);
+        des_crypt112_16(pwd, r->in.new_password->hash, p->dc->sess_key, 0);
 
         DEBUG(100,("_netr_ServerPasswordSet: new given value was :\n"));

branches/samba-3.3.x/source/rpc_server/srv_samr_nt.c

@@ -262 +262 @@
         *pacc_requested &= ~MAXIMUM_ALLOWED_ACCESS;
 
-        /* At least try for generic read. */
-        *pacc_requested = GENERIC_READ_ACCESS;
+        /* At least try for generic read|execute - Everyone gets that. */
+        *pacc_requested = GENERIC_READ_ACCESS|GENERIC_EXECUTE_ACCESS;
 
         /* root gets anything. */

branches/samba-3.3.x/source/rpcclient/rpcclient.c

@@ -588 +588 @@
                                 ntresult = cli_rpc_pipe_open_spnego_ntlmssp(
                                         cli, cmd_entry->interface,
+                                        NCACN_NP,
                                         pipe_default_auth_level,
                                         lp_workgroup(),
@@ -597 +598 @@
                                 ntresult = cli_rpc_pipe_open_ntlmssp(
                                         cli, cmd_entry->interface,
+                                        NCACN_NP,
                                         pipe_default_auth_level,
                                         lp_workgroup(),
@@ -606 +608 @@
                                 ntresult = cli_rpc_pipe_open_schannel(
                                         cli, cmd_entry->interface,
+                                        NCACN_NP,
                                         pipe_default_auth_level,
                                         lp_workgroup(),

branches/samba-3.3.x/source/smbd/files.c

@@ -408 +408 @@
                                         fsp->fsp_name);
 
-                if (strnequal(d_fullname, d1_fullname, dlen)) {
+                /*
+                 * If the open file has a path that is a longer
+                 * component, then it's a subpath.
+                 */
+                if (strnequal(d_fullname, d1_fullname, dlen) &&
+                                (d1_fullname[dlen] == '/')) {
                         TALLOC_FREE(d_fullname);
                         TALLOC_FREE(d1_fullname);
@@ -414 +419 @@
                 }
                 TALLOC_FREE(d1_fullname);
-        } 
+        }
 
         TALLOC_FREE(d_fullname);

branches/samba-3.3.x/source/smbd/notify_inotify.c

@@ -233 +233 @@
         struct inotify_event *e0, *e;
         uint32_t prev_cookie=0;
+        NTSTATUS status;
 
         /*
@@ -248 +249 @@
         if (e == NULL) return;
 
-        if (sys_read(in->fd, e0, bufsize) != bufsize) {
-                DEBUG(0,("Failed to read all inotify data\n"));
+        status = read_data(in->fd, (char *)e0, bufsize);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,("Failed to read all inotify data - %s\n",
+                        nt_errstr(status)));
                 talloc_free(e0);
+                /* the inotify fd will now be out of sync,
+                 * can't keep reading data off it */
+                TALLOC_FREE(fde);
                 return;
         }

branches/samba-3.3.x/source/smbd/posix_acls.c

@@ -3179 +3179 @@
         SMB_ACL_T def_acl = NULL;
         struct pai_val *pal;
+        int ret;
 
         *ppdesc = NULL;
@@ -3185 +3186 @@
 
         /* Get the stat struct for the owner info. */
-        if(SMB_VFS_STAT(conn, name, &sbuf) != 0) {
+        if (lp_posix_pathnames()) {
+                ret = SMB_VFS_LSTAT(conn, name, &sbuf);
+        } else {
+                ret = SMB_VFS_STAT(conn, name, &sbuf);
+        }
+        if(ret != 0) {
                 return map_nt_error_from_unix(errno);
         }
@@ -3219 +3225 @@
         files_struct *fsp;
         SMB_STRUCT_STAT st;
+        bool posix_paths = lp_posix_pathnames();
 
         if(!CAN_WRITE(conn)) {
@@ -3226 +3233 @@
         /* Case (1). */
         /* try the direct way first */
-        ret = SMB_VFS_CHOWN(conn, fname, uid, gid);
+        if (posix_paths) {
+                ret = SMB_VFS_LCHOWN(conn, fname, uid, gid);
+        } else {
+                ret = SMB_VFS_CHOWN(conn, fname, uid, gid);
+        }
         if (ret == 0)
                 return 0;
@@ -3266 +3277 @@
         }
 
-        if (SMB_VFS_STAT(conn,fname,&st)) {
+        if (posix_paths) {
+                ret = SMB_VFS_LSTAT(conn,fname,&st);
+        } else {
+                ret = SMB_VFS_STAT(conn,fname,&st);
+        }
+        if (ret != 0) {
                 return -1;
         }
@@ -3498 +3514 @@
         bool acl_set_support = false;
         bool ret = false;
+        bool posix_paths = lp_posix_pathnames();
+        int sret;
 
         DEBUG(10,("set_nt_acl: called for file %s\n", fsp->fsp_name ));
@@ -3511 +3529 @@
 
         if(fsp->is_directory || fsp->fh->fd == -1) {
-                if(SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf) != 0)
+                if (posix_paths) {
+                        sret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name, &sbuf);
+                } else {
+                        sret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf);
+                }
+                if (sret != 0) {
                         return map_nt_error_from_unix(errno);
+                }
         } else {
                 if(SMB_VFS_FSTAT(fsp, &sbuf) != 0)
@@ -3556 +3580 @@
 
                 if(fsp->is_directory) {
-                        if(SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf) != 0) {
+                        if (posix_paths) {
+                                sret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name, &sbuf);
+                        } else {
+                                sret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf);
+                        }
+                        if (sret != 0) {
                                 return map_nt_error_from_unix(errno);
                         }
                 } else {
-
-                        int sret;
-
-                        if(fsp->fh->fd == -1)
-                                sret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf);
-                        else
+                        if(fsp->fh->fd == -1) {
+                                if (posix_paths) {
+                                        sret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name, &sbuf);
+                                } else {
+                                        sret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf);
+                                }
+                        } else {
                                 sret = SMB_VFS_FSTAT(fsp, &sbuf);
+                        }
 
                         if(sret != 0)
@@ -3645 +3676 @@
                         }
                 } else {
-                        int sret = -1;
-
                         /*
                          * No default ACL - delete one if it exists.
@@ -3706 +3735 @@
 
                 if (orig_mode != posix_perms) {
-                        int sret = -1;
-
                         DEBUG(3,("set_nt_acl: chmod %s. perms = 0%o.\n",
                                 fsp->fsp_name, (unsigned int)posix_perms ));

branches/samba-3.3.x/source/smbd/reply.c

@@ -958 +958 @@
         }
 
-        if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn,name,&sbuf) != 0)) {
-                DEBUG(3,("reply_checkpath: stat of %s failed (%s)\n",name,strerror(errno)));
-                status = map_nt_error_from_unix(errno);
-                goto path_err;
+        if (!VALID_STAT(sbuf)) {
+                int ret;
+
+                if (lp_posix_pathnames()) {
+                        ret = SMB_VFS_LSTAT(conn,name,&sbuf);
+                } else {
+                        ret = SMB_VFS_STAT(conn,name,&sbuf);
+                }
+                if (ret != 0) {
+                        DEBUG(3,("reply_checkpath: stat of %s failed (%s)\n",name,strerror(errno)));
+                        status = map_nt_error_from_unix(errno);
+                        goto path_err;
+                }
         }
 
@@ -1068 +1077 @@
                         return;
                 }
-                if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn,fname,&sbuf) != 0)) {
-                        DEBUG(3,("reply_getatr: stat of %s failed (%s)\n",fname,strerror(errno)));
-                        reply_unixerror(req, ERRDOS,ERRbadfile);
-                        END_PROFILE(SMBgetatr);
-                        return;
+                if (!VALID_STAT(sbuf)) {
+                        int ret;
+
+                        if (lp_posix_pathnames()) {
+                                ret = SMB_VFS_LSTAT(conn,fname,&sbuf);
+                        } else {
+                                ret = SMB_VFS_STAT(conn,fname,&sbuf);
+                        }
+                        if (ret != 0) {
+                                DEBUG(3,("reply_getatr: stat of %s failed (%s)\n",fname,strerror(errno)));
+                                reply_unixerror(req, ERRDOS,ERRbadfile);
+                                END_PROFILE(SMBgetatr);
+                                return;
+                        }
                 }
 
@@ -2302 +2320 @@
         files_struct *fsp;
         uint32 dirtype_orig = dirtype;
+        bool posix_paths = lp_posix_pathnames();
+        int ret;
         NTSTATUS status;
 
@@ -2310 +2330 @@
         }
 
-        if (SMB_VFS_LSTAT(conn,fname,&sbuf) != 0) {
+        if (posix_paths) {
+                ret = SMB_VFS_LSTAT(conn,fname,&sbuf);
+        } else {
+                ret = SMB_VFS_STAT(conn,fname,&sbuf);
+        }
+        if (ret != 0) {
                 return map_nt_error_from_unix(errno);
         }
@@ -2396 +2421 @@
                  FILE_OPEN,             /* create_disposition*/
                  FILE_NON_DIRECTORY_FILE, /* create_options */
-                 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
+                                        /* file_attributes */
+                 posix_paths ? FILE_FLAG_POSIX_SEMANTICS|0777 :
+                                FILE_ATTRIBUTE_NORMAL,
                  0,                     /* oplock_request */
                  0,                     /* allocation_size */

branches/samba-3.3.x/source/utils/net.h

@@ -158 +158 @@
 #define NET_FLAGS_SIGN                          0x00000040      /* sign RPC connection */
 #define NET_FLAGS_SEAL                          0x00000080      /* seal RPC connection */
+#define NET_FLAGS_TCP                           0x00000100      /* use ncacn_ip_tcp */
 
 /* net share operation modes */

branches/samba-3.3.x/source/utils/net_join.c

@@ -35 +35 @@
 int net_join(struct net_context *c, int argc, const char **argv)
 {
-        if (argc < 1)
-                return net_join_usage(c, argc, argv);
-
-        if (StrCaseCmp(argv[0], "HELP") == 0) {
+        if ((argc > 0) && (StrCaseCmp(argv[0], "HELP") == 0)) {
                 net_join_usage(c, argc, argv);
                 return 0;

branches/samba-3.3.x/source/utils/net_rpc.c

@@ -158 +158 @@
                         /* Always try and create an schannel netlogon pipe. */
                         nt_status = cli_rpc_pipe_open_schannel(
-                                cli, interface,
+                                cli, interface, NCACN_NP,
                                 PIPE_AUTH_LEVEL_PRIVACY, domain_name,
                                 &pipe_hnd);
@@ -170 +170 @@
                                 nt_status = cli_rpc_pipe_open_ntlmssp(
                                         cli, interface,
+                                        (conn_flags & NET_FLAGS_TCP) ?
+                                        NCACN_IP_TCP : NCACN_NP,
                                         PIPE_AUTH_LEVEL_PRIVACY,
                                         lp_workgroup(), c->opt_user_name,
@@ -797 +799 @@
                                   argv[0],
                                   0,
-                                  (uint8_t **)&u0,
+                                  (uint8_t **)(void *)&u0,
                                   (uint32_t)-1,
                                   &entries_read,
@@ -2997 +2999 @@
         status = NetShareEnum(c->opt_host,
                               level,
-                              (uint8_t **)&i1,
+                              (uint8_t **)(void *)&i1,
                               (uint32_t)-1,
                               &entries_read,
@@ -4773 +4775 @@
                              username,
                              3,
-                             (uint8_t **)&i3,
+                             (uint8_t **)(void *)&i3,
                              preferred_len,
                              &entries_read,

branches/samba-3.3.x/source/utils/net_rpc_join.c

@@ -101 +101 @@
 
         ntret = cli_rpc_pipe_open_schannel_with_key(
-                cli, &ndr_table_netlogon.syntax_id, PIPE_AUTH_LEVEL_PRIVACY,
+                cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
+                PIPE_AUTH_LEVEL_PRIVACY,
                 domain, netlogon_pipe->dc, &pipe_hnd);
 
@@ -420 +421 @@
 
                 result = cli_rpc_pipe_open_schannel_with_key(
-                        cli, &ndr_table_netlogon.syntax_id,
+                        cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
                         PIPE_AUTH_LEVEL_PRIVACY, domain, pipe_hnd->dc,
                         &netlogon_schannel_pipe);

branches/samba-3.3.x/source/utils/net_rpc_samsync.c

@@ -503 +503 @@
         } else {
                 ret = run_rpc_command(c, cli, &ndr_table_drsuapi.syntax_id,
-                                      NET_FLAGS_SEAL,
+                                      NET_FLAGS_SEAL | NET_FLAGS_TCP,
                                       rpc_vampire_keytab_ds_internals, argc, argv);
         }

branches/samba-3.3.x/source/winbindd/winbindd.c

@@ -848 +848 @@
         message_dispatch(winbind_messaging_context());
 
-        run_events(winbind_event_context(), 0, NULL, NULL);
+        if (run_events(winbind_event_context(), 0, NULL, NULL)) {
+                return;
+        }
 
         /* refresh the trusted domain cache */
@@ -928 +930 @@
                 if (FD_ISSET(ev->fd, &w_fds))
                         flags |= EVENT_FD_WRITE;
-                if (flags)
+                if (flags) {
                         ev->handler(ev, flags);
+                        return;
+                }
                 ev = next;
         }

branches/samba-3.3.x/source/winbindd/winbindd.h

@@ -123 +123 @@
 
         struct rpc_pipe_client *lsa_pipe;
+        struct rpc_pipe_client *lsa_pipe_tcp;
         POLICY_HND lsa_policy;
 
@@ -183 +184 @@
                                   * we don't have to try _ex every time. */
 
+        bool can_do_ncacn_ip_tcp;
+
         /* Lookup methods for this domain (LDAP or RPC) */
         struct winbindd_methods *methods;

branches/samba-3.3.x/source/winbindd/winbindd_ads.c

@@ -978 +978 @@
         size_t num_members = 0;
         ads_control args;
-        struct rpc_pipe_client *cli;
-        POLICY_HND lsa_policy;
         DOM_SID *sid_mem_nocache = NULL;
         char **names_nocache = NULL;
@@ -1124 +1122 @@
         if (num_nocache > 0) {
 
-                status = cm_connect_lsa(domain, tmp_ctx, &cli, &lsa_policy);
-
-                if (!NT_STATUS_IS_OK(status)) {
-                        goto done;
-                }
-
-                status = rpccli_lsa_lookup_sids(cli, tmp_ctx,
-                                                &lsa_policy,
-                                                num_nocache,
-                                                sid_mem_nocache,
-                                                &domains_nocache,
-                                                &names_nocache,
-                                                &name_types_nocache);
+                status = winbindd_lookup_sids(tmp_ctx,
+                                              domain,
+                                              num_nocache,
+                                              sid_mem_nocache,
+                                              &domains_nocache,
+                                              &names_nocache,
+                                              &name_types_nocache);
 
                 if (!(NT_STATUS_IS_OK(status) ||
@@ -1145 +1137 @@
                                   "- retrying...\n", nt_errstr(status)));
 
-                        status = cm_connect_lsa(domain, tmp_ctx, &cli,
-                                                &lsa_policy);
-
-                        if (!NT_STATUS_IS_OK(status)) {
-                                goto done;
-                        }
-
-                        status = rpccli_lsa_lookup_sids(cli, tmp_ctx,
-                                                        &lsa_policy,
-                                                        num_nocache,
-                                                        sid_mem_nocache,
-                                                        &domains_nocache,
-                                                        &names_nocache,
-                                                        &name_types_nocache);
+                        status = winbindd_lookup_sids(tmp_ctx,
+                                                      domain,
+                                                      num_nocache,
+                                                      sid_mem_nocache,
+                                                      &domains_nocache,
+                                                      &names_nocache,
+                                                      &name_types_nocache);
                 }
 

branches/samba-3.3.x/source/winbindd/winbindd_cm.c

@@ -858 +858 @@
                                                               machine_password,
                                                               lp_workgroup(),
-                                                              domain->name);
+                                                              domain->alt_name);
 
                         if (!ADS_ERR_OK(ads_status)) {
@@ -1543 +1543 @@
         }
 
+        if (conn->lsa_pipe_tcp != NULL) {
+                TALLOC_FREE(conn->lsa_pipe_tcp);
+                /* Ok, it must be dead. Drop timeout to 0.5 sec. */
+                if (conn->cli) {
+                        cli_set_timeout(conn->cli, 500);
+                }
+        }
+
         if (conn->netlogon_pipe != NULL) {
                 TALLOC_FREE(conn->netlogon_pipe);
@@ -1917 +1925 @@
                   domain->name, domain->active_directory ? "" : "NOT "));
 
+        domain->can_do_ncacn_ip_tcp = domain->active_directory;
+
         TALLOC_FREE(cli);
 
@@ -2039 +2049 @@
         result = cli_rpc_pipe_open_spnego_ntlmssp(conn->cli,
                                                   &ndr_table_samr.syntax_id,
+                                                  NCACN_NP,
                                                   PIPE_AUTH_LEVEL_PRIVACY,
                                                   domain_name,
@@ -2082 +2093 @@
         }
         result = cli_rpc_pipe_open_schannel_with_key
-                (conn->cli, &ndr_table_samr.syntax_id, PIPE_AUTH_LEVEL_PRIVACY,
+                (conn->cli, &ndr_table_samr.syntax_id, NCACN_NP,
+                PIPE_AUTH_LEVEL_PRIVACY,
                  domain->name, p_dcinfo, &conn->samr_pipe);
 
@@ -2137 +2149 @@
  done:
 
-        if (!NT_STATUS_IS_OK(result)) {
+        if (NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED)) {
+                /*
+                 * if we got access denied, we might just have no access rights
+                 * to talk to the remote samr server server (e.g. when we are a
+                 * PDC and we are connecting a w2k8 pdc via an interdomain
+                 * trust). In that case do not invalidate the whole connection
+                 * stack
+                 */
+                TALLOC_FREE(conn->samr_pipe);
+                ZERO_STRUCT(conn->sam_domain_handle);
+                return result;
+        } else if (!NT_STATUS_IS_OK(result)) {
                 invalidate_cm_connection(conn);
                 return result;
@@ -2147 +2170 @@
         SAFE_FREE(machine_account);
         return result;
+}
+
+/**********************************************************************
+ open an schanneld ncacn_ip_tcp connection to LSA
+***********************************************************************/
+
+NTSTATUS cm_connect_lsa_tcp(struct winbindd_domain *domain,
+                            TALLOC_CTX *mem_ctx,
+                            struct rpc_pipe_client **cli)
+{
+        struct winbindd_cm_conn *conn;
+        NTSTATUS status;
+
+        DEBUG(10,("cm_connect_lsa_tcp\n"));
+
+        status = init_dc_connection(domain);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        conn = &domain->conn;
+
+        if (conn->lsa_pipe_tcp &&
+            conn->lsa_pipe_tcp->transport_type == NCACN_IP_TCP &&
+            conn->lsa_pipe_tcp->auth->auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
+                goto done;
+        }
+
+        TALLOC_FREE(conn->lsa_pipe_tcp);
+
+        status = cli_rpc_pipe_open_schannel(conn->cli,
+                                            &ndr_table_lsarpc.syntax_id,
+                                            NCACN_IP_TCP,
+                                            PIPE_AUTH_LEVEL_PRIVACY,
+                                            domain->name,
+                                            &conn->lsa_pipe_tcp);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10,("cli_rpc_pipe_open_schannel failed: %s\n",
+                        nt_errstr(status)));
+                goto done;
+        }
+
+ done:
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(conn->lsa_pipe_tcp);
+                return status;
+        }
+
+        *cli = conn->lsa_pipe_tcp;
+
+        return status;
 }
 
@@ -2179 +2253 @@
          * authenticated LSA pipe with sign & seal. */
         result = cli_rpc_pipe_open_spnego_ntlmssp
-                (conn->cli, &ndr_table_lsarpc.syntax_id,
+                (conn->cli, &ndr_table_lsarpc.syntax_id, NCACN_NP,
                  PIPE_AUTH_LEVEL_PRIVACY,
                  conn->cli->domain, conn->cli->user_name, conn_pwd,
@@ -2220 +2294 @@
         }
         result = cli_rpc_pipe_open_schannel_with_key
-                (conn->cli, &ndr_table_lsarpc.syntax_id,
+                (conn->cli, &ndr_table_lsarpc.syntax_id, NCACN_NP,
                  PIPE_AUTH_LEVEL_PRIVACY,
                  domain->name, p_dcinfo, &conn->lsa_pipe);
@@ -2367 +2441 @@
 
         result = cli_rpc_pipe_open_schannel_with_key(
-                conn->cli, &ndr_table_netlogon.syntax_id,
+                conn->cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
                 PIPE_AUTH_LEVEL_PRIVACY, domain->name, netlogon_pipe->dc,
                 &conn->netlogon_pipe);

branches/samba-3.3.x/source/winbindd/winbindd_proto.h

@@ -74 +74 @@
 /* The following definitions come from winbindd/winbindd_ads.c  */
 
+/* The following definitions come from winbindd/winbindd_rpc.c  */
+
+NTSTATUS winbindd_lookup_sids(TALLOC_CTX *mem_ctx,
+                              struct winbindd_domain *domain,
+                              uint32_t num_sids,
+                              const struct dom_sid *sids,
+                              char ***domains,
+                              char ***names,
+                              enum lsa_SidType **types);
+NTSTATUS winbindd_lookup_names(TALLOC_CTX *mem_ctx,
+                               struct winbindd_domain *domain,
+                               uint32_t num_names,
+                               const char **names,
+                               const char ***domains,
+                               struct dom_sid **sids,
+                               enum lsa_SidType **types);
 
 /* The following definitions come from winbindd/winbindd_async.c  */
@@ -218 +234 @@
 NTSTATUS cm_connect_lsa(struct winbindd_domain *domain, TALLOC_CTX *mem_ctx,
                         struct rpc_pipe_client **cli, POLICY_HND *lsa_policy);
+NTSTATUS cm_connect_lsa_tcp(struct winbindd_domain *domain,
+                            TALLOC_CTX *mem_ctx,
+                            struct rpc_pipe_client **cli);
 NTSTATUS cm_connect_netlogon(struct winbindd_domain *domain,
                              struct rpc_pipe_client **cli);

branches/samba-3.3.x/source/winbindd/winbindd_rpc.c

@@ -278 +278 @@
         enum lsa_SidType *types = NULL;
         char *full_name = NULL;
-        struct rpc_pipe_client *cli;
-        POLICY_HND lsa_policy;
         NTSTATUS name_map_status = NT_STATUS_UNSUCCESSFUL;
         char *mapped_name = NULL;
@@ -311 +309 @@
                  full_name?full_name:"", domain_name ));
 
-        result = cm_connect_lsa(domain, mem_ctx, &cli, &lsa_policy);
-        if (!NT_STATUS_IS_OK(result))
-                return result;
-
-        result = rpccli_lsa_lookup_names(cli, mem_ctx, &lsa_policy, 1, 
-                                         (const char**) &full_name, NULL, 1, &sids, &types);
-        
+        result = winbindd_lookup_names(mem_ctx, domain, 1,
+                                       (const char **)&full_name, NULL,
+                                       &sids, &types);
         if (!NT_STATUS_IS_OK(result))
                 return result;
@@ -343 +337 @@
         enum lsa_SidType *types = NULL;
         NTSTATUS result;
-        struct rpc_pipe_client *cli;
-        POLICY_HND lsa_policy;
         NTSTATUS name_map_status = NT_STATUS_UNSUCCESSFUL;
         char *mapped_name = NULL;
@@ -351 +343 @@
                  domain->name ));
 
-        result = cm_connect_lsa(domain, mem_ctx, &cli, &lsa_policy);
+        result = winbindd_lookup_sids(mem_ctx,
+                                      domain,
+                                      1,
+                                      sid,
+                                      &domains,
+                                      &names,
+                                      &types);
         if (!NT_STATUS_IS_OK(result)) {
-                DEBUG(2,("msrpc_sid_to_name: cm_connect_lsa() failed (%s)\n",
-                         nt_errstr(result)));           
+                DEBUG(2,("msrpc_sid_to_name: failed to lookup sids: %s\n",
+                        nt_errstr(result)));
                 return result;
         }
         
-
-        result = rpccli_lsa_lookup_sids(cli, mem_ctx, &lsa_policy,
-                                        1, sid, &domains, &names, &types);
-        if (!NT_STATUS_IS_OK(result)) {         
-                DEBUG(2,("msrpc_sid_to_name: rpccli_lsa_lookup_sids()  failed (%s)\n",
-                         nt_errstr(result)));           
-                return result;
-        }
 
         *type = (enum lsa_SidType)types[0];
@@ -396 +386 @@
         char **domains;
         NTSTATUS result;
-        struct rpc_pipe_client *cli;
-        POLICY_HND lsa_policy;
         DOM_SID *sids;
         size_t i;
@@ -419 +407 @@
         }
 
-        result = cm_connect_lsa(domain, mem_ctx, &cli, &lsa_policy);
-        if (!NT_STATUS_IS_OK(result)) {
-                return result;
-        }
-
-        result = rpccli_lsa_lookup_sids(cli, mem_ctx, &lsa_policy,
-                                        num_rids, sids, &domains,
-                                        names, types);
+        result = winbindd_lookup_sids(mem_ctx,
+                                      domain,
+                                      num_rids,
+                                      sids,
+                                      &domains,
+                                      names,
+                                      types);
+
         if (!NT_STATUS_IS_OK(result) &&
             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED)) {
@@ -1186 +1174 @@
 }
 
+typedef NTSTATUS (*lookup_sids_fn_t)(struct rpc_pipe_client *cli,
+                                     TALLOC_CTX *mem_ctx,
+                                     struct policy_handle *pol,
+                                     int num_sids,
+                                     const DOM_SID *sids,
+                                     char ***pdomains,
+                                     char ***pnames,
+                                     enum lsa_SidType **ptypes);
+
+NTSTATUS winbindd_lookup_sids(TALLOC_CTX *mem_ctx,
+                              struct winbindd_domain *domain,
+                              uint32_t num_sids,
+                              const struct dom_sid *sids,
+                              char ***domains,
+                              char ***names,
+                              enum lsa_SidType **types)
+{
+        NTSTATUS status;
+        struct rpc_pipe_client *cli = NULL;
+        struct policy_handle lsa_policy;
+        unsigned int orig_timeout;
+        lookup_sids_fn_t lookup_sids_fn = rpccli_lsa_lookup_sids;
+
+        if (domain->can_do_ncacn_ip_tcp) {
+                status = cm_connect_lsa_tcp(domain, mem_ctx, &cli);
+                if (NT_STATUS_IS_OK(status)) {
+                        lookup_sids_fn = rpccli_lsa_lookup_sids3;
+                        goto lookup;
+                }
+                domain->can_do_ncacn_ip_tcp = false;
+        }
+        status = cm_connect_lsa(domain, mem_ctx, &cli, &lsa_policy);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+ lookup:
+        /*
+         * This call can take a long time
+         * allow the server to time out.
+         * 35 seconds should do it.
+         */
+        orig_timeout = rpccli_set_timeout(cli, 35000);
+
+        status = lookup_sids_fn(cli,
+                                mem_ctx,
+                                &lsa_policy,
+                                num_sids,
+                                sids,
+                                domains,
+                                names,
+                                types);
+
+        /* And restore our original timeout. */
+        rpccli_set_timeout(cli, orig_timeout);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        return status;
+}
+
+typedef NTSTATUS (*lookup_names_fn_t)(struct rpc_pipe_client *cli,
+                                      TALLOC_CTX *mem_ctx,
+                                      struct policy_handle *pol,
+                                      int num_names,
+                                      const char **names,
+                                      const char ***dom_names,
+                                      int level,
+                                      struct dom_sid **sids,
+                                      enum lsa_SidType **types);
+
+NTSTATUS winbindd_lookup_names(TALLOC_CTX *mem_ctx,
+                               struct winbindd_domain *domain,
+                               uint32_t num_names,
+                               const char **names,
+                               const char ***domains,
+                               struct dom_sid **sids,
+                               enum lsa_SidType **types)
+{
+        NTSTATUS status;
+        struct rpc_pipe_client *cli = NULL;
+        struct policy_handle lsa_policy;
+        unsigned int orig_timeout;
+        lookup_names_fn_t lookup_names_fn = rpccli_lsa_lookup_names;
+
+        if (domain->can_do_ncacn_ip_tcp) {
+                status = cm_connect_lsa_tcp(domain, mem_ctx, &cli);
+                if (NT_STATUS_IS_OK(status)) {
+                        lookup_names_fn = rpccli_lsa_lookup_names4;
+                        goto lookup;
+                }
+                domain->can_do_ncacn_ip_tcp = false;
+        }
+        status = cm_connect_lsa(domain, mem_ctx, &cli, &lsa_policy);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+ lookup:
+
+        /*
+         * This call can take a long time
+         * allow the server to time out.
+         * 35 seconds should do it.
+         */
+        orig_timeout = rpccli_set_timeout(cli, 35000);
+
+        status = lookup_names_fn(cli,
+                                 mem_ctx,
+                                 &lsa_policy,
+                                 num_names,
+                                 (const char **) names,
+                                 domains,
+                                 1,
+                                 sids,
+                                 types);
+
+        /* And restore our original timeout. */
+        rpccli_set_timeout(cli, orig_timeout);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        return status;
+}
 
 /* the rpc backend methods are exposed via this structure */