Changeset 221 for branches/samba-3.3.x/source/libsmb

Timestamp:

May 24, 2009, 7:17:10 AM (16 years ago)

Author:

Herwig Bauernfeind

Message:

Update Samba 3.3 to 3.3.1

Location:

branches/samba-3.3.x/source/libsmb

Files:

• async_smb.c (modified) (2 diffs)
• clifsinfo.c (modified) (1 diff)
• clikrb5.c (modified) (1 diff)
• libsmb_compat.c (modified) (1 diff)
• libsmb_context.c (modified) (2 diffs)
• libsmb_dir.c (modified) (6 diffs)
• libsmb_file.c (modified) (1 diff)
• libsmb_path.c (modified) (3 diffs)
• libsmb_server.c (modified) (3 diffs)
• libsmb_setget.c (modified) (1 diff)
• libsmb_stat.c (modified) (2 diffs)
• libsmb_xattr.c (modified) (16 diffs)
• namequery.c (modified) (2 diffs)

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

@@ -319 +319 @@
 {
         struct cli_state *cli = (struct cli_state *)p;
-        struct cli_request *req;
+        struct cli_request *req, *next;
         NTSTATUS status;
 
@@ -422 +422 @@
 
  sock_error:
-        for (req = cli->outstanding_requests; req; req = req->next) {
+        for (req = cli->outstanding_requests; req; req = next) {
+                next = req;
                 async_req_error(req->async, status);
         }

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

@@ -303 +303 @@
         return ret;
 }
+
+bool cli_get_fs_full_size_info(struct cli_state *cli,
+                               SMB_BIG_UINT *total_allocation_units,
+                               SMB_BIG_UINT *caller_allocation_units,
+                               SMB_BIG_UINT *actual_allocation_units,
+                               SMB_BIG_UINT *sectors_per_allocation_unit,
+                               SMB_BIG_UINT *bytes_per_sector)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+
+        setup = TRANSACT2_QFSINFO;
+
+        SSVAL(param,0,SMB_FS_FULL_SIZE_INFORMATION);
+
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+                    0, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+
+        if (rdata_count != 32) {
+                goto cleanup;
+        }
+
+        if (total_allocation_units) {
+                *total_allocation_units = BIG_UINT(rdata, 0);
+        }
+        if (caller_allocation_units) {
+                *caller_allocation_units = BIG_UINT(rdata,8);
+        }
+        if (actual_allocation_units) {
+                *actual_allocation_units = BIG_UINT(rdata,16);
+        }
+        if (sectors_per_allocation_unit) {
+                *sectors_per_allocation_unit = IVAL(rdata,24);
+        }
+        if (bytes_per_sector) {
+                *bytes_per_sector = IVAL(rdata,28);
+        }
+
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+
+        return ret;
+}
+
+bool cli_get_posix_fs_info(struct cli_state *cli,
+                           uint32 *optimal_transfer_size,
+                           uint32 *block_size,
+                           SMB_BIG_UINT *total_blocks,
+                           SMB_BIG_UINT *blocks_available,
+                           SMB_BIG_UINT *user_blocks_available,
+                           SMB_BIG_UINT *total_file_nodes,
+                           SMB_BIG_UINT *free_file_nodes,
+                           SMB_BIG_UINT *fs_identifier)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+
+        setup = TRANSACT2_QFSINFO;
+
+        SSVAL(param,0,SMB_QUERY_POSIX_FS_INFO);
+
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+                    0, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+
+        if (rdata_count != 56) {
+                goto cleanup;
+        }
+
+        if (optimal_transfer_size) {
+                *optimal_transfer_size = IVAL(rdata, 0);
+        }
+        if (block_size) {
+                *block_size = IVAL(rdata,4);
+        }
+        if (total_blocks) {
+                *total_blocks = BIG_UINT(rdata,8);
+        }
+        if (blocks_available) {
+                *blocks_available = BIG_UINT(rdata,16);
+        }
+        if (user_blocks_available) {
+                *user_blocks_available = BIG_UINT(rdata,24);
+        }
+        if (total_file_nodes) {
+                *total_file_nodes = BIG_UINT(rdata,32);
+        }
+        if (free_file_nodes) {
+                *free_file_nodes = BIG_UINT(rdata,40);
+        }
+        if (fs_identifier) {
+                *fs_identifier = BIG_UINT(rdata,48);
+        }
+
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+
+        return ret;
+}
+
 
 /******************************************************************************

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

@@ -1747 +1747 @@
                 }
 
+                if (tmp[0] == '/') {
+                        /* Treat as a FILE: keytab definition. */
+                        found_valid_name = true;
+                }
+
                 if (found_valid_name) {
                         if (tmp[0] != '/') {

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

@@ -331 +331 @@
 
 int
+smbc_statvfs(char *path,
+             struct statvfs *st)
+{
+        return smbc_getFunctionStatVFS(statcont)(statcont, path, st);
+}
+
+int
+smbc_fstatvfs(int fd,
+              struct statvfs *st)
+{
+        SMBCFILE * file = find_fd(fd);
+        return smbc_getFunctionFstatVFS(statcont)(statcont, file, st);
+}
+
+int
 smbc_ftruncate(int fd,
                off_t size)

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

@@ -95 +95 @@
         smbc_setFunctionFtruncate(context, SMBC_ftruncate_ctx);
         smbc_setFunctionStat(context, SMBC_stat_ctx);
+        smbc_setFunctionStatVFS(context, SMBC_statvfs_ctx);
+        smbc_setFunctionFstatVFS(context, SMBC_fstatvfs_ctx);
         smbc_setFunctionFstat(context, SMBC_fstat_ctx);
         smbc_setFunctionOpendir(context, SMBC_opendir_ctx);
@@ -645 +647 @@
         cli_cm_set_credentials();
 }
+
+void smbc_set_credentials_with_fallback(SMBCCTX *context,
+                                        const char *workgroup,
+                                        const char *user,
+                                        const char *password)
+{
+        smbc_bool use_kerberos = false;
+        const char *signing_state = "off";
+        
+        if (!context ||
+            ! workgroup || ! *workgroup ||
+            ! user || ! *user ||
+            ! password || ! *password) {
+            
+                return;
+        }
+
+        if (smbc_getOptionUseKerberos(context)) {
+                use_kerberos = True;
+        }
+
+        if (lp_client_signing()) {
+                signing_state = "on";
+        }
+
+        if (lp_client_signing() == Required) {
+                signing_state = "force";
+        }
+
+        /* Using CONST_DISCARD here is ugly, but
+         * we know that smbc_set_credentials() doesn't
+         * actually modify the strings, and should have
+         * been const from the start. We're constrained
+         * by the ABI here.
+         */
+
+        smbc_set_credentials(CONST_DISCARD(char *,workgroup),
+                             CONST_DISCARD(char *,user),
+                             CONST_DISCARD(char *,password),
+                             use_kerberos,
+                             CONST_DISCARD(char *,signing_state));
+
+        if (smbc_getOptionFallbackAfterKerberos(context)) {
+                cli_cm_set_fallback_after_kerberos();
+        }
+}

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

@@ -1502 +1502 @@
         char *password = NULL;
         char *workgroup = NULL;
+        char *targetpath = NULL;
+        struct cli_state *targetcli = NULL;
         char *path = NULL;
         uint16 mode;
@@ -1519 +1521 @@
         }
 
-        DEBUG(4, ("smbc_chmod(%s, 0%3o)\n", fname, newmode));
+        DEBUG(4, ("smbc_chmod(%s, 0%3o)\n", fname, (unsigned int)newmode));
 
         if (SMBC_parse_path(frame,
@@ -1552 +1554 @@
                 return -1;  /* errno set by SMBC_server */
         }
+        
+        /*d_printf(">>>unlink: resolving %s\n", path);*/
+        if (!cli_resolve_path(frame, "", srv->cli, path,
+                              &targetcli, &targetpath)) {
+                d_printf("Could not resolve %s\n", path);
+                TALLOC_FREE(frame);
+                return -1;
+        }
 
         mode = 0;
@@ -1560 +1570 @@
         if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= aHIDDEN;
 
-        if (!cli_setatr(srv->cli, path, mode, 0)) {
-                errno = SMBC_errno(context, srv->cli);
+        if (!cli_setatr(targetcli, targetpath, mode, 0)) {
+                errno = SMBC_errno(context, targetcli);
                 TALLOC_FREE(frame);
                 return -1;
@@ -1902 +1912 @@
         }
 
+        /* set the credentials to make DFS work */
+        smbc_set_credentials_with_fallback(ocontext,
+                                           workgroup,
+                                           user1,
+                                           password1);
+
         /*d_printf(">>>rename: resolving %s\n", path1);*/
         if (!cli_resolve_path(frame, "", srv->cli, path1,
@@ -1909 +1925 @@
                 return -1;
         }
+        
+        /* set the credentials to make DFS work */
+        smbc_set_credentials_with_fallback(ncontext,
+                                           workgroup,
+                                           user2,
+                                           password2);
+        
         /*d_printf(">>>rename: resolved path as %s\n", targetpath1);*/
         /*d_printf(">>>rename: resolving %s\n", path2);*/

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

@@ -383 +383 @@
                 return -1;
         }
-        
+
         /*d_printf(">>>write: resolving %s\n", path);*/
         if (!cli_resolve_path(frame, "", file->srv->cli, path,

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

@@ -234 +234 @@
         const char *p;
         char *q, *r;
+        char *workgroup = NULL;
         int len;
         
@@ -333 +334 @@
                 
                 if (strchr_m(u, ';')) {
-                        char *workgroup;
                         next_token_no_ltrim_talloc(ctx, &u, &workgroup, ";");
                         if (!workgroup) {
@@ -395 +395 @@
         (void) urldecode_talloc(ctx, pp_user, *pp_user);
         (void) urldecode_talloc(ctx, pp_password, *pp_password);
+
+        if (!workgroup) {
+                workgroup = talloc_strdup(ctx, smbc_getWorkgroup(context));
+        }
+        if (!workgroup) {
+                return -1;
+        }
+
+        /* set the credentials to make DFS work */
+        smbc_set_credentials_with_fallback(context,
+                                           workgroup,
+                                           *pp_user,
+                                           *pp_password);
         
         return 0;

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

@@ -239 +239 @@
 {
         SMBCSRV *srv=NULL;
+        char *workgroup = NULL;
         struct cli_state *c;
         struct nmb_name called, calling;
@@ -360 +361 @@
                 
                 /* ... then we're done here.  Give 'em what they came for. */
-                return srv;
+                goto done;
         }
         
@@ -599 +600 @@
         
         DLIST_ADD(context->internal->servers, srv);
+done:
+        if (!pp_workgroup || !*pp_workgroup || !**pp_workgroup) {
+                workgroup = talloc_strdup(ctx, smbc_getWorkgroup(context));
+        } else {
+                workgroup = *pp_workgroup;
+        }
+        if(!workgroup) {
+                return NULL;
+        }
+        
+        /* set the credentials to make DFS work */
+        smbc_set_credentials_with_fallback(context,
+                                           workgroup,
+                                           *pp_username,
+                                           *pp_password);
+        
         return srv;
         

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

@@ -660 +660 @@
 }
 
+smbc_statvfs_fn
+smbc_getFunctionStatVFS(SMBCCTX *c)
+{
+        return c->internal->posix_emu.statvfs_fn;
+}
+
+void
+smbc_setFunctionStatVFS(SMBCCTX *c, smbc_statvfs_fn fn)
+{
+        c->internal->posix_emu.statvfs_fn = fn;
+}
+
+smbc_fstatvfs_fn
+smbc_getFunctionFstatVFS(SMBCCTX *c)
+{
+        return c->internal->posix_emu.fstatvfs_fn;
+}
+
+void
+smbc_setFunctionFstatVFS(SMBCCTX *c, smbc_fstatvfs_fn fn)
+{
+        c->internal->posix_emu.fstatvfs_fn = fn;
+}
+
 smbc_ftruncate_fn
 smbc_getFunctionFtruncate(SMBCCTX *c)

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

@@ -156 +156 @@
                 return -1;
         }
-        
+
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
@@ -301 +301 @@
         
 }
+
+
+/*
+ * Routine to obtain file system information given a path
+ */
+int
+SMBC_statvfs_ctx(SMBCCTX *context,
+                 char *path,
+                 struct statvfs *st)
+{
+        int             ret;
+        bool            bIsDir;
+        struct stat     statbuf;
+        SMBCFILE *      pFile;
+
+        /* Determine if the provided path is a file or a folder */
+        if (SMBC_stat_ctx(context, path, &statbuf) < 0) {
+                return -1;
+        }
+
+        /* Is it a file or a directory?  */
+        if (S_ISDIR(statbuf.st_mode)) {
+                /* It's a directory. */
+                if ((pFile = SMBC_opendir_ctx(context, path)) == NULL) {
+                        return -1;
+                }
+                bIsDir = true;
+        } else if (S_ISREG(statbuf.st_mode)) {
+                /* It's a file. */
+                if ((pFile = SMBC_open_ctx(context, path,
+                                           O_RDONLY, 0)) == NULL) {
+                        return -1;
+                }
+                bIsDir = false;
+        } else {
+                /* It's neither a file nor a directory. Not supported. */
+                errno = ENOSYS;
+                return -1;
+        }
+
+        /* Now we have an open file handle, so just use SMBC_fstatvfs */
+        ret = SMBC_fstatvfs_ctx(context, pFile, st);
+
+        /* Close the file or directory */
+        if (bIsDir) {
+                SMBC_closedir_ctx(context, pFile);
+        } else {
+                SMBC_close_ctx(context, pFile);
+        }
+
+        return ret;
+}
+
+
+/*
+ * Routine to obtain file system information given an fd
+ */
+
+int
+SMBC_fstatvfs_ctx(SMBCCTX *context,
+                  SMBCFILE *file,
+                  struct statvfs *st)
+{
+        unsigned long flags = 0;
+        uint32 fs_attrs = 0;
+        struct cli_state *cli = file->srv->cli;
+                
+
+        /* Initialize all fields (at least until we actually use them) */
+        memset(st, 0, sizeof(*st));
+
+        /*
+         * The state of each flag is such that the same bits are unset as
+         * would typically be unset on a local file system on a POSIX OS. Thus
+         * the bit is on, for example, only for case-insensitive file systems
+         * since most POSIX file systems are case sensitive and fstatvfs()
+         * would typically return zero in these bits on such a local file
+         * system.
+         */
+
+        /* See if the server has UNIX CIFS support */
+        if (! SERVER_HAS_UNIX_CIFS(cli)) {
+                SMB_BIG_UINT total_allocation_units;
+                SMB_BIG_UINT caller_allocation_units;
+                SMB_BIG_UINT actual_allocation_units;
+                SMB_BIG_UINT sectors_per_allocation_unit;
+                SMB_BIG_UINT bytes_per_sector;
+                
+                /* Nope. If size data is available... */
+                if (cli_get_fs_full_size_info(cli,
+                                              &total_allocation_units,
+                                              &caller_allocation_units,
+                                              &actual_allocation_units,
+                                              &sectors_per_allocation_unit,
+                                              &bytes_per_sector)) {
+
+                        /* ... then provide it */
+                        st->f_bsize =
+                                (unsigned long) bytes_per_sector;
+#if HAVE_FRSIZE
+                        st->f_frsize =
+                                (unsigned long) sectors_per_allocation_unit;
+#endif
+                        st->f_blocks =
+                                (fsblkcnt_t) total_allocation_units;
+                        st->f_bfree =
+                                (fsblkcnt_t) actual_allocation_units;
+                }
+
+                flags |= SMBC_VFS_FEATURE_NO_UNIXCIFS;
+        } else {
+                uint32 optimal_transfer_size;
+                uint32 block_size;
+                SMB_BIG_UINT total_blocks;
+                SMB_BIG_UINT blocks_available;
+                SMB_BIG_UINT user_blocks_available;
+                SMB_BIG_UINT total_file_nodes;
+                SMB_BIG_UINT free_file_nodes;
+                SMB_BIG_UINT fs_identifier;
+
+                /* Has UNIXCIFS. If POSIX filesystem info is available... */
+                if (cli_get_posix_fs_info(cli,
+                                          &optimal_transfer_size,
+                                          &block_size,
+                                          &total_blocks,
+                                          &blocks_available,
+                                          &user_blocks_available,
+                                          &total_file_nodes,
+                                          &free_file_nodes,
+                                          &fs_identifier)) {
+
+                        /* ... then what's provided here takes precedence. */
+                        st->f_bsize =
+                                (unsigned long) block_size;
+                        st->f_blocks =
+                                (fsblkcnt_t) total_blocks;
+                        st->f_bfree =
+                                (fsblkcnt_t) blocks_available;
+                        st->f_bavail =
+                                (fsblkcnt_t) user_blocks_available;
+                        st->f_files =
+                                (fsfilcnt_t) total_file_nodes;
+                        st->f_ffree =
+                                (fsfilcnt_t) free_file_nodes;
+#if HAVE_FSID_INT
+                        st->f_fsid =
+                                (unsigned long) fs_identifier;
+#endif
+                }
+        }
+
+        /* See if the share is case sensitive */
+        if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
+                /*
+                 * We can't determine the case sensitivity of
+                 * the share. We have no choice but to use the
+                 * user-specified case sensitivity setting.
+                 */
+                if (! smbc_getOptionCaseSensitive(context)) {
+                        flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
+                }
+        } else {
+                if (! (fs_attrs & FILE_CASE_SENSITIVE_SEARCH)) {
+                        flags |= SMBC_VFS_FEATURE_CASE_INSENSITIVE;
+                }
+        }
+
+        /* See if DFS is supported */
+        if ((cli->capabilities & CAP_DFS) &&  cli->dfsroot) {
+                flags |= SMBC_VFS_FEATURE_DFS;
+        }
+
+#if HAVE_STATVFS_F_FLAG
+        st->f_flag = flags;
+#elif HAVE_STATVFS_F_FLAGS
+        st->f_flags = flags;
+#endif
+
+        return 0;
+}

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

@@ -1274 +1274 @@
                                                             ",%s:%lu",
                                                             attr_strings.create_time_attr,
-                                                            create_time);
+                                                            (unsigned long) create_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1284 +1284 @@
                                                      ",%s:%lu",
                                                      attr_strings.create_time_attr,
-                                                     create_time);
+                                                     (unsigned long) create_time);
                                 }
                         } else if (StrCaseCmp(name, attr_strings.create_time_attr) == 0) {
                                 if (determine_size) {
-                                        p = talloc_asprintf(ctx, "%lu", create_time);
+                                        p = talloc_asprintf(ctx, "%lu", (unsigned long) create_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1296 +1296 @@
                                 } else {
                                         n = snprintf(buf, bufsize,
-                                                     "%lu", create_time);
+                                                     "%lu", (unsigned long) create_time);
                                 }
                         }
@@ -1316 +1316 @@
                                                             ",%s:%lu",
                                                             attr_strings.access_time_attr,
-                                                            access_time);
+                                                            (unsigned long) access_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1326 +1326 @@
                                                      ",%s:%lu",
                                                      attr_strings.access_time_attr,
-                                                     access_time);
+                                                     (unsigned long) access_time);
                                 }
                         } else if (StrCaseCmp(name, attr_strings.access_time_attr) == 0) {
                                 if (determine_size) {
-                                        p = talloc_asprintf(ctx, "%lu", access_time);
+                                        p = talloc_asprintf(ctx, "%lu", (unsigned long) access_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1338 +1338 @@
                                 } else {
                                         n = snprintf(buf, bufsize,
-                                                     "%lu", access_time);
+                                                     "%lu", (unsigned long) access_time);
                                 }
                         }
@@ -1358 +1358 @@
                                                             ",%s:%lu",
                                                             attr_strings.write_time_attr,
-                                                            write_time);
+                                                            (unsigned long) write_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1368 +1368 @@
                                                      ",%s:%lu",
                                                      attr_strings.write_time_attr,
-                                                     write_time);
+                                                     (unsigned long) write_time);
                                 }
                         } else if (StrCaseCmp(name, attr_strings.write_time_attr) == 0) {
                                 if (determine_size) {
-                                        p = talloc_asprintf(ctx, "%lu", write_time);
+                                        p = talloc_asprintf(ctx, "%lu", (unsigned long) write_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1380 +1380 @@
                                 } else {
                                         n = snprintf(buf, bufsize,
-                                                     "%lu", write_time);
+                                                     "%lu", (unsigned long) write_time);
                                 }
                         }
@@ -1400 +1400 @@
                                                             ",%s:%lu",
                                                             attr_strings.change_time_attr,
-                                                            change_time);
+                                                            (unsigned long) change_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1410 +1410 @@
                                                      ",%s:%lu",
                                                      attr_strings.change_time_attr,
-                                                     change_time);
+                                                     (unsigned long) change_time);
                                 }
                         } else if (StrCaseCmp(name, attr_strings.change_time_attr) == 0) {
                                 if (determine_size) {
-                                        p = talloc_asprintf(ctx, "%lu", change_time);
+                                        p = talloc_asprintf(ctx, "%lu", (unsigned long) change_time);
                                         if (!p) {
                                                 errno = ENOMEM;
@@ -1422 +1422 @@
                                 } else {
                                         n = snprintf(buf, bufsize,
-                                                     "%lu", change_time);
+                                                     "%lu", (unsigned long) change_time);
                                 }
                         }
@@ -1502 +1502 @@
          POLICY_HND *pol,
          const char *filename,
-         const char *the_acl,
+         char *the_acl,
          int mode,
          int flags)
@@ -1532 +1532 @@
                 }
                 
-                sd = sec_desc_parse(ctx, ipc_cli, pol, numeric,
-                                    CONST_DISCARD(char *, the_acl));
+                sd = sec_desc_parse(ctx, ipc_cli, pol, numeric, the_acl);
                 
                 if (!sd) {
@@ -2115 +2114 @@
                 
                 /* Yup. */
+                char *filename = (char *) name;
                 ret = cacl_get(context, talloc_tos(), srv,
                                ipc_srv == NULL ? NULL : ipc_srv->cli, 
                                &ipc_srv->pol, path,
-                               CONST_DISCARD(char *, name),
-                               CONST_DISCARD(char *, value), size);
+                               filename,
+                               CONST_DISCARD(char *, value),
+                               size);
                 if (ret < 0 && errno == 0) {
                         errno = SMBC_errno(context, srv->cli);
@@ -2238 +2239 @@
                 ret = cacl_set(talloc_tos(), srv->cli,
                                ipc_srv->cli, &ipc_srv->pol, path,
-                               name + 19, SMBC_XATTR_MODE_REMOVE, 0);
+                               CONST_DISCARD(char *, name) + 19,
+                               SMBC_XATTR_MODE_REMOVE, 0);
                 TALLOC_FREE(frame);
                 return ret;

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

@@ -1503 +1503 @@
 
         DEBUG(10, ("internal_resolve_name: looking up %s#%x (sitename %s)\n",
-                        name, name_type, sitename ? sitename : NULL));
+                        name, name_type, sitename ? sitename : "(null)"));
 
         if (is_ipaddress(name)) {
@@ -2142 +2142 @@
                         bool ads_only )
 {
-        bool ordered;
+        bool ordered = false;
         NTSTATUS status;
         enum dc_lookup_type lookup_type = DC_NORMAL_LOOKUP;