Merge ~joalif/ubuntu/+source/cifs-utils:lp1886551-bionic into ubuntu/+source/cifs-utils:ubuntu/devel

[Ioanna Alifieraki]

[Andreas Hasenack (ahasenack)]

The target of this merge needs to be ubuntu/bionic-devel, not ubuntu/devel, as the latter one represents groovy at the moment

Unmerged commits

b070456... by Ioanna Alifieraki on 2020-09-10

update debian/changelog

7f4bffe... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #18

a1d84a2... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #17

b576b0b... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #16

0f28916... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #15

8a6bf1c... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #14

9358f8e... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #13

d26d8db... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #12

406bc80... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #11

a66a231... by Ioanna Alifieraki on 2020-09-10

LP #1886551 patch #10

diff --git a/debian/changelog b/debian/changelog
index eaa06da..24347d8 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,4 @@
+<<<<<<< debian/changelog
 cifs-utils (2:6.10-0ubuntu1) groovy; urgency=medium
 
   [ Sergio Durigan Junior ]
@@ -37,6 +38,38 @@ cifs-utils (2:6.8-2) unstable; urgency=medium
   * Update Standards-Version to 4.1.4, no change
 
  -- Mathieu Parent <[e-mail]>  Sun, 17 Jun 2018 21:58:28 +0200
+=======
+cifs-utils (2:6.8-1ubuntu2) bionic; urgency=medium
+
+  * d/p/0001-smbinfo-add-a-utility-to-display-smb-specific-inform.patch
+  * d/p/0002-smbinfo.rst-document-kernel-version.patch
+  * d/p/0003-smbinfo-Add-more-File-Information-classes.patch
+  * d/p/0004-smbinfo-update-help-text.patch
+  * d/p/0005-smbinfo-Update-the-usage-text-with-the-new-infolevel.patch
+  * d/p/0006-smbinfo-add-FileFsFullSizeInformation.patch
+  * d/p/0007-smbinfo-decode-the-ACEs.patch
+  * d/p/0008-smbinfo-fix-code-style.patch
+  * d/p/0009-smbinfo-add-fsctl-getobjid-support.patch
+  * d/p/0010-smbinfo-missing-help-for-fsctl-getobjid.patch
+  * d/p/0011-smbinfo-Add-ability-to-query-snapshots-previous-vers.patch
+  * d/p/0012-smbinfo-make-argument-order-consistent.patch
+  * d/p/0013-smbinfo-use-constant-for-input-buffer-length.patch
+  * d/p/0014-smbinfo-Improve-help-usage-and-add-h-option.patch
+  * d/p/0015-smbinfo-add-GETCOMPRESSION-support.patch
+  * d/p/0016-smbinfo-print-the-security-information-needed-to-dec.patch
+  * d/p/0017-smbinfo-Add-SETCOMPRESSION-support.patch
+  * d/p/0018-smbinfo.rst-document-new-keys-command.patch :
+    Add smbinfo utility and 'keys' command (LP: #1886551) 
+
+ -- Ioanna Alifieraki <[e-mail]>  Thu, 10 Sep 2020 02:31:09 +0100
+
+cifs-utils (2:6.8-1ubuntu1) bionic; urgency=medium
+
+  * d/p/setcifsacl-fix-adding-ACE-when-owner-sid-in-unexpect.patch:
+    Fix adding ACE when owner sid in unexpected location (LP: #1886548)
+
+ -- Eric Desrochers <[e-mail]>  Wed, 08 Jul 2020 17:44:31 +0000
+>>>>>>> debian/changelog
 
 cifs-utils (2:6.8-1) unstable; urgency=medium
 
diff --git a/debian/patches/0001-smbinfo-add-a-utility-to-display-smb-specific-inform.patch b/debian/patches/0001-smbinfo-add-a-utility-to-display-smb-specific-inform.patch
new file mode 100644
index 0000000..988b651
--- /dev/null
+++ b/debian/patches/0001-smbinfo-add-a-utility-to-display-smb-specific-inform.patch
@@ -0,0 +1,465 @@
+From 3eb33a11665aebc503024b1b8ed655a32eb55035 Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=3eb33a11665aebc503024b1b8ed655a32eb55035
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Wed, 3 Oct 2018 10:42:03 +1000
+Subject: [PATCH] smbinfo: add a utility to display smb specific information
+ about objects
+
+For example
+  smbinfo secdesc <file> will print the security descriptor
+  smbinfo quota <file> will print the quotas for the volume
+
+Signed-off-by: Aurelien Aptel <[e-mail]>
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ Makefile.am  |   6 +
+ configure.ac |   6 +
+ smbinfo.c    | 305 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ smbinfo.rst  |  81 ++++++++++++++
+ 4 files changed, 398 insertions(+)
+ create mode 100644 smbinfo.c
+ create mode 100644 smbinfo.rst
+
+diff --git a/Makefile.am b/Makefile.am
+index f37c9ae..8291b99 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -79,6 +79,12 @@ setcifsacl.rst: setcifsacl.rst.in
+ 	$(SED) 's,[@]pluginpath@,$(pluginpath),' $(srcdir)/$@.in > $@-t && mv $@-t $@
+ endif
+ 
++if CONFIG_SMBINFO
++bin_PROGRAMS += smbinfo
++smbinfo_SOURCES = smbinfo.c
++rst_man_pages += smbinfo.1
++endif
++
+ if CONFIG_PLUGIN
+ plugindir = $(pkglibdir)
+ plugin_PROGRAMS = idmapwb.so
+diff --git a/configure.ac b/configure.ac
+index 8e3d6ce..aaef452 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -40,6 +40,11 @@ AC_ARG_ENABLE(cifsacl,
+ 	enable_cifsacl=$enableval,
+ 	enable_cifsacl="maybe")
+ 
++AC_ARG_ENABLE(smbinfo,
++        [AS_HELP_STRING([--enable-smbinfo],[Create smbinfo binary @<:@default=yes@@])],
++        enable_smbinfo=$enableval,
++        enable_smbinfo="maybe")
++
+ AC_ARG_ENABLE(pam,
+ 	[AS_HELP_STRING([--enable-pam],[Create cifscreds PAM module @<:@default=yes@:>@])],
+ 	enable_pam=$enableval,
+@@ -275,6 +280,7 @@ AM_CONDITIONAL(CONFIG_CIFSUPCALL, [test "$enable_cifsupcall" != "no"])
+ AM_CONDITIONAL(CONFIG_CIFSCREDS, [test "$enable_cifscreds" != "no"])
+ AM_CONDITIONAL(CONFIG_CIFSIDMAP, [test "$enable_cifsidmap" != "no"])
+ AM_CONDITIONAL(CONFIG_CIFSACL, [test "$enable_cifsacl" != "no"])
++AM_CONDITIONAL(CONFIG_SMBINFO, [test "$enable_smbinfo" != "no"])
+ AM_CONDITIONAL(CONFIG_PAM, [test "$enable_pam" != "no"])
+ AM_CONDITIONAL(CONFIG_PLUGIN, [test "$enable_cifsidmap" != "no" -o "$enable_cifsacl" != "no"])
+ 
+diff --git a/smbinfo.c b/smbinfo.c
+new file mode 100644
+index 0000000..b1c129b
+--- /dev/null
++++ b/smbinfo.c
+@@ -0,0 +1,305 @@
++/*
++ * smbinfo
++ *
++ * Copyright (C) Ronnie Sahlberg ([e-mail]) 2018
++ * Copyright (C) Aurelien Aptel ([e-mail]) 2018
++ *
++ * Display SMB-specific file information using cifs IOCTL
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif /* HAVE_CONFIG_H */
++
++#include <endian.h>
++#include <errno.h>
++#include <getopt.h>
++#include <sys/ioctl.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++#include <fcntl.h>
++#include <string.h>
++#include <stdint.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <time.h>
++#include <unistd.h>
++#include <inttypes.h>
++
++#define CIFS_IOCTL_MAGIC 0xCF
++struct smb_query_info {
++        uint32_t   info_type;
++        uint32_t   file_info_class;
++        uint32_t   additional_information;
++        uint32_t   flags;
++        uint32_t   input_buffer_length;
++        uint32_t   output_buffer_length;
++        /* char buffer[]; */
++} __packed;
++
++#define CIFS_QUERY_INFO _IOWR(CIFS_IOCTL_MAGIC, 7, struct smb_query_info)
++#define INPUT_BUFFER_LENGTH 16384
++
++static void
++usage(char *name)
++{
++        fprintf(stderr, "Usage: %s <command> <file>\n"
++                "Commands are\n"
++                "  secdesc:\n"
++                "      Prints the security descriptor for a cifs file.\n"
++                "  quota:\n"
++                "      Prints the quota for a cifs file.\n",
++                name);
++        exit(1);
++}
++
++static void
++print_sid(unsigned char *sd)
++{
++        int i;
++        uint32_t subauth;
++        uint64_t idauth;
++
++        if (sd[0] != 1) {
++                fprintf(stderr, "Unknown SID revision\n");
++                return;
++        }
++
++        idauth = 0;
++        for (i = 0; i < 6; i++)
++                idauth = (idauth << 8) | sd[2 + i];
++
++        printf("S-1-%" PRIu64, idauth);
++        for (i = 0; i < sd[1]; i++) {
++                memcpy(&subauth, &sd[8 + 4 * i], 4);
++                subauth = le32toh(subauth);
++                printf("-%d", subauth);
++        }
++}
++
++static void
++print_acl(unsigned char *sd)
++{
++        int i, j, off;
++        uint16_t count, size;
++
++        if (sd[0] != 2) {
++                fprintf(stderr, "Unknown ACL revision\n");
++                return;
++        }
++
++        memcpy(&count, &sd[4], 2);
++        count = le16toh(count);
++        off = 8;
++        for (i = 0; i < count; i++) {
++                printf("Type:%02x Flags:%02x ", sd[off], sd[off + 1]);
++                memcpy(&size, &sd[off + 2], 2);
++                size = le16toh(size);
++
++                for (j = 0; j < size; j++)
++                        printf("%02x", sd[off + 4 + j]);
++
++                off += size;
++                printf("\n");
++        }
++}
++
++static void
++print_sd(uint8_t *sd)
++{
++        int offset_owner, offset_group, offset_dacl;
++
++        printf("Revision:%d\n", sd[0]);
++        if (sd[0] != 1) {
++                fprintf(stderr, "Unknown SD revision\n");
++                exit(1);
++        }
++
++        printf("Control: %02x%02x\n", sd[2], sd[3]);
++
++        memcpy(&offset_owner, &sd[4], 4);
++        offset_owner = le32toh(offset_owner);
++        memcpy(&offset_group, &sd[8], 4);
++        offset_group = le32toh(offset_group);
++        memcpy(&offset_dacl, &sd[16], 4);
++        offset_dacl = le32toh(offset_dacl);
++
++        if (offset_owner) {
++                printf("Owner: ");
++                print_sid(&sd[offset_owner]);
++                printf("\n");
++        }
++        if (offset_group) {
++                printf("Group: ");
++                print_sid(&sd[offset_group]);
++                printf("\n");
++        }
++        if (offset_dacl) {
++                printf("DACL:\n");
++                print_acl(&sd[offset_dacl]);
++        }
++}
++
++void secdesc(int f) {
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++        qi->info_type = 0x03;
++        qi->file_info_class = 0;
++        qi->additional_information = 0x00000007; /* Owner, Group, Dacl */
++        qi->input_buffer_length = INPUT_BUFFER_LENGTH;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_sd((uint8_t *)(&qi[1]));
++}
++
++void
++win_to_timeval(uint64_t smb2_time, struct timeval *tv)
++{
++  tv->tv_usec = (smb2_time / 10) % 1000000;
++  tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
++}
++
++static void
++print_quota(unsigned char *sd)
++{
++        uint32_t u32, neo;
++        uint64_t u64;
++        struct timeval tv;
++        struct tm;
++        int i, off = 0;
++
++ one_more:
++        memcpy(&u32, &sd[off], 4);
++        neo = le32toh(u32);
++
++        memcpy(&u32, &sd[off + 4], 4);
++        u32 = le32toh(u32);
++        printf("SID Length %d\n", u32);
++
++        memcpy(&u64, &sd[off + 8], 8);
++        win_to_timeval(le64toh(u64), &tv);
++        printf("Change Time %s", ctime(&tv.tv_sec));
++
++        memcpy(&u64, &sd[off + 16], 8);
++        u64 = le32toh(u64);
++        printf("Quota Used %" PRIu64 "\n", u64);
++
++        memcpy(&u64, &sd[off + 24], 8);
++        u64 = le64toh(u64);
++        if (u64 == 0xffffffffffffffff) {
++                printf("Quota Threshold NO THRESHOLD\n");
++        } else {
++                printf("Quota Threshold %" PRIu64 "\n", u64);
++        }
++
++        memcpy(&u64, &sd[off + 32], 8);
++        u64 = le64toh(u64);
++        if (u64 == 0xffffffffffffffff) {
++                printf("Quota Limit NO LIMIT\n");
++        } else {
++                printf("Quota Limit %" PRIu64 "\n", u64);
++        }
++
++        printf("SID: S-1");
++        u64 = 0;
++        for (i = 0; i < 6; i++)
++                u64 = (u64 << 8) | sd[off + 42 + i];
++        printf("-%" PRIu64, u64);
++
++        for (i = 0; i < sd[off + 41]; i++) {
++                memcpy(&u32, &sd[off + 48 + 4 * i], 4);
++                u32 = le32toh(u32);
++                printf("-%u", u32);
++        }
++        printf("\n\n");
++        off += neo;
++
++        if (neo != 0) {
++                goto one_more;
++        }
++}
++
++void quota(int f) {
++        struct smb_query_info *qi;
++        char *buf;
++        int i;
++
++        qi = malloc(sizeof(struct smb_query_info) + 16384);
++        memset(qi, 0, sizeof(struct smb_query_info) + 16384);
++        qi->info_type = 0x04;
++        qi->file_info_class = 0;
++        qi->additional_information = 0; /* Owner, Group, Dacl */
++        qi->input_buffer_length = 16384;
++
++        buf = (char *)&qi[1];
++               buf[0] = 0; /* return single */
++        buf[1] = 1; /* restart scan */
++
++        /* sid list length */
++        i = 0;
++        memcpy(&buf[4], &i, 4);
++
++        qi->output_buffer_length = 16;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_quota((unsigned char *)(&qi[1]));
++}
++
++int main(int argc, char *argv[])
++{
++        int c;
++        int f;
++
++        while ((c = getopt_long(argc, argv, "v", NULL, NULL)) != -1) {
++                switch (c) {
++                case 'v':
++                        printf("smbinfo version %s\n", VERSION);
++                        return 0;
++                default:
++                        usage(argv[0]);
++                }
++        }
++
++        if (optind >= argc - 1)
++                usage(argv[0]);
++
++        if ((f = open(argv[optind + 1], O_RDONLY)) < 0) {
++                fprintf(stderr, "Failed to open %s\n", argv[optind + 1]);
++                exit(1);
++        }
++
++
++        if (!strcmp(argv[1], "secdesc")) {
++                secdesc(f);
++        } else if (!strcmp(argv[1], "quota")) {
++                quota(f);
++        } else {
++                fprintf(stderr, "Unknown command %s\n", argv[optind]);
++                exit(1);
++        }
++
++
++        close(f);
++        return 0;
++}
+diff --git a/smbinfo.rst b/smbinfo.rst
+new file mode 100644
+index 0000000..e37c709
+--- /dev/null
++++ b/smbinfo.rst
+@@ -0,0 +1,81 @@
++============
++smbinfo
++============
++
++-----------------------------------------------------------------------------------------------------
++Userspace helper to display SMB-specific file information for the Linux SMB client file system (CIFS)
++-----------------------------------------------------------------------------------------------------
++:Manual section: 1
++
++********
++SYNOPSIS
++********
++
++  smbinfo [-v] {command} {file system object}
++
++***********
++DESCRIPTION
++***********
++
++This tool is part of the cifs-utils suite.
++
++`smbinfo` is a userspace helper program for the Linux SMB
++client file system (CIFS). It is intended to display SMB-specific file
++informations such as Security Descriptors and Quota.
++
++This tool works by making an CIFS_QUERY_INFO IOCTL call to the Linux
++SMB client which in turn issues a SMB Query Info request and returns
++the result. This differs from `getcifsacl` which uses extended file
++attributes.
++
++*******
++OPTIONS
++*******
++
++-v
++  Print version number and exit.
++
++*******
++COMMAND
++*******
++
++`secdesc`: Print the security descriptor in the form
++- Revision
++- Control
++- Owner SID
++- Group SID
++- ACL
++- File types
++- File flags
++
++`quota`: Print the quota for the volume in the form
++- SID Length
++- Change Time
++- Quota Used
++- Quota Threshold
++- Quota Limit
++- SID
++
++*****
++NOTES
++*****
++
++Kernel support for smbinfo utilities requires the CIFS_QUERY_INFO
++IOCTL which was initially introduced in the XXX kernel and is only
++implemented for mount points using SMB2 or above (see mount.cifs(8)
++`vers` option).
++
++********
++SEE ALSO
++********
++
++mount.cifs(8), getcifsacl(1)
++
++******
++AUTHOR
++******
++
++Ronnie Sahlberg wrote the smbinfo program.
++
++The Linux CIFS Mailing list is the preferred place to ask questions
++regarding these programs.
+-- 
+2.17.1
+
diff --git a/debian/patches/0002-smbinfo.rst-document-kernel-version.patch b/debian/patches/0002-smbinfo.rst-document-kernel-version.patch
new file mode 100644
index 0000000..8ffa7fe
--- /dev/null
+++ b/debian/patches/0002-smbinfo.rst-document-kernel-version.patch
@@ -0,0 +1,28 @@
+From f0c95ea8d2835b16ac17895fa7bcbbfdc95ed708 Mon Sep 17 00:00:00 2001
+From: Aurelien Aptel <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=f0c95ea8d2835b16ac17895fa7bcbbfdc95ed708
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Thu, 24 Jan 2019 18:13:56 +0100
+Subject: [PATCH] smbinfo.rst: document kernel version
+
+Signed-off-by: Aurelien Aptel <[e-mail]>
+---
+ smbinfo.rst | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/smbinfo.rst b/smbinfo.rst
+index e37c709..a10edb1 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -61,7 +61,7 @@ NOTES
+ *****
+ 
+ Kernel support for smbinfo utilities requires the CIFS_QUERY_INFO
+-IOCTL which was initially introduced in the XXX kernel and is only
++IOCTL which was initially introduced in the 4.20 kernel and is only
+ implemented for mount points using SMB2 or above (see mount.cifs(8)
+ `vers` option).
+ 
+-- 
+2.17.1
+
diff --git a/debian/patches/0003-smbinfo-Add-more-File-Information-classes.patch b/debian/patches/0003-smbinfo-Add-more-File-Information-classes.patch
new file mode 100644
index 0000000..f0d1009
--- /dev/null
+++ b/debian/patches/0003-smbinfo-Add-more-File-Information-classes.patch
@@ -0,0 +1,602 @@
+From 0ca46dbb7d50d8872b60e71baa337d96884cd881 Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=0ca46dbb7d50d8872b60e71baa337d96884cd881
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Tue, 29 Jan 2019 16:53:57 +1000
+Subject: [PATCH] smbinfo: Add more File*Information classes
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 483 ++++++++++++++++++++++++++++++++++++++++++++++++++--
+ smbinfo.rst |  34 +++-
+ 2 files changed, 497 insertions(+), 20 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index b1c129b..7184a68 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -65,6 +65,447 @@ usage(char *name)
+         exit(1);
+ }
+ 
++static void
++win_to_timeval(uint64_t smb2_time, struct timeval *tv)
++{
++  tv->tv_usec = (smb2_time / 10) % 1000000;
++  tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
++}
++
++struct bit_string {
++        unsigned int bit;
++        char *string;
++};
++
++struct bit_string directory_access_mask[] = {
++        { 0x00000001, "LIST_DIRECTORY" },
++        { 0x00000002, "ADD_FILE" },
++        { 0x00000004, "ADD_SUBDIRECTORY" },
++        { 0x00000008, "READ_EA" },
++        { 0x00000010, "WRITE_EA" },
++        { 0x00000020, "TRAVERSE" },
++        { 0x00000040, "DELETE_CHILD" },
++        { 0x00000080, "READ_ATTRIBUTES" },
++        { 0x00000100, "WRITE_ATTRIBUTES" },
++        { 0x00010000, "DELETE" },
++        { 0x00020000, "READ_CONTROL" },
++        { 0x00040000, "WRITE_DAC" },
++        { 0x00080000, "WRITE_OWNER" },
++        { 0x00100000, "SYNCHRONIZER" },
++        { 0x01000000, "ACCESS_SYSTEM_SECURITY" },
++        { 0x02000000, "MAXIMUM_ALLOWED" },
++        { 0x10000000, "GENERIC_ALL" },
++        { 0x20000000, "GENERIC_EXECUTE" },
++        { 0x40000000, "GENERIC_WRITE" },
++        { 0x80000000, "GENERIC_READ" },
++        { 0, NULL }
++};
++
++struct bit_string file_access_mask[] = {
++        { 0x00000001, "READ_DATA" },
++        { 0x00000002, "WRITE_DATA" },
++        { 0x00000004, "APPEND_DATA" },
++        { 0x00000008, "READ_EA" },
++        { 0x00000010, "WRITE_EA" },
++        { 0x00000020, "EXECUTE" },
++        { 0x00000040, "DELETE_CHILD" },
++        { 0x00000080, "READ_ATTRIBUTES" },
++        { 0x00000100, "WRITE_ATTRIBUTES" },
++        { 0x00010000, "DELETE" },
++        { 0x00020000, "READ_CONTROL" },
++        { 0x00040000, "WRITE_DAC" },
++        { 0x00080000, "WRITE_OWNER" },
++        { 0x00100000, "SYNCHRONIZER" },
++        { 0x01000000, "ACCESS_SYSTEM_SECURITY" },
++        { 0x02000000, "MAXIMUM_ALLOWED" },
++        { 0x10000000, "GENERIC_ALL" },
++        { 0x20000000, "GENERIC_EXECUTE" },
++        { 0x40000000, "GENERIC_WRITE" },
++        { 0x80000000, "GENERIC_READ" },
++        { 0, NULL }
++};
++
++static void
++print_bits(uint32_t mask, struct bit_string *bs)
++{
++        while (bs->string) {
++                if (mask & bs->bit)
++                    printf("%s ", bs->string);
++                bs++;
++        }
++}
++
++static void
++print_fileaccessinfo(uint8_t *sd, int type)
++{
++        uint32_t access_flags;
++
++        memcpy(&access_flags, &sd[0], 4);
++        access_flags = le32toh(access_flags);
++
++        if (type == S_IFDIR) {
++                printf("Directory access flags 0x%08x: ", access_flags);
++                print_bits(access_flags, directory_access_mask);
++        } else {
++                printf("File/Printer access flags 0x%08x: ", access_flags);
++                print_bits(access_flags, file_access_mask);
++        }
++        printf("\n");
++}
++
++static void
++fileaccessinfo(int f)
++{
++        struct smb_query_info *qi;
++        struct stat st;
++
++        fstat(f, &st);
++
++        qi = malloc(sizeof(struct smb_query_info) + 4);
++        memset(qi, 0, sizeof(qi) + 4);
++        qi->info_type = 0x01;
++        qi->file_info_class = 8;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 4;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_fileaccessinfo((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
++        free(qi);
++}
++
++static void
++print_filealigninfo(uint8_t *sd)
++{
++        uint32_t mask;
++
++        memcpy(&mask, &sd[0], 4);
++        mask = le32toh(mask);
++
++        printf("File alignment: ");
++        if (mask == 0)
++                printf("BYTE_ALIGNMENT");
++        else if (mask == 1)
++                printf("WORD_ALIGNMENT");
++        else if (mask == 3)
++                printf("LONG_ALIGNMENT");
++        else if (mask == 7)
++                printf("QUAD_ALIGNMENT");
++        else if (mask == 15)
++                printf("OCTA_ALIGNMENT");
++        else if (mask == 31)
++                printf("32_bit_ALIGNMENT");
++        else if (mask == 63)
++                printf("64_bit_ALIGNMENT");
++        else if (mask == 127)
++                printf("128_bit_ALIGNMENT");
++        else if (mask == 255)
++                printf("254_bit_ALIGNMENT");
++        else if (mask == 511)
++                printf("512_bit_ALIGNMENT");
++
++        printf("\n");
++}
++
++static void
++filealigninfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 4);
++        memset(qi, 0, sizeof(qi) + 4);
++        qi->info_type = 0x01;
++        qi->file_info_class = 17;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 4;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filealigninfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++struct bit_string file_attributes_mask[] = {
++        { 0x00000001, "READ_ONLY" },
++        { 0x00000002, "HIDDEN" },
++        { 0x00000004, "SYSTEM" },
++        { 0x00000010, "DIRECTORY" },
++        { 0x00000020, "ARCHIVE" },
++        { 0x00000080, "NORMAL" },
++        { 0x00000100, "TEMPORARY" },
++        { 0x00000200, "SPARSE_FILE" },
++        { 0x00000400, "REPARSE_POINT" },
++        { 0x00000800, "COMPRESSED" },
++        { 0x00001000, "OFFLINE" },
++        { 0x00002000, "NOT_CONTENT_INDEXED" },
++        { 0x00004000, "ENCRYPTED" },
++        { 0x00008000, "INTEGRITY_STREAM" },
++        { 0x00020000, "NO_SCRUB_DATA" },
++        { 0, NULL }
++};
++
++static void
++print_filebasicinfo(uint8_t *sd)
++{
++        struct timeval tv;
++        uint64_t u64;
++        uint32_t u32;
++
++        memcpy(&u64, &sd[0], 8);
++        win_to_timeval(le64toh(u64), &tv);
++        printf("Creation Time %s", ctime(&tv.tv_sec));
++
++        memcpy(&u64, &sd[8], 8);
++        win_to_timeval(le64toh(u64), &tv);
++        printf("Last Access Time %s", ctime(&tv.tv_sec));
++
++        memcpy(&u64, &sd[16], 8);
++        win_to_timeval(le64toh(u64), &tv);
++        printf("Last Write Time %s", ctime(&tv.tv_sec));
++
++        memcpy(&u64, &sd[24], 8);
++        win_to_timeval(le64toh(u64), &tv);
++        printf("Last Change Time %s", ctime(&tv.tv_sec));
++
++        memcpy(&u32, &sd[32], 4);
++        u32 = le32toh(u32);
++        printf("File Attributes 0x%08x: ", u32);
++        print_bits(u32, file_attributes_mask);
++        printf("\n");
++}
++
++static void
++filebasicinfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 40);
++        memset(qi, 0, sizeof(qi) + 40);
++        qi->info_type = 0x01;
++        qi->file_info_class = 4;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 40;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filebasicinfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++static void
++print_filestandardinfo(uint8_t *sd)
++{
++        uint64_t u64;
++        uint32_t u32;
++
++        memcpy(&u64, &sd[0], 8);
++        printf("Allocation Size %" PRIu64 "\n", le64toh(u64));
++
++        memcpy(&u64, &sd[8], 8);
++        printf("End Of File %" PRIu64 "\n", le64toh(u64));
++
++        memcpy(&u32, &sd[16], 4);
++        printf("Number Of Links %" PRIu32 "\n", le32toh(u32));
++
++        printf("Delete Pending %d\n", sd[20]);
++        printf("Delete Directory %d\n", sd[21]);
++}
++
++static void
++filestandardinfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 24);
++        memset(qi, 0, sizeof(qi) + 24);
++        qi->info_type = 0x01;
++        qi->file_info_class = 5;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 24;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filestandardinfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++static void
++print_fileinternalinfo(uint8_t *sd)
++{
++        uint64_t u64;
++
++        memcpy(&u64, &sd[0], 8);
++        printf("Index Number %" PRIu64 "\n", le64toh(u64));
++}
++
++static void
++fileinternalinfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 8);
++        memset(qi, 0, sizeof(qi) + 8);
++        qi->info_type = 0x01;
++        qi->file_info_class = 6;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 8;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_fileinternalinfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++struct bit_string file_mode_mask[] = {
++        { 0x00000002, "WRITE_THROUGH" },
++        { 0x00000004, "SEQUENTIAL_ONLY" },
++        { 0x00000008, "NO_INTERMEDIATE_BUFFERING" },
++        { 0x00000010, "SYNCHRONOUS_IO_ALERT" },
++        { 0x00000020, "SYNCHRONOUS_IO_NONALERT" },
++        { 0x00001000, "DELETE_ON_CLOSE" },
++        { 0, NULL }
++};
++
++static void
++print_filemodeinfo(uint8_t *sd)
++{
++        uint32_t u32;
++
++        memcpy(&u32, &sd[32], 4);
++        u32 = le32toh(u32);
++        printf("Mode 0x%08x: ", u32);
++        print_bits(u32, file_mode_mask);
++        printf("\n");
++}
++
++static void
++filemodeinfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 4);
++        memset(qi, 0, sizeof(qi) + 4);
++        qi->info_type = 0x01;
++        qi->file_info_class = 16;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 4;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filemodeinfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++static void
++print_filepositioninfo(uint8_t *sd)
++{
++        uint64_t u64;
++
++        memcpy(&u64, &sd[0], 8);
++        printf("Current Byte Offset %" PRIu64 "\n", le64toh(u64));
++}
++
++static void
++filepositioninfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 8);
++        memset(qi, 0, sizeof(qi) + 8);
++        qi->info_type = 0x01;
++        qi->file_info_class = 14;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 8;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filepositioninfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++static void
++print_fileeainfo(uint8_t *sd)
++{
++        uint32_t u32;
++
++        memcpy(&u32, &sd[0], 4);
++        printf("Ea Size %" PRIu32 "\n", le32toh(u32));
++}
++
++static void
++fileeainfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 4);
++        memset(qi, 0, sizeof(qi) + 4);
++        qi->info_type = 0x01;
++        qi->file_info_class = 7;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 4;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_fileeainfo((uint8_t *)(&qi[1]));
++        free(qi);
++}
++
++static void
++fileallinfo(int f)
++{
++        struct smb_query_info *qi;
++        struct stat st;
++
++        fstat(f, &st);
++
++        qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++        memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
++        qi->info_type = 0x01;
++        qi->file_info_class = 18;
++        qi->additional_information = 0;
++        qi->input_buffer_length = INPUT_BUFFER_LENGTH;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filebasicinfo((uint8_t *)(&qi[1]));
++        print_filestandardinfo((uint8_t *)(&qi[1]) + 40);
++        print_fileinternalinfo((uint8_t *)(&qi[1]) + 64);
++        print_fileeainfo((uint8_t *)(&qi[1]) + 72);
++        print_fileaccessinfo((uint8_t *)(&qi[1]) + 76, st.st_mode & S_IFMT);
++        print_filepositioninfo((uint8_t *)(&qi[1]) + 80);
++        print_filemodeinfo((uint8_t *)(&qi[1]) + 88);
++        print_filealigninfo((uint8_t *)(&qi[1]) + 92);
++        // SMB2 servers like Win16 does not seem to return name info
++        free(qi);
++}
++
+ static void
+ print_sid(unsigned char *sd)
+ {
+@@ -152,10 +593,13 @@ print_sd(uint8_t *sd)
+         }
+ }
+ 
+-void secdesc(int f) {
++static void
++secdesc(int f)
++{
+         struct smb_query_info *qi;
+ 
+         qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++        memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
+         qi->info_type = 0x03;
+         qi->file_info_class = 0;
+         qi->additional_information = 0x00000007; /* Owner, Group, Dacl */
+@@ -167,13 +611,7 @@ void secdesc(int f) {
+         }
+ 
+         print_sd((uint8_t *)(&qi[1]));
+-}
+-
+-void
+-win_to_timeval(uint64_t smb2_time, struct timeval *tv)
+-{
+-  tv->tv_usec = (smb2_time / 10) % 1000000;
+-  tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
++        free(qi);
+ }
+ 
+ static void
+@@ -236,7 +674,9 @@ print_quota(unsigned char *sd)
+         }
+ }
+ 
+-void quota(int f) {
++static void
++quota(int f)
++{
+         struct smb_query_info *qi;
+         char *buf;
+         int i;
+@@ -264,6 +704,7 @@ void quota(int f) {
+         }
+ 
+         print_quota((unsigned char *)(&qi[1]));
++        free(qi);
+ }
+ 
+ int main(int argc, char *argv[])
+@@ -290,11 +731,29 @@ int main(int argc, char *argv[])
+         }
+ 
+ 
+-        if (!strcmp(argv[1], "secdesc")) {
++        if (!strcmp(argv[1], "fileaccessinfo"))
++                fileaccessinfo(f);
++        else if (!strcmp(argv[1], "filealigninfo"))
++                filealigninfo(f);
++        else if (!strcmp(argv[1], "fileallinfo"))
++                fileallinfo(f);
++        else if (!strcmp(argv[1], "filebasicinfo"))
++                filebasicinfo(f);
++        else if (!strcmp(argv[1], "fileeainfo"))
++                fileeainfo(f);
++        else if (!strcmp(argv[1], "fileinternalinfo"))
++                fileinternalinfo(f);
++        else if (!strcmp(argv[1], "filemodeinfo"))
++                filemodeinfo(f);
++        else if (!strcmp(argv[1], "filepositioninfo"))
++                filepositioninfo(f);
++        else if (!strcmp(argv[1], "filestandardinfo"))
++                filestandardinfo(f);
++        else if (!strcmp(argv[1], "secdesc"))
+                 secdesc(f);
+-        } else if (!strcmp(argv[1], "quota")) {
++        else if (!strcmp(argv[1], "quota"))
+                 quota(f);
+-        } else {
++        else {
+                 fprintf(stderr, "Unknown command %s\n", argv[optind]);
+                 exit(1);
+         }
+diff --git a/smbinfo.rst b/smbinfo.rst
+index a10edb1..85de4cb 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -39,14 +39,23 @@ OPTIONS
+ COMMAND
+ *******
+ 
+-`secdesc`: Print the security descriptor in the form
+-- Revision
+-- Control
+-- Owner SID
+-- Group SID
+-- ACL
+-- File types
+-- File flags
++`fileaccessinfo`: Prints the FileAccessInformation class
++
++`filealigninfo`: Prints the FileAlignmentInformation class
++
++`fileallinfo`: Prints the FileAllInformation class
++
++`filebasicinfo`: Prints the FileBasicInformation class
++
++`fileeainfo`: Prints the FileEaInformation class
++
++`fileinternalinfo`: Prints the FileInternalInformation class
++
++`filemodeinfo`: Prints the FileModeInformation class
++
++`filepositioninfo`: Prints the FilePositionInformation class
++
++`filestandardinfo`: Prints the FileStandardInformation class
+ 
+ `quota`: Print the quota for the volume in the form
+ - SID Length
+@@ -56,6 +65,15 @@ COMMAND
+ - Quota Limit
+ - SID
+ 
++`secdesc`: Print the security descriptor in the form
++- Revision
++- Control
++- Owner SID
++- Group SID
++- ACL
++- File types
++- File flags
++
+ *****
+ NOTES
+ *****
+-- 
+2.17.1
+
diff --git a/debian/patches/0004-smbinfo-update-help-text.patch b/debian/patches/0004-smbinfo-update-help-text.patch
new file mode 100644
index 0000000..0032c72
--- /dev/null
+++ b/debian/patches/0004-smbinfo-update-help-text.patch
@@ -0,0 +1,36 @@
+From db9d117fd6e2660768a35e72a374540ffc68d36d Mon Sep 17 00:00:00 2001
+From: Steve French <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=db9d117fd6e2660768a35e72a374540ffc68d36d
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Tue, 29 Jan 2019 07:03:01 -0600
+Subject: [PATCH] smbinfo: update help text
+
+Add description for fileallinfo query option.
+
+Note that there are eight other recently added query options, but they
+are mostly a subset a "fileallinfo" so could be of little value
+(and may even be very confusing if we documented all nine in the
+help text in smbinfo, instead of just this one).  The man page
+has a full description of them.
+
+Signed-off-by: Steve French <[e-mail]>
+---
+ smbinfo.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 7184a68..76e722e 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -57,6 +57,8 @@ usage(char *name)
+ {
+         fprintf(stderr, "Usage: %s <command> <file>\n"
+                 "Commands are\n"
++                "  fileallinfo:\n"
++                "      Prints common metadata associated with a file.\n"
+                 "  secdesc:\n"
+                 "      Prints the security descriptor for a cifs file.\n"
+                 "  quota:\n"
+-- 
+2.17.1
+
diff --git a/debian/patches/0005-smbinfo-Update-the-usage-text-with-the-new-infolevel.patch b/debian/patches/0005-smbinfo-Update-the-usage-text-with-the-new-infolevel.patch
new file mode 100644
index 0000000..f8e2c76
--- /dev/null
+++ b/debian/patches/0005-smbinfo-Update-the-usage-text-with-the-new-infolevel.patch
@@ -0,0 +1,45 @@
+From 858ac4df38169d0b7835113c54a0f85d309303ce Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=858ac4df38169d0b7835113c54a0f85d309303ce
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Wed, 13 Feb 2019 15:47:36 +1000
+Subject: [PATCH] smbinfo: Update the usage text with the new infolevels
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c | 18 +++++++++++++++++-
+ 1 file changed, 17 insertions(+), 1 deletion(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 76e722e..5815f06 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -57,8 +57,24 @@ usage(char *name)
+ {
+         fprintf(stderr, "Usage: %s <command> <file>\n"
+                 "Commands are\n"
++                "  fileaccessinfo:\n"
++                "      Prints FileAccessInfo for a cifs file.\n"
++                "  filealigninfo:\n"
++                "      Prints FileAlignInfo for a cifs file.\n"
+                 "  fileallinfo:\n"
+-                "      Prints common metadata associated with a file.\n"
++                "      Prints FileAllInfo for a cifs file.\n"
++                "  filebasicinfo:\n"
++                "      Prints FileBasicInfo for a cifs file.\n"
++                "  fileeainfo:\n"
++                "      Prints FileEAInfo for a cifs file.\n"
++                "  fileinternalinfo:\n"
++                "      Prints FileInternalInfo for a cifs file.\n"
++                "  filemodeinfo:\n"
++                "      Prints FileModeInfo for a cifs file.\n"
++                "  filepositioninfo:\n"
++                "      Prints FilePositionInfo for a cifs file.\n"
++                "  filestandardinfo:\n"
++                "      Prints FileStandardInfo for a cifs file.\n"
+                 "  secdesc:\n"
+                 "      Prints the security descriptor for a cifs file.\n"
+                 "  quota:\n"
+-- 
+2.17.1
+
diff --git a/debian/patches/0006-smbinfo-add-FileFsFullSizeInformation.patch b/debian/patches/0006-smbinfo-add-FileFsFullSizeInformation.patch
new file mode 100644
index 0000000..2554f12
--- /dev/null
+++ b/debian/patches/0006-smbinfo-add-FileFsFullSizeInformation.patch
@@ -0,0 +1,103 @@
+From 70902177e944c79aeb5c88e2092ef329724138fc Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=70902177e944c79aeb5c88e2092ef329724138fc
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Wed, 13 Feb 2019 15:47:37 +1000
+Subject: [PATCH] smbinfo: add FileFsFullSizeInformation
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
+ smbinfo.rst |  2 ++
+ 2 files changed, 51 insertions(+)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 5815f06..02910c6 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -67,6 +67,8 @@ usage(char *name)
+                 "      Prints FileBasicInfo for a cifs file.\n"
+                 "  fileeainfo:\n"
+                 "      Prints FileEAInfo for a cifs file.\n"
++                "  filefsfullsizeinfo:\n"
++                "      Prints FileFsFullSizeInfo for a cifs share.\n"
+                 "  fileinternalinfo:\n"
+                 "      Prints FileInternalInfo for a cifs file.\n"
+                 "  filemodeinfo:\n"
+@@ -492,6 +494,51 @@ fileeainfo(int f)
+         free(qi);
+ }
+ 
++static void
++print_filefullsizeinfo(uint8_t *sd)
++{
++        uint32_t u32;
++        uint64_t u64;
++
++        memcpy(&u64, &sd[0], 8);
++        printf("Total Allocation Units: %" PRIu64 "\n", le64toh(u64));
++
++        memcpy(&u64, &sd[8], 8);
++        printf("Caller Available Allocation Units: %" PRIu64 "\n",
++	       le64toh(u64));
++
++        memcpy(&u64, &sd[16], 8);
++        printf("Actual Available Allocation Units: %" PRIu64 "\n",
++	       le64toh(u64));
++
++        memcpy(&u32, &sd[24], 4);
++        printf("Sectors Per Allocation Unit: %" PRIu32 "\n", le32toh(u32));
++
++        memcpy(&u32, &sd[28], 4);
++        printf("Bytes Per Sector: %" PRIu32 "\n", le32toh(u32));
++}
++
++static void
++filefsfullsizeinfo(int f)
++{
++        struct smb_query_info *qi;
++
++        qi = malloc(sizeof(struct smb_query_info) + 32);
++	memset(qi, 0, sizeof(qi) + 32);
++        qi->info_type = 0x02;
++        qi->file_info_class = 7;
++        qi->additional_information = 0;
++        qi->input_buffer_length = 32;
++
++        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++                exit(1);
++        }
++
++        print_filefullsizeinfo((uint8_t *)(&qi[1]));
++	free(qi);
++}
++
+ static void
+ fileallinfo(int f)
+ {
+@@ -759,6 +806,8 @@ int main(int argc, char *argv[])
+                 filebasicinfo(f);
+         else if (!strcmp(argv[1], "fileeainfo"))
+                 fileeainfo(f);
++        else if (!strcmp(argv[1], "filefsfullsizeinfo"))
++                filefsfullsizeinfo(f);
+         else if (!strcmp(argv[1], "fileinternalinfo"))
+                 fileinternalinfo(f);
+         else if (!strcmp(argv[1], "filemodeinfo"))
+diff --git a/smbinfo.rst b/smbinfo.rst
+index 85de4cb..5222a71 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -49,6 +49,8 @@ COMMAND
+ 
+ `fileeainfo`: Prints the FileEaInformation class
+ 
++`filefsfullsizeinfo`: Prints the FileFsFullSizeInformation class
++
+ `fileinternalinfo`: Prints the FileInternalInformation class
+ 
+ `filemodeinfo`: Prints the FileModeInformation class
+-- 
+2.17.1
+
diff --git a/debian/patches/0007-smbinfo-decode-the-ACEs.patch b/debian/patches/0007-smbinfo-decode-the-ACEs.patch
new file mode 100644
index 0000000..0fc50a6
--- /dev/null
+++ b/debian/patches/0007-smbinfo-decode-the-ACEs.patch
@@ -0,0 +1,347 @@
+From 1191a6cafde1f6e39546cab26a5b90c3cca523fd Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=1191a6cafde1f6e39546cab26a5b90c3cca523fd
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 1 Mar 2019 12:05:58 +1000
+Subject: [PATCH] smbinfo: decode the ACEs
+
+Decode the most common ACE types and provide a [-V]erbose option
+to show the individual mask bits by name.
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 197 +++++++++++++++++++++++++++++++++++++++++++---------
+ smbinfo.rst |   5 +-
+ 2 files changed, 168 insertions(+), 34 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 02910c6..6290a4c 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -52,10 +52,13 @@ struct smb_query_info {
+ #define CIFS_QUERY_INFO _IOWR(CIFS_IOCTL_MAGIC, 7, struct smb_query_info)
+ #define INPUT_BUFFER_LENGTH 16384
+ 
++int verbose;
++
+ static void
+ usage(char *name)
+ {
+-        fprintf(stderr, "Usage: %s <command> <file>\n"
++        fprintf(stderr, "Usage: %s [-V] <command> <file>\n"
++                "-V for verbose output\n"
+                 "Commands are\n"
+                 "  fileaccessinfo:\n"
+                 "      Prints FileAccessInfo for a cifs file.\n"
+@@ -148,11 +151,22 @@ struct bit_string file_access_mask[] = {
+ static void
+ print_bits(uint32_t mask, struct bit_string *bs)
+ {
++        int first = 1;
++
++        if (!verbose) {
++                return;
++        }
++
+         while (bs->string) {
+-                if (mask & bs->bit)
+-                    printf("%s ", bs->string);
++                if (mask & bs->bit) {
++                        printf("%s%s", first?"":",", bs->string);
++                        first = 0;
++                }
+                 bs++;
+         }
++        if (!first) {
++                printf(" ");
++        }
+ }
+ 
+ static void
+@@ -591,17 +605,106 @@ print_sid(unsigned char *sd)
+         for (i = 0; i < sd[1]; i++) {
+                 memcpy(&subauth, &sd[8 + 4 * i], 4);
+                 subauth = le32toh(subauth);
+-                printf("-%d", subauth);
++                printf("-%u", subauth);
+         }
+ }
+ 
+ static void
+-print_acl(unsigned char *sd)
++print_ace_type(uint8_t t)
++{
++        switch(t) {
++	case 0x00: printf("ALLOWED"); break;
++	case 0x01: printf("DENIED"); break;
++	case 0x02: printf("AUDIT"); break;
++	case 0x03: printf("ALARM"); break;
++	case 0x04: printf("ALLOWED_COMPOUND"); break;
++	case 0x05: printf("ALLOWED_OBJECT"); break;
++	case 0x06: printf("DENIED_OBJECT"); break;
++	case 0x07: printf("AUDIT_OBJECT"); break;
++	case 0x08: printf("ALARM_OBJECT"); break;
++	case 0x09: printf("ALLOWED_CALLBACK"); break;
++	case 0x0a: printf("DENIED_CALLBACK"); break;
++	case 0x0b: printf("ALLOWED_CALLBACK_OBJECT"); break;
++	case 0x0c: printf("DENIED_CALLBACK_OBJECT"); break;
++	case 0x0d: printf("AUDIT_CALLBACK"); break;
++	case 0x0e: printf("ALARM_CALLBACK"); break;
++	case 0x0f: printf("AUDIT_CALLBACK_OBJECT"); break;
++	case 0x10: printf("ALARM_CALLBACK_OBJECT"); break;
++	case 0x11: printf("MANDATORY_LABEL"); break;
++	case 0x12: printf("RESOURCE_ATTRIBUTE"); break;
++	case 0x13: printf("SCOPED_POLICY_ID"); break;
++	default: printf("<UNKNOWN>");
++	}
++	printf(" ");
++}
++
++struct bit_string ace_flags_mask[] = {
++        { 0x80, "FAILED_ACCESS" },
++        { 0x40, "SUCCESSFUL_ACCESS" },
++        { 0x10, "INHERITED" },
++        { 0x08, "INHERIT_ONLY" },
++        { 0x04, "NO_PROPAGATE_INHERIT" },
++        { 0x02, "CONTAINER_INHERIT" },
++        { 0x01, "OBJECT_INHERIT" },
++        { 0, NULL }
++};
++
++static void
++print_mask_sid_ace(unsigned char *sd, int type)
++{
++        uint32_t u32;
++
++        memcpy(&u32, &sd[0], 4);
++	printf("Mask:0x%08x ", le32toh(u32));
++	if (type == S_IFDIR) {
++		print_bits(le32toh(u32), directory_access_mask);
++        } else {
++		print_bits(le32toh(u32), file_access_mask);
++	}
++	printf("SID:");
++	print_sid(&sd[4]);
++	printf("\n");
++}
++
++static int
++print_ace(unsigned char *sd, int type)
++{
++        uint16_t size;
++	int i;
++
++	printf("Type:0x%02x ", sd[0]);
++	if (verbose) {
++		print_ace_type(sd[0]);
++	}
++
++	printf("Flags:0x%02x ", sd[1]);
++	print_bits(sd[1], ace_flags_mask);
++
++	memcpy(&size, &sd[2], 2);
++	size = le16toh(size);
++
++	switch (sd[0]) {
++	case 0x00:
++	case 0x01:
++	case 0x02:
++		print_mask_sid_ace(&sd[4], type);
++		break;
++	default:
++		for (i = 0; i < size; i++)
++			printf("%02x", sd[4 + i]);
++	}
++
++	printf("\n");
++	return size;
++}
++
++static void
++print_acl(unsigned char *sd, int type)
+ {
+-        int i, j, off;
+-        uint16_t count, size;
++        int i, off;
++        uint16_t count;
+ 
+-        if (sd[0] != 2) {
++        if ((sd[0] != 2) && (sd[0] != 4)) {
+                 fprintf(stderr, "Unknown ACL revision\n");
+                 return;
+         }
+@@ -610,22 +713,43 @@ print_acl(unsigned char *sd)
+         count = le16toh(count);
+         off = 8;
+         for (i = 0; i < count; i++) {
+-                printf("Type:%02x Flags:%02x ", sd[off], sd[off + 1]);
+-                memcpy(&size, &sd[off + 2], 2);
+-                size = le16toh(size);
++		off += print_ace(&sd[off], type);
++        }
++}
+ 
+-                for (j = 0; j < size; j++)
+-                        printf("%02x", sd[off + 4 + j]);
++struct bit_string control_bits_mask[] = {
++        { 0x8000, "SR" },
++        { 0x4000, "RM" },
++        { 0x2000, "PS" },
++        { 0x1000, "PD" },
++        { 0x0800, "SI" },
++        { 0x0400, "DI" },
++        { 0x0200, "SC" },
++        { 0x0100, "DC" },
++        { 0x0080, "DT" },
++        { 0x0040, "SS" },
++        { 0x0020, "SD" },
++        { 0x0010, "SP" },
++        { 0x0008, "DD" },
++        { 0x0004, "DP" },
++        { 0x0002, "GD" },
++        { 0x0001, "OD" },
++        { 0, NULL }
++};
+ 
+-                off += size;
+-                printf("\n");
+-        }
++static void
++print_control(uint16_t c)
++{
++	printf("Control: 0x%04x ", c);
++	print_bits(c, control_bits_mask);
++	printf("\n");
+ }
+ 
+ static void
+-print_sd(uint8_t *sd)
++print_sd(uint8_t *sd, int type)
+ {
+         int offset_owner, offset_group, offset_dacl;
++	uint16_t u16;
+ 
+         printf("Revision:%d\n", sd[0]);
+         if (sd[0] != 1) {
+@@ -633,7 +757,8 @@ print_sd(uint8_t *sd)
+                 exit(1);
+         }
+ 
+-        printf("Control: %02x%02x\n", sd[2], sd[3]);
++        memcpy(&u16, &sd[2], 2);
++        print_control(le16toh(u16));
+ 
+         memcpy(&offset_owner, &sd[4], 4);
+         offset_owner = le32toh(offset_owner);
+@@ -654,7 +779,7 @@ print_sd(uint8_t *sd)
+         }
+         if (offset_dacl) {
+                 printf("DACL:\n");
+-                print_acl(&sd[offset_dacl]);
++                print_acl(&sd[offset_dacl], type);
+         }
+ }
+ 
+@@ -662,6 +787,9 @@ static void
+ secdesc(int f)
+ {
+         struct smb_query_info *qi;
++        struct stat st;
++
++        fstat(f, &st);
+ 
+         qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
+         memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
+@@ -675,7 +803,7 @@ secdesc(int f)
+                 exit(1);
+         }
+ 
+-        print_sd((uint8_t *)(&qi[1]));
++        print_sd((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
+         free(qi);
+ }
+ 
+@@ -777,11 +905,14 @@ int main(int argc, char *argv[])
+         int c;
+         int f;
+ 
+-        while ((c = getopt_long(argc, argv, "v", NULL, NULL)) != -1) {
++        while ((c = getopt_long(argc, argv, "vV", NULL, NULL)) != -1) {
+                 switch (c) {
+                 case 'v':
+                         printf("smbinfo version %s\n", VERSION);
+                         return 0;
++                case 'V':
++			verbose = 1;
++			break;
+                 default:
+                         usage(argv[0]);
+                 }
+@@ -796,29 +927,29 @@ int main(int argc, char *argv[])
+         }
+ 
+ 
+-        if (!strcmp(argv[1], "fileaccessinfo"))
++        if (!strcmp(argv[optind], "fileaccessinfo"))
+                 fileaccessinfo(f);
+-        else if (!strcmp(argv[1], "filealigninfo"))
++        else if (!strcmp(argv[optind], "filealigninfo"))
+                 filealigninfo(f);
+-        else if (!strcmp(argv[1], "fileallinfo"))
++        else if (!strcmp(argv[optind], "fileallinfo"))
+                 fileallinfo(f);
+-        else if (!strcmp(argv[1], "filebasicinfo"))
++        else if (!strcmp(argv[optind], "filebasicinfo"))
+                 filebasicinfo(f);
+-        else if (!strcmp(argv[1], "fileeainfo"))
++        else if (!strcmp(argv[optind], "fileeainfo"))
+                 fileeainfo(f);
+-        else if (!strcmp(argv[1], "filefsfullsizeinfo"))
++        else if (!strcmp(argv[optind], "filefsfullsizeinfo"))
+                 filefsfullsizeinfo(f);
+-        else if (!strcmp(argv[1], "fileinternalinfo"))
++        else if (!strcmp(argv[optind], "fileinternalinfo"))
+                 fileinternalinfo(f);
+-        else if (!strcmp(argv[1], "filemodeinfo"))
++        else if (!strcmp(argv[optind], "filemodeinfo"))
+                 filemodeinfo(f);
+-        else if (!strcmp(argv[1], "filepositioninfo"))
++        else if (!strcmp(argv[optind], "filepositioninfo"))
+                 filepositioninfo(f);
+-        else if (!strcmp(argv[1], "filestandardinfo"))
++        else if (!strcmp(argv[optind], "filestandardinfo"))
+                 filestandardinfo(f);
+-        else if (!strcmp(argv[1], "secdesc"))
++        else if (!strcmp(argv[optind], "secdesc"))
+                 secdesc(f);
+-        else if (!strcmp(argv[1], "quota"))
++        else if (!strcmp(argv[optind], "quota"))
+                 quota(f);
+         else {
+                 fprintf(stderr, "Unknown command %s\n", argv[optind]);
+diff --git a/smbinfo.rst b/smbinfo.rst
+index 5222a71..9bfd313 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -11,7 +11,7 @@ Userspace helper to display SMB-specific file information for the Linux SMB clie
+ SYNOPSIS
+ ********
+ 
+-  smbinfo [-v] {command} {file system object}
++  smbinfo [-v] [-V] {command} {file system object}
+ 
+ ***********
+ DESCRIPTION
+@@ -35,6 +35,9 @@ OPTIONS
+ -v
+   Print version number and exit.
+ 
++-V
++  Verbose output.
++
+ *******
+ COMMAND
+ *******
+-- 
+2.17.1
+
diff --git a/debian/patches/0008-smbinfo-fix-code-style.patch b/debian/patches/0008-smbinfo-fix-code-style.patch
new file mode 100644
index 0000000..eb7078a
--- /dev/null
+++ b/debian/patches/0008-smbinfo-fix-code-style.patch
@@ -0,0 +1,1473 @@
+From f9f5d421d62decc5f0d025b77415708b1c45d234 Mon Sep 17 00:00:00 2001
+From: Pavel Shilovsky <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=f9f5d421d62decc5f0d025b77415708b1c45d234
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 8 Mar 2019 16:28:45 -0800
+Subject: [PATCH] smbinfo: fix code style
+
+Signed-off-by: Pavel Shilovsky <[e-mail]>
+---
+ smbinfo.c | 1175 ++++++++++++++++++++++++++---------------------------
+ 1 file changed, 583 insertions(+), 592 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 6290a4c..d7e7bf3 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -40,13 +40,13 @@
+ 
+ #define CIFS_IOCTL_MAGIC 0xCF
+ struct smb_query_info {
+-        uint32_t   info_type;
+-        uint32_t   file_info_class;
+-        uint32_t   additional_information;
+-        uint32_t   flags;
+-        uint32_t   input_buffer_length;
+-        uint32_t   output_buffer_length;
+-        /* char buffer[]; */
++	uint32_t   info_type;
++	uint32_t   file_info_class;
++	uint32_t   additional_information;
++	uint32_t   flags;
++	uint32_t   input_buffer_length;
++	uint32_t   output_buffer_length;
++	/* char buffer[]; */
+ } __packed;
+ 
+ #define CIFS_QUERY_INFO _IOWR(CIFS_IOCTL_MAGIC, 7, struct smb_query_info)
+@@ -57,562 +57,560 @@ int verbose;
+ static void
+ usage(char *name)
+ {
+-        fprintf(stderr, "Usage: %s [-V] <command> <file>\n"
+-                "-V for verbose output\n"
+-                "Commands are\n"
+-                "  fileaccessinfo:\n"
+-                "      Prints FileAccessInfo for a cifs file.\n"
+-                "  filealigninfo:\n"
+-                "      Prints FileAlignInfo for a cifs file.\n"
+-                "  fileallinfo:\n"
+-                "      Prints FileAllInfo for a cifs file.\n"
+-                "  filebasicinfo:\n"
+-                "      Prints FileBasicInfo for a cifs file.\n"
+-                "  fileeainfo:\n"
+-                "      Prints FileEAInfo for a cifs file.\n"
+-                "  filefsfullsizeinfo:\n"
+-                "      Prints FileFsFullSizeInfo for a cifs share.\n"
+-                "  fileinternalinfo:\n"
+-                "      Prints FileInternalInfo for a cifs file.\n"
+-                "  filemodeinfo:\n"
+-                "      Prints FileModeInfo for a cifs file.\n"
+-                "  filepositioninfo:\n"
+-                "      Prints FilePositionInfo for a cifs file.\n"
+-                "  filestandardinfo:\n"
+-                "      Prints FileStandardInfo for a cifs file.\n"
+-                "  secdesc:\n"
+-                "      Prints the security descriptor for a cifs file.\n"
+-                "  quota:\n"
+-                "      Prints the quota for a cifs file.\n",
+-                name);
+-        exit(1);
++	fprintf(stderr, "Usage: %s [-V] <command> <file>\n"
++		"-V for verbose output\n"
++		"Commands are\n"
++		"  fileaccessinfo:\n"
++		"      Prints FileAccessInfo for a cifs file.\n"
++		"  filealigninfo:\n"
++		"      Prints FileAlignInfo for a cifs file.\n"
++		"  fileallinfo:\n"
++		"      Prints FileAllInfo for a cifs file.\n"
++		"  filebasicinfo:\n"
++		"      Prints FileBasicInfo for a cifs file.\n"
++		"  fileeainfo:\n"
++		"      Prints FileEAInfo for a cifs file.\n"
++		"  filefsfullsizeinfo:\n"
++		"      Prints FileFsFullSizeInfo for a cifs share.\n"
++		"  fileinternalinfo:\n"
++		"      Prints FileInternalInfo for a cifs file.\n"
++		"  filemodeinfo:\n"
++		"      Prints FileModeInfo for a cifs file.\n"
++		"  filepositioninfo:\n"
++		"      Prints FilePositionInfo for a cifs file.\n"
++		"  filestandardinfo:\n"
++		"      Prints FileStandardInfo for a cifs file.\n"
++		"  secdesc:\n"
++		"      Prints the security descriptor for a cifs file.\n"
++		"  quota:\n"
++		"      Prints the quota for a cifs file.\n",
++		name);
++	exit(1);
+ }
+ 
+ static void
+ win_to_timeval(uint64_t smb2_time, struct timeval *tv)
+ {
+-  tv->tv_usec = (smb2_time / 10) % 1000000;
+-  tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
++	tv->tv_usec = (smb2_time / 10) % 1000000;
++	tv->tv_sec  = (smb2_time - 116444736000000000) / 10000000;
+ }
+ 
+ struct bit_string {
+-        unsigned int bit;
+-        char *string;
++	unsigned int bit;
++	char *string;
+ };
+ 
+ struct bit_string directory_access_mask[] = {
+-        { 0x00000001, "LIST_DIRECTORY" },
+-        { 0x00000002, "ADD_FILE" },
+-        { 0x00000004, "ADD_SUBDIRECTORY" },
+-        { 0x00000008, "READ_EA" },
+-        { 0x00000010, "WRITE_EA" },
+-        { 0x00000020, "TRAVERSE" },
+-        { 0x00000040, "DELETE_CHILD" },
+-        { 0x00000080, "READ_ATTRIBUTES" },
+-        { 0x00000100, "WRITE_ATTRIBUTES" },
+-        { 0x00010000, "DELETE" },
+-        { 0x00020000, "READ_CONTROL" },
+-        { 0x00040000, "WRITE_DAC" },
+-        { 0x00080000, "WRITE_OWNER" },
+-        { 0x00100000, "SYNCHRONIZER" },
+-        { 0x01000000, "ACCESS_SYSTEM_SECURITY" },
+-        { 0x02000000, "MAXIMUM_ALLOWED" },
+-        { 0x10000000, "GENERIC_ALL" },
+-        { 0x20000000, "GENERIC_EXECUTE" },
+-        { 0x40000000, "GENERIC_WRITE" },
+-        { 0x80000000, "GENERIC_READ" },
+-        { 0, NULL }
++	{ 0x00000001, "LIST_DIRECTORY" },
++	{ 0x00000002, "ADD_FILE" },
++	{ 0x00000004, "ADD_SUBDIRECTORY" },
++	{ 0x00000008, "READ_EA" },
++	{ 0x00000010, "WRITE_EA" },
++	{ 0x00000020, "TRAVERSE" },
++	{ 0x00000040, "DELETE_CHILD" },
++	{ 0x00000080, "READ_ATTRIBUTES" },
++	{ 0x00000100, "WRITE_ATTRIBUTES" },
++	{ 0x00010000, "DELETE" },
++	{ 0x00020000, "READ_CONTROL" },
++	{ 0x00040000, "WRITE_DAC" },
++	{ 0x00080000, "WRITE_OWNER" },
++	{ 0x00100000, "SYNCHRONIZER" },
++	{ 0x01000000, "ACCESS_SYSTEM_SECURITY" },
++	{ 0x02000000, "MAXIMUM_ALLOWED" },
++	{ 0x10000000, "GENERIC_ALL" },
++	{ 0x20000000, "GENERIC_EXECUTE" },
++	{ 0x40000000, "GENERIC_WRITE" },
++	{ 0x80000000, "GENERIC_READ" },
++	{ 0, NULL }
+ };
+ 
+ struct bit_string file_access_mask[] = {
+-        { 0x00000001, "READ_DATA" },
+-        { 0x00000002, "WRITE_DATA" },
+-        { 0x00000004, "APPEND_DATA" },
+-        { 0x00000008, "READ_EA" },
+-        { 0x00000010, "WRITE_EA" },
+-        { 0x00000020, "EXECUTE" },
+-        { 0x00000040, "DELETE_CHILD" },
+-        { 0x00000080, "READ_ATTRIBUTES" },
+-        { 0x00000100, "WRITE_ATTRIBUTES" },
+-        { 0x00010000, "DELETE" },
+-        { 0x00020000, "READ_CONTROL" },
+-        { 0x00040000, "WRITE_DAC" },
+-        { 0x00080000, "WRITE_OWNER" },
+-        { 0x00100000, "SYNCHRONIZER" },
+-        { 0x01000000, "ACCESS_SYSTEM_SECURITY" },
+-        { 0x02000000, "MAXIMUM_ALLOWED" },
+-        { 0x10000000, "GENERIC_ALL" },
+-        { 0x20000000, "GENERIC_EXECUTE" },
+-        { 0x40000000, "GENERIC_WRITE" },
+-        { 0x80000000, "GENERIC_READ" },
+-        { 0, NULL }
++	{ 0x00000001, "READ_DATA" },
++	{ 0x00000002, "WRITE_DATA" },
++	{ 0x00000004, "APPEND_DATA" },
++	{ 0x00000008, "READ_EA" },
++	{ 0x00000010, "WRITE_EA" },
++	{ 0x00000020, "EXECUTE" },
++	{ 0x00000040, "DELETE_CHILD" },
++	{ 0x00000080, "READ_ATTRIBUTES" },
++	{ 0x00000100, "WRITE_ATTRIBUTES" },
++	{ 0x00010000, "DELETE" },
++	{ 0x00020000, "READ_CONTROL" },
++	{ 0x00040000, "WRITE_DAC" },
++	{ 0x00080000, "WRITE_OWNER" },
++	{ 0x00100000, "SYNCHRONIZER" },
++	{ 0x01000000, "ACCESS_SYSTEM_SECURITY" },
++	{ 0x02000000, "MAXIMUM_ALLOWED" },
++	{ 0x10000000, "GENERIC_ALL" },
++	{ 0x20000000, "GENERIC_EXECUTE" },
++	{ 0x40000000, "GENERIC_WRITE" },
++	{ 0x80000000, "GENERIC_READ" },
++	{ 0, NULL }
+ };
+ 
+ static void
+ print_bits(uint32_t mask, struct bit_string *bs)
+ {
+-        int first = 1;
++	int first = 1;
+ 
+-        if (!verbose) {
+-                return;
+-        }
++	if (!verbose)
++		return;
+ 
+-        while (bs->string) {
+-                if (mask & bs->bit) {
+-                        printf("%s%s", first?"":",", bs->string);
+-                        first = 0;
+-                }
+-                bs++;
+-        }
+-        if (!first) {
+-                printf(" ");
+-        }
++	while (bs->string) {
++		if (mask & bs->bit) {
++			printf("%s%s", first?"":",", bs->string);
++			first = 0;
++		}
++		bs++;
++	}
++	if (!first)
++		printf(" ");
+ }
+ 
+ static void
+ print_fileaccessinfo(uint8_t *sd, int type)
+ {
+-        uint32_t access_flags;
++	uint32_t access_flags;
+ 
+-        memcpy(&access_flags, &sd[0], 4);
+-        access_flags = le32toh(access_flags);
++	memcpy(&access_flags, &sd[0], 4);
++	access_flags = le32toh(access_flags);
+ 
+-        if (type == S_IFDIR) {
+-                printf("Directory access flags 0x%08x: ", access_flags);
+-                print_bits(access_flags, directory_access_mask);
+-        } else {
+-                printf("File/Printer access flags 0x%08x: ", access_flags);
+-                print_bits(access_flags, file_access_mask);
+-        }
+-        printf("\n");
++	if (type == S_IFDIR) {
++		printf("Directory access flags 0x%08x: ", access_flags);
++		print_bits(access_flags, directory_access_mask);
++	} else {
++		printf("File/Printer access flags 0x%08x: ", access_flags);
++		print_bits(access_flags, file_access_mask);
++	}
++	printf("\n");
+ }
+ 
+ static void
+ fileaccessinfo(int f)
+ {
+-        struct smb_query_info *qi;
+-        struct stat st;
++	struct smb_query_info *qi;
++	struct stat st;
+ 
+-        fstat(f, &st);
++	fstat(f, &st);
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 4);
+-        memset(qi, 0, sizeof(qi) + 4);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 8;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 4;
++	qi = malloc(sizeof(struct smb_query_info) + 4);
++	memset(qi, 0, sizeof(qi) + 4);
++	qi->info_type = 0x01;
++	qi->file_info_class = 8;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 4;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_fileaccessinfo((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
+-        free(qi);
++	print_fileaccessinfo((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
++	free(qi);
+ }
+ 
+ static void
+ print_filealigninfo(uint8_t *sd)
+ {
+-        uint32_t mask;
+-
+-        memcpy(&mask, &sd[0], 4);
+-        mask = le32toh(mask);
+-
+-        printf("File alignment: ");
+-        if (mask == 0)
+-                printf("BYTE_ALIGNMENT");
+-        else if (mask == 1)
+-                printf("WORD_ALIGNMENT");
+-        else if (mask == 3)
+-                printf("LONG_ALIGNMENT");
+-        else if (mask == 7)
+-                printf("QUAD_ALIGNMENT");
+-        else if (mask == 15)
+-                printf("OCTA_ALIGNMENT");
+-        else if (mask == 31)
+-                printf("32_bit_ALIGNMENT");
+-        else if (mask == 63)
+-                printf("64_bit_ALIGNMENT");
+-        else if (mask == 127)
+-                printf("128_bit_ALIGNMENT");
+-        else if (mask == 255)
+-                printf("254_bit_ALIGNMENT");
+-        else if (mask == 511)
+-                printf("512_bit_ALIGNMENT");
+-
+-        printf("\n");
++	uint32_t mask;
++
++	memcpy(&mask, &sd[0], 4);
++	mask = le32toh(mask);
++
++	printf("File alignment: ");
++	if (mask == 0)
++		printf("BYTE_ALIGNMENT");
++	else if (mask == 1)
++		printf("WORD_ALIGNMENT");
++	else if (mask == 3)
++		printf("LONG_ALIGNMENT");
++	else if (mask == 7)
++		printf("QUAD_ALIGNMENT");
++	else if (mask == 15)
++		printf("OCTA_ALIGNMENT");
++	else if (mask == 31)
++		printf("32_bit_ALIGNMENT");
++	else if (mask == 63)
++		printf("64_bit_ALIGNMENT");
++	else if (mask == 127)
++		printf("128_bit_ALIGNMENT");
++	else if (mask == 255)
++		printf("254_bit_ALIGNMENT");
++	else if (mask == 511)
++		printf("512_bit_ALIGNMENT");
++
++	printf("\n");
+ }
+ 
+ static void
+ filealigninfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 4);
+-        memset(qi, 0, sizeof(qi) + 4);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 17;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 4;
++	qi = malloc(sizeof(struct smb_query_info) + 4);
++	memset(qi, 0, sizeof(qi) + 4);
++	qi->info_type = 0x01;
++	qi->file_info_class = 17;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 4;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filealigninfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_filealigninfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ struct bit_string file_attributes_mask[] = {
+-        { 0x00000001, "READ_ONLY" },
+-        { 0x00000002, "HIDDEN" },
+-        { 0x00000004, "SYSTEM" },
+-        { 0x00000010, "DIRECTORY" },
+-        { 0x00000020, "ARCHIVE" },
+-        { 0x00000080, "NORMAL" },
+-        { 0x00000100, "TEMPORARY" },
+-        { 0x00000200, "SPARSE_FILE" },
+-        { 0x00000400, "REPARSE_POINT" },
+-        { 0x00000800, "COMPRESSED" },
+-        { 0x00001000, "OFFLINE" },
+-        { 0x00002000, "NOT_CONTENT_INDEXED" },
+-        { 0x00004000, "ENCRYPTED" },
+-        { 0x00008000, "INTEGRITY_STREAM" },
+-        { 0x00020000, "NO_SCRUB_DATA" },
+-        { 0, NULL }
++	{ 0x00000001, "READ_ONLY" },
++	{ 0x00000002, "HIDDEN" },
++	{ 0x00000004, "SYSTEM" },
++	{ 0x00000010, "DIRECTORY" },
++	{ 0x00000020, "ARCHIVE" },
++	{ 0x00000080, "NORMAL" },
++	{ 0x00000100, "TEMPORARY" },
++	{ 0x00000200, "SPARSE_FILE" },
++	{ 0x00000400, "REPARSE_POINT" },
++	{ 0x00000800, "COMPRESSED" },
++	{ 0x00001000, "OFFLINE" },
++	{ 0x00002000, "NOT_CONTENT_INDEXED" },
++	{ 0x00004000, "ENCRYPTED" },
++	{ 0x00008000, "INTEGRITY_STREAM" },
++	{ 0x00020000, "NO_SCRUB_DATA" },
++	{ 0, NULL }
+ };
+ 
+ static void
+ print_filebasicinfo(uint8_t *sd)
+ {
+-        struct timeval tv;
+-        uint64_t u64;
+-        uint32_t u32;
++	struct timeval tv;
++	uint64_t u64;
++	uint32_t u32;
+ 
+-        memcpy(&u64, &sd[0], 8);
+-        win_to_timeval(le64toh(u64), &tv);
+-        printf("Creation Time %s", ctime(&tv.tv_sec));
++	memcpy(&u64, &sd[0], 8);
++	win_to_timeval(le64toh(u64), &tv);
++	printf("Creation Time %s", ctime(&tv.tv_sec));
+ 
+-        memcpy(&u64, &sd[8], 8);
+-        win_to_timeval(le64toh(u64), &tv);
+-        printf("Last Access Time %s", ctime(&tv.tv_sec));
++	memcpy(&u64, &sd[8], 8);
++	win_to_timeval(le64toh(u64), &tv);
++	printf("Last Access Time %s", ctime(&tv.tv_sec));
+ 
+-        memcpy(&u64, &sd[16], 8);
+-        win_to_timeval(le64toh(u64), &tv);
+-        printf("Last Write Time %s", ctime(&tv.tv_sec));
++	memcpy(&u64, &sd[16], 8);
++	win_to_timeval(le64toh(u64), &tv);
++	printf("Last Write Time %s", ctime(&tv.tv_sec));
+ 
+-        memcpy(&u64, &sd[24], 8);
+-        win_to_timeval(le64toh(u64), &tv);
+-        printf("Last Change Time %s", ctime(&tv.tv_sec));
++	memcpy(&u64, &sd[24], 8);
++	win_to_timeval(le64toh(u64), &tv);
++	printf("Last Change Time %s", ctime(&tv.tv_sec));
+ 
+-        memcpy(&u32, &sd[32], 4);
+-        u32 = le32toh(u32);
+-        printf("File Attributes 0x%08x: ", u32);
+-        print_bits(u32, file_attributes_mask);
+-        printf("\n");
++	memcpy(&u32, &sd[32], 4);
++	u32 = le32toh(u32);
++	printf("File Attributes 0x%08x: ", u32);
++	print_bits(u32, file_attributes_mask);
++	printf("\n");
+ }
+ 
+ static void
+ filebasicinfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 40);
+-        memset(qi, 0, sizeof(qi) + 40);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 4;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 40;
++	qi = malloc(sizeof(struct smb_query_info) + 40);
++	memset(qi, 0, sizeof(qi) + 40);
++	qi->info_type = 0x01;
++	qi->file_info_class = 4;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 40;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filebasicinfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_filebasicinfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ static void
+ print_filestandardinfo(uint8_t *sd)
+ {
+-        uint64_t u64;
+-        uint32_t u32;
++	uint64_t u64;
++	uint32_t u32;
+ 
+-        memcpy(&u64, &sd[0], 8);
+-        printf("Allocation Size %" PRIu64 "\n", le64toh(u64));
++	memcpy(&u64, &sd[0], 8);
++	printf("Allocation Size %" PRIu64 "\n", le64toh(u64));
+ 
+-        memcpy(&u64, &sd[8], 8);
+-        printf("End Of File %" PRIu64 "\n", le64toh(u64));
++	memcpy(&u64, &sd[8], 8);
++	printf("End Of File %" PRIu64 "\n", le64toh(u64));
+ 
+-        memcpy(&u32, &sd[16], 4);
+-        printf("Number Of Links %" PRIu32 "\n", le32toh(u32));
++	memcpy(&u32, &sd[16], 4);
++	printf("Number Of Links %" PRIu32 "\n", le32toh(u32));
+ 
+-        printf("Delete Pending %d\n", sd[20]);
+-        printf("Delete Directory %d\n", sd[21]);
++	printf("Delete Pending %d\n", sd[20]);
++	printf("Delete Directory %d\n", sd[21]);
+ }
+ 
+ static void
+ filestandardinfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 24);
+-        memset(qi, 0, sizeof(qi) + 24);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 5;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 24;
++	qi = malloc(sizeof(struct smb_query_info) + 24);
++	memset(qi, 0, sizeof(qi) + 24);
++	qi->info_type = 0x01;
++	qi->file_info_class = 5;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 24;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filestandardinfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_filestandardinfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ static void
+ print_fileinternalinfo(uint8_t *sd)
+ {
+-        uint64_t u64;
++	uint64_t u64;
+ 
+-        memcpy(&u64, &sd[0], 8);
+-        printf("Index Number %" PRIu64 "\n", le64toh(u64));
++	memcpy(&u64, &sd[0], 8);
++	printf("Index Number %" PRIu64 "\n", le64toh(u64));
+ }
+ 
+ static void
+ fileinternalinfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 8);
+-        memset(qi, 0, sizeof(qi) + 8);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 6;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 8;
++	qi = malloc(sizeof(struct smb_query_info) + 8);
++	memset(qi, 0, sizeof(qi) + 8);
++	qi->info_type = 0x01;
++	qi->file_info_class = 6;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 8;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_fileinternalinfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_fileinternalinfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ struct bit_string file_mode_mask[] = {
+-        { 0x00000002, "WRITE_THROUGH" },
+-        { 0x00000004, "SEQUENTIAL_ONLY" },
+-        { 0x00000008, "NO_INTERMEDIATE_BUFFERING" },
+-        { 0x00000010, "SYNCHRONOUS_IO_ALERT" },
+-        { 0x00000020, "SYNCHRONOUS_IO_NONALERT" },
+-        { 0x00001000, "DELETE_ON_CLOSE" },
+-        { 0, NULL }
++	{ 0x00000002, "WRITE_THROUGH" },
++	{ 0x00000004, "SEQUENTIAL_ONLY" },
++	{ 0x00000008, "NO_INTERMEDIATE_BUFFERING" },
++	{ 0x00000010, "SYNCHRONOUS_IO_ALERT" },
++	{ 0x00000020, "SYNCHRONOUS_IO_NONALERT" },
++	{ 0x00001000, "DELETE_ON_CLOSE" },
++	{ 0, NULL }
+ };
+ 
+ static void
+ print_filemodeinfo(uint8_t *sd)
+ {
+-        uint32_t u32;
++	uint32_t u32;
+ 
+-        memcpy(&u32, &sd[32], 4);
+-        u32 = le32toh(u32);
+-        printf("Mode 0x%08x: ", u32);
+-        print_bits(u32, file_mode_mask);
+-        printf("\n");
++	memcpy(&u32, &sd[32], 4);
++	u32 = le32toh(u32);
++	printf("Mode 0x%08x: ", u32);
++	print_bits(u32, file_mode_mask);
++	printf("\n");
+ }
+ 
+ static void
+ filemodeinfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 4);
+-        memset(qi, 0, sizeof(qi) + 4);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 16;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 4;
++	qi = malloc(sizeof(struct smb_query_info) + 4);
++	memset(qi, 0, sizeof(qi) + 4);
++	qi->info_type = 0x01;
++	qi->file_info_class = 16;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 4;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filemodeinfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_filemodeinfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ static void
+ print_filepositioninfo(uint8_t *sd)
+ {
+-        uint64_t u64;
++	uint64_t u64;
+ 
+-        memcpy(&u64, &sd[0], 8);
+-        printf("Current Byte Offset %" PRIu64 "\n", le64toh(u64));
++	memcpy(&u64, &sd[0], 8);
++	printf("Current Byte Offset %" PRIu64 "\n", le64toh(u64));
+ }
+ 
+ static void
+ filepositioninfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 8);
+-        memset(qi, 0, sizeof(qi) + 8);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 14;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 8;
++	qi = malloc(sizeof(struct smb_query_info) + 8);
++	memset(qi, 0, sizeof(qi) + 8);
++	qi->info_type = 0x01;
++	qi->file_info_class = 14;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 8;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filepositioninfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_filepositioninfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ static void
+ print_fileeainfo(uint8_t *sd)
+ {
+-        uint32_t u32;
++	uint32_t u32;
+ 
+-        memcpy(&u32, &sd[0], 4);
+-        printf("Ea Size %" PRIu32 "\n", le32toh(u32));
++	memcpy(&u32, &sd[0], 4);
++	printf("Ea Size %" PRIu32 "\n", le32toh(u32));
+ }
+ 
+ static void
+ fileeainfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 4);
+-        memset(qi, 0, sizeof(qi) + 4);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 7;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 4;
++	qi = malloc(sizeof(struct smb_query_info) + 4);
++	memset(qi, 0, sizeof(qi) + 4);
++	qi->info_type = 0x01;
++	qi->file_info_class = 7;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 4;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_fileeainfo((uint8_t *)(&qi[1]));
+-        free(qi);
++	print_fileeainfo((uint8_t *)(&qi[1]));
++	free(qi);
+ }
+ 
+ static void
+ print_filefullsizeinfo(uint8_t *sd)
+ {
+-        uint32_t u32;
+-        uint64_t u64;
++	uint32_t u32;
++	uint64_t u64;
+ 
+-        memcpy(&u64, &sd[0], 8);
+-        printf("Total Allocation Units: %" PRIu64 "\n", le64toh(u64));
++	memcpy(&u64, &sd[0], 8);
++	printf("Total Allocation Units: %" PRIu64 "\n", le64toh(u64));
+ 
+-        memcpy(&u64, &sd[8], 8);
+-        printf("Caller Available Allocation Units: %" PRIu64 "\n",
++	memcpy(&u64, &sd[8], 8);
++	printf("Caller Available Allocation Units: %" PRIu64 "\n",
+ 	       le64toh(u64));
+ 
+-        memcpy(&u64, &sd[16], 8);
+-        printf("Actual Available Allocation Units: %" PRIu64 "\n",
++	memcpy(&u64, &sd[16], 8);
++	printf("Actual Available Allocation Units: %" PRIu64 "\n",
+ 	       le64toh(u64));
+ 
+-        memcpy(&u32, &sd[24], 4);
+-        printf("Sectors Per Allocation Unit: %" PRIu32 "\n", le32toh(u32));
++	memcpy(&u32, &sd[24], 4);
++	printf("Sectors Per Allocation Unit: %" PRIu32 "\n", le32toh(u32));
+ 
+-        memcpy(&u32, &sd[28], 4);
+-        printf("Bytes Per Sector: %" PRIu32 "\n", le32toh(u32));
++	memcpy(&u32, &sd[28], 4);
++	printf("Bytes Per Sector: %" PRIu32 "\n", le32toh(u32));
+ }
+ 
+ static void
+ filefsfullsizeinfo(int f)
+ {
+-        struct smb_query_info *qi;
++	struct smb_query_info *qi;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 32);
++	qi = malloc(sizeof(struct smb_query_info) + 32);
+ 	memset(qi, 0, sizeof(qi) + 32);
+-        qi->info_type = 0x02;
+-        qi->file_info_class = 7;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = 32;
+-
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	qi->info_type = 0x02;
++	qi->file_info_class = 7;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 32;
++
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filefullsizeinfo((uint8_t *)(&qi[1]));
++	print_filefullsizeinfo((uint8_t *)(&qi[1]));
+ 	free(qi);
+ }
+ 
+ static void
+ fileallinfo(int f)
+ {
+-        struct smb_query_info *qi;
+-        struct stat st;
++	struct smb_query_info *qi;
++	struct stat st;
+ 
+-        fstat(f, &st);
++	fstat(f, &st);
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
+-        memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
+-        qi->info_type = 0x01;
+-        qi->file_info_class = 18;
+-        qi->additional_information = 0;
+-        qi->input_buffer_length = INPUT_BUFFER_LENGTH;
++	qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++	memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
++	qi->info_type = 0x01;
++	qi->file_info_class = 18;
++	qi->additional_information = 0;
++	qi->input_buffer_length = INPUT_BUFFER_LENGTH;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_filebasicinfo((uint8_t *)(&qi[1]));
+-        print_filestandardinfo((uint8_t *)(&qi[1]) + 40);
+-        print_fileinternalinfo((uint8_t *)(&qi[1]) + 64);
+-        print_fileeainfo((uint8_t *)(&qi[1]) + 72);
+-        print_fileaccessinfo((uint8_t *)(&qi[1]) + 76, st.st_mode & S_IFMT);
+-        print_filepositioninfo((uint8_t *)(&qi[1]) + 80);
+-        print_filemodeinfo((uint8_t *)(&qi[1]) + 88);
+-        print_filealigninfo((uint8_t *)(&qi[1]) + 92);
+-        // SMB2 servers like Win16 does not seem to return name info
+-        free(qi);
++	print_filebasicinfo((uint8_t *)(&qi[1]));
++	print_filestandardinfo((uint8_t *)(&qi[1]) + 40);
++	print_fileinternalinfo((uint8_t *)(&qi[1]) + 64);
++	print_fileeainfo((uint8_t *)(&qi[1]) + 72);
++	print_fileaccessinfo((uint8_t *)(&qi[1]) + 76, st.st_mode & S_IFMT);
++	print_filepositioninfo((uint8_t *)(&qi[1]) + 80);
++	print_filemodeinfo((uint8_t *)(&qi[1]) + 88);
++	print_filealigninfo((uint8_t *)(&qi[1]) + 92);
++	// SMB2 servers like Win16 does not seem to return name info
++	free(qi);
+ }
+ 
+ static void
+ print_sid(unsigned char *sd)
+ {
+-        int i;
+-        uint32_t subauth;
+-        uint64_t idauth;
++	int i;
++	uint32_t subauth;
++	uint64_t idauth;
+ 
+-        if (sd[0] != 1) {
+-                fprintf(stderr, "Unknown SID revision\n");
+-                return;
+-        }
++	if (sd[0] != 1) {
++		fprintf(stderr, "Unknown SID revision\n");
++		return;
++	}
+ 
+-        idauth = 0;
+-        for (i = 0; i < 6; i++)
+-                idauth = (idauth << 8) | sd[2 + i];
++	idauth = 0;
++	for (i = 0; i < 6; i++)
++		idauth = (idauth << 8) | sd[2 + i];
+ 
+-        printf("S-1-%" PRIu64, idauth);
+-        for (i = 0; i < sd[1]; i++) {
+-                memcpy(&subauth, &sd[8 + 4 * i], 4);
+-                subauth = le32toh(subauth);
+-                printf("-%u", subauth);
+-        }
++	printf("S-1-%" PRIu64, idauth);
++	for (i = 0; i < sd[1]; i++) {
++		memcpy(&subauth, &sd[8 + 4 * i], 4);
++		subauth = le32toh(subauth);
++		printf("-%u", subauth);
++	}
+ }
+ 
+ static void
+ print_ace_type(uint8_t t)
+ {
+-        switch(t) {
++	switch(t) {
+ 	case 0x00: printf("ALLOWED"); break;
+ 	case 0x01: printf("DENIED"); break;
+ 	case 0x02: printf("AUDIT"); break;
+@@ -639,28 +637,27 @@ print_ace_type(uint8_t t)
+ }
+ 
+ struct bit_string ace_flags_mask[] = {
+-        { 0x80, "FAILED_ACCESS" },
+-        { 0x40, "SUCCESSFUL_ACCESS" },
+-        { 0x10, "INHERITED" },
+-        { 0x08, "INHERIT_ONLY" },
+-        { 0x04, "NO_PROPAGATE_INHERIT" },
+-        { 0x02, "CONTAINER_INHERIT" },
+-        { 0x01, "OBJECT_INHERIT" },
+-        { 0, NULL }
++	{ 0x80, "FAILED_ACCESS" },
++	{ 0x40, "SUCCESSFUL_ACCESS" },
++	{ 0x10, "INHERITED" },
++	{ 0x08, "INHERIT_ONLY" },
++	{ 0x04, "NO_PROPAGATE_INHERIT" },
++	{ 0x02, "CONTAINER_INHERIT" },
++	{ 0x01, "OBJECT_INHERIT" },
++	{ 0, NULL }
+ };
+ 
+ static void
+ print_mask_sid_ace(unsigned char *sd, int type)
+ {
+-        uint32_t u32;
++	uint32_t u32;
+ 
+-        memcpy(&u32, &sd[0], 4);
++	memcpy(&u32, &sd[0], 4);
+ 	printf("Mask:0x%08x ", le32toh(u32));
+-	if (type == S_IFDIR) {
++	if (type == S_IFDIR)
+ 		print_bits(le32toh(u32), directory_access_mask);
+-        } else {
++	else
+ 		print_bits(le32toh(u32), file_access_mask);
+-	}
+ 	printf("SID:");
+ 	print_sid(&sd[4]);
+ 	printf("\n");
+@@ -669,7 +666,7 @@ print_mask_sid_ace(unsigned char *sd, int type)
+ static int
+ print_ace(unsigned char *sd, int type)
+ {
+-        uint16_t size;
++	uint16_t size;
+ 	int i;
+ 
+ 	printf("Type:0x%02x ", sd[0]);
+@@ -701,40 +698,39 @@ print_ace(unsigned char *sd, int type)
+ static void
+ print_acl(unsigned char *sd, int type)
+ {
+-        int i, off;
+-        uint16_t count;
++	int i, off;
++	uint16_t count;
+ 
+-        if ((sd[0] != 2) && (sd[0] != 4)) {
+-                fprintf(stderr, "Unknown ACL revision\n");
+-                return;
+-        }
++	if ((sd[0] != 2) && (sd[0] != 4)) {
++		fprintf(stderr, "Unknown ACL revision\n");
++		return;
++	}
+ 
+-        memcpy(&count, &sd[4], 2);
+-        count = le16toh(count);
+-        off = 8;
+-        for (i = 0; i < count; i++) {
++	memcpy(&count, &sd[4], 2);
++	count = le16toh(count);
++	off = 8;
++	for (i = 0; i < count; i++)
+ 		off += print_ace(&sd[off], type);
+-        }
+ }
+ 
+ struct bit_string control_bits_mask[] = {
+-        { 0x8000, "SR" },
+-        { 0x4000, "RM" },
+-        { 0x2000, "PS" },
+-        { 0x1000, "PD" },
+-        { 0x0800, "SI" },
+-        { 0x0400, "DI" },
+-        { 0x0200, "SC" },
+-        { 0x0100, "DC" },
+-        { 0x0080, "DT" },
+-        { 0x0040, "SS" },
+-        { 0x0020, "SD" },
+-        { 0x0010, "SP" },
+-        { 0x0008, "DD" },
+-        { 0x0004, "DP" },
+-        { 0x0002, "GD" },
+-        { 0x0001, "OD" },
+-        { 0, NULL }
++	{ 0x8000, "SR" },
++	{ 0x4000, "RM" },
++	{ 0x2000, "PS" },
++	{ 0x1000, "PD" },
++	{ 0x0800, "SI" },
++	{ 0x0400, "DI" },
++	{ 0x0200, "SC" },
++	{ 0x0100, "DC" },
++	{ 0x0080, "DT" },
++	{ 0x0040, "SS" },
++	{ 0x0020, "SD" },
++	{ 0x0010, "SP" },
++	{ 0x0008, "DD" },
++	{ 0x0004, "DP" },
++	{ 0x0002, "GD" },
++	{ 0x0001, "OD" },
++	{ 0, NULL }
+ };
+ 
+ static void
+@@ -748,215 +744,210 @@ print_control(uint16_t c)
+ static void
+ print_sd(uint8_t *sd, int type)
+ {
+-        int offset_owner, offset_group, offset_dacl;
++	int offset_owner, offset_group, offset_dacl;
+ 	uint16_t u16;
+ 
+-        printf("Revision:%d\n", sd[0]);
+-        if (sd[0] != 1) {
+-                fprintf(stderr, "Unknown SD revision\n");
+-                exit(1);
+-        }
+-
+-        memcpy(&u16, &sd[2], 2);
+-        print_control(le16toh(u16));
+-
+-        memcpy(&offset_owner, &sd[4], 4);
+-        offset_owner = le32toh(offset_owner);
+-        memcpy(&offset_group, &sd[8], 4);
+-        offset_group = le32toh(offset_group);
+-        memcpy(&offset_dacl, &sd[16], 4);
+-        offset_dacl = le32toh(offset_dacl);
+-
+-        if (offset_owner) {
+-                printf("Owner: ");
+-                print_sid(&sd[offset_owner]);
+-                printf("\n");
+-        }
+-        if (offset_group) {
+-                printf("Group: ");
+-                print_sid(&sd[offset_group]);
+-                printf("\n");
+-        }
+-        if (offset_dacl) {
+-                printf("DACL:\n");
+-                print_acl(&sd[offset_dacl], type);
+-        }
++	printf("Revision:%d\n", sd[0]);
++	if (sd[0] != 1) {
++		fprintf(stderr, "Unknown SD revision\n");
++		exit(1);
++	}
++
++	memcpy(&u16, &sd[2], 2);
++	print_control(le16toh(u16));
++
++	memcpy(&offset_owner, &sd[4], 4);
++	offset_owner = le32toh(offset_owner);
++	memcpy(&offset_group, &sd[8], 4);
++	offset_group = le32toh(offset_group);
++	memcpy(&offset_dacl, &sd[16], 4);
++	offset_dacl = le32toh(offset_dacl);
++
++	if (offset_owner) {
++		printf("Owner: ");
++		print_sid(&sd[offset_owner]);
++		printf("\n");
++	}
++	if (offset_group) {
++		printf("Group: ");
++		print_sid(&sd[offset_group]);
++		printf("\n");
++	}
++	if (offset_dacl) {
++		printf("DACL:\n");
++		print_acl(&sd[offset_dacl], type);
++	}
+ }
+ 
+ static void
+ secdesc(int f)
+ {
+-        struct smb_query_info *qi;
+-        struct stat st;
++	struct smb_query_info *qi;
++	struct stat st;
+ 
+-        fstat(f, &st);
++	fstat(f, &st);
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
+-        memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
+-        qi->info_type = 0x03;
+-        qi->file_info_class = 0;
+-        qi->additional_information = 0x00000007; /* Owner, Group, Dacl */
+-        qi->input_buffer_length = INPUT_BUFFER_LENGTH;
++	qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++	memset(qi, 0, sizeof(qi) + INPUT_BUFFER_LENGTH);
++	qi->info_type = 0x03;
++	qi->file_info_class = 0;
++	qi->additional_information = 0x00000007; /* Owner, Group, Dacl */
++	qi->input_buffer_length = INPUT_BUFFER_LENGTH;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_sd((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
+-        free(qi);
++	print_sd((uint8_t *)(&qi[1]), st.st_mode & S_IFMT);
++	free(qi);
+ }
+ 
+ static void
+ print_quota(unsigned char *sd)
+ {
+-        uint32_t u32, neo;
+-        uint64_t u64;
+-        struct timeval tv;
+-        struct tm;
+-        int i, off = 0;
+-
+- one_more:
+-        memcpy(&u32, &sd[off], 4);
+-        neo = le32toh(u32);
+-
+-        memcpy(&u32, &sd[off + 4], 4);
+-        u32 = le32toh(u32);
+-        printf("SID Length %d\n", u32);
+-
+-        memcpy(&u64, &sd[off + 8], 8);
+-        win_to_timeval(le64toh(u64), &tv);
+-        printf("Change Time %s", ctime(&tv.tv_sec));
+-
+-        memcpy(&u64, &sd[off + 16], 8);
+-        u64 = le32toh(u64);
+-        printf("Quota Used %" PRIu64 "\n", u64);
+-
+-        memcpy(&u64, &sd[off + 24], 8);
+-        u64 = le64toh(u64);
+-        if (u64 == 0xffffffffffffffff) {
+-                printf("Quota Threshold NO THRESHOLD\n");
+-        } else {
+-                printf("Quota Threshold %" PRIu64 "\n", u64);
+-        }
+-
+-        memcpy(&u64, &sd[off + 32], 8);
+-        u64 = le64toh(u64);
+-        if (u64 == 0xffffffffffffffff) {
+-                printf("Quota Limit NO LIMIT\n");
+-        } else {
+-                printf("Quota Limit %" PRIu64 "\n", u64);
+-        }
+-
+-        printf("SID: S-1");
+-        u64 = 0;
+-        for (i = 0; i < 6; i++)
+-                u64 = (u64 << 8) | sd[off + 42 + i];
+-        printf("-%" PRIu64, u64);
+-
+-        for (i = 0; i < sd[off + 41]; i++) {
+-                memcpy(&u32, &sd[off + 48 + 4 * i], 4);
+-                u32 = le32toh(u32);
+-                printf("-%u", u32);
+-        }
+-        printf("\n\n");
+-        off += neo;
+-
+-        if (neo != 0) {
+-                goto one_more;
+-        }
++	uint32_t u32, neo;
++	uint64_t u64;
++	struct timeval tv;
++	struct tm;
++	int i, off = 0;
++
++one_more:
++	memcpy(&u32, &sd[off], 4);
++	neo = le32toh(u32);
++
++	memcpy(&u32, &sd[off + 4], 4);
++	u32 = le32toh(u32);
++	printf("SID Length %d\n", u32);
++
++	memcpy(&u64, &sd[off + 8], 8);
++	win_to_timeval(le64toh(u64), &tv);
++	printf("Change Time %s", ctime(&tv.tv_sec));
++
++	memcpy(&u64, &sd[off + 16], 8);
++	u64 = le32toh(u64);
++	printf("Quota Used %" PRIu64 "\n", u64);
++
++	memcpy(&u64, &sd[off + 24], 8);
++	u64 = le64toh(u64);
++	if (u64 == 0xffffffffffffffff)
++		printf("Quota Threshold NO THRESHOLD\n");
++	else
++		printf("Quota Threshold %" PRIu64 "\n", u64);
++
++	memcpy(&u64, &sd[off + 32], 8);
++	u64 = le64toh(u64);
++	if (u64 == 0xffffffffffffffff)
++		printf("Quota Limit NO LIMIT\n");
++	else
++		printf("Quota Limit %" PRIu64 "\n", u64);
++
++	printf("SID: S-1");
++	u64 = 0;
++	for (i = 0; i < 6; i++)
++		u64 = (u64 << 8) | sd[off + 42 + i];
++	printf("-%" PRIu64, u64);
++
++	for (i = 0; i < sd[off + 41]; i++) {
++		memcpy(&u32, &sd[off + 48 + 4 * i], 4);
++		u32 = le32toh(u32);
++		printf("-%u", u32);
++	}
++	printf("\n\n");
++	off += neo;
++
++	if (neo != 0)
++		goto one_more;
+ }
+ 
+ static void
+ quota(int f)
+ {
+-        struct smb_query_info *qi;
+-        char *buf;
+-        int i;
++	struct smb_query_info *qi;
++	char *buf;
++	int i;
+ 
+-        qi = malloc(sizeof(struct smb_query_info) + 16384);
+-        memset(qi, 0, sizeof(struct smb_query_info) + 16384);
+-        qi->info_type = 0x04;
+-        qi->file_info_class = 0;
+-        qi->additional_information = 0; /* Owner, Group, Dacl */
+-        qi->input_buffer_length = 16384;
++	qi = malloc(sizeof(struct smb_query_info) + 16384);
++	memset(qi, 0, sizeof(struct smb_query_info) + 16384);
++	qi->info_type = 0x04;
++	qi->file_info_class = 0;
++	qi->additional_information = 0; /* Owner, Group, Dacl */
++	qi->input_buffer_length = 16384;
+ 
+-        buf = (char *)&qi[1];
+-               buf[0] = 0; /* return single */
+-        buf[1] = 1; /* restart scan */
++	buf = (char *)&qi[1];
++	buf[0] = 0; /* return single */
++	buf[1] = 1; /* restart scan */
+ 
+-        /* sid list length */
+-        i = 0;
+-        memcpy(&buf[4], &i, 4);
++	/* sid list length */
++	i = 0;
++	memcpy(&buf[4], &i, 4);
+ 
+-        qi->output_buffer_length = 16;
++	qi->output_buffer_length = 16;
+ 
+-        if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
+-                fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
+-                exit(1);
+-        }
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
+ 
+-        print_quota((unsigned char *)(&qi[1]));
+-        free(qi);
++	print_quota((unsigned char *)(&qi[1]));
++	free(qi);
+ }
+ 
+ int main(int argc, char *argv[])
+ {
+-        int c;
+-        int f;
++	int c;
++	int f;
+ 
+-        while ((c = getopt_long(argc, argv, "vV", NULL, NULL)) != -1) {
+-                switch (c) {
+-                case 'v':
+-                        printf("smbinfo version %s\n", VERSION);
+-                        return 0;
+-                case 'V':
++	while ((c = getopt_long(argc, argv, "vV", NULL, NULL)) != -1) {
++		switch (c) {
++		case 'v':
++			printf("smbinfo version %s\n", VERSION);
++			return 0;
++		case 'V':
+ 			verbose = 1;
+ 			break;
+-                default:
+-                        usage(argv[0]);
+-                }
+-        }
+-
+-        if (optind >= argc - 1)
+-                usage(argv[0]);
+-
+-        if ((f = open(argv[optind + 1], O_RDONLY)) < 0) {
+-                fprintf(stderr, "Failed to open %s\n", argv[optind + 1]);
+-                exit(1);
+-        }
+-
+-
+-        if (!strcmp(argv[optind], "fileaccessinfo"))
+-                fileaccessinfo(f);
+-        else if (!strcmp(argv[optind], "filealigninfo"))
+-                filealigninfo(f);
+-        else if (!strcmp(argv[optind], "fileallinfo"))
+-                fileallinfo(f);
+-        else if (!strcmp(argv[optind], "filebasicinfo"))
+-                filebasicinfo(f);
+-        else if (!strcmp(argv[optind], "fileeainfo"))
+-                fileeainfo(f);
+-        else if (!strcmp(argv[optind], "filefsfullsizeinfo"))
+-                filefsfullsizeinfo(f);
+-        else if (!strcmp(argv[optind], "fileinternalinfo"))
+-                fileinternalinfo(f);
+-        else if (!strcmp(argv[optind], "filemodeinfo"))
+-                filemodeinfo(f);
+-        else if (!strcmp(argv[optind], "filepositioninfo"))
+-                filepositioninfo(f);
+-        else if (!strcmp(argv[optind], "filestandardinfo"))
+-                filestandardinfo(f);
+-        else if (!strcmp(argv[optind], "secdesc"))
+-                secdesc(f);
+-        else if (!strcmp(argv[optind], "quota"))
+-                quota(f);
+-        else {
+-                fprintf(stderr, "Unknown command %s\n", argv[optind]);
+-                exit(1);
+-        }
+-
+-
+-        close(f);
+-        return 0;
++		default:
++			usage(argv[0]);
++		}
++	}
++
++	if (optind >= argc - 1)
++		usage(argv[0]);
++
++	if ((f = open(argv[optind + 1], O_RDONLY)) < 0) {
++		fprintf(stderr, "Failed to open %s\n", argv[optind + 1]);
++		exit(1);
++	}
++
++	if (!strcmp(argv[optind], "fileaccessinfo"))
++		fileaccessinfo(f);
++	else if (!strcmp(argv[optind], "filealigninfo"))
++		filealigninfo(f);
++	else if (!strcmp(argv[optind], "fileallinfo"))
++		fileallinfo(f);
++	else if (!strcmp(argv[optind], "filebasicinfo"))
++		filebasicinfo(f);
++	else if (!strcmp(argv[optind], "fileeainfo"))
++		fileeainfo(f);
++	else if (!strcmp(argv[optind], "filefsfullsizeinfo"))
++		filefsfullsizeinfo(f);
++	else if (!strcmp(argv[optind], "fileinternalinfo"))
++		fileinternalinfo(f);
++	else if (!strcmp(argv[optind], "filemodeinfo"))
++		filemodeinfo(f);
++	else if (!strcmp(argv[optind], "filepositioninfo"))
++		filepositioninfo(f);
++	else if (!strcmp(argv[optind], "filestandardinfo"))
++		filestandardinfo(f);
++	else if (!strcmp(argv[optind], "secdesc"))
++		secdesc(f);
++	else if (!strcmp(argv[optind], "quota"))
++		quota(f);
++	else {
++		fprintf(stderr, "Unknown command %s\n", argv[optind]);
++		exit(1);
++	}
++
++	close(f);
++	return 0;
+ }
+-- 
+2.17.1
+
diff --git a/debian/patches/0009-smbinfo-add-fsctl-getobjid-support.patch b/debian/patches/0009-smbinfo-add-fsctl-getobjid-support.patch
new file mode 100644
index 0000000..c015058
--- /dev/null
+++ b/debian/patches/0009-smbinfo-add-fsctl-getobjid-support.patch
@@ -0,0 +1,131 @@
+From fb33ba335325020d4f42985491f2f98eddffc165 Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=fb33ba335325020d4f42985491f2f98eddffc165
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 15 Mar 2019 16:22:15 +1000
+Subject: [PATCH] smbinfo: add fsctl-getobjid support
+
+This will print the ObjectID buffer for the object.
+This is an example on how to fetch FSCTL data for an object using
+the passthrough API.
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++++
+ smbinfo.rst |  2 ++
+ 2 files changed, 75 insertions(+)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index d7e7bf3..268114b 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -39,6 +39,11 @@
+ #include <inttypes.h>
+ 
+ #define CIFS_IOCTL_MAGIC 0xCF
++
++/* query_info flags */
++#define PASSTHRU_QUERY_INFO     0x00000000
++#define PASSTHRU_FSCTL          0x00000001
++
+ struct smb_query_info {
+ 	uint32_t   info_type;
+ 	uint32_t   file_info_class;
+@@ -167,6 +172,72 @@ print_bits(uint32_t mask, struct bit_string *bs)
+ 		printf(" ");
+ }
+ 
++static void
++print_guid(uint8_t *sd)
++{
++	uint32_t u32;
++	uint16_t u16;
++	int i;
++
++	memcpy(&u32, &sd[0], 4);
++	printf("%08x-", le32toh(u32));
++
++	memcpy(&u16, &sd[4], 2);
++	printf("%04x-", le16toh(u16));
++
++	memcpy(&u16, &sd[6], 2);
++	printf("%04x-", le16toh(u16));
++
++	printf("%02x%02x-", sd[8], sd[9]);
++	for (i = 0; i < 6; i++)
++		printf("%02x", sd[10 + i]);
++}
++
++static void
++print_objidbuf(uint8_t *sd)
++{
++	printf("Object-ID: ");
++	print_guid(&sd[0]);
++	printf("\n");
++
++	printf("Birth-Volume-ID: ");
++	print_guid(&sd[16]);
++	printf("\n");
++
++	printf("Birth-Object-ID: ");
++	print_guid(&sd[32]);
++	printf("\n");
++
++	printf("Domain-ID: ");
++	print_guid(&sd[48]);
++	printf("\n");
++}
++
++static void
++fsctlgetobjid(int f)
++{
++	struct smb_query_info *qi;
++	struct stat st;
++
++	fstat(f, &st);
++
++	qi = malloc(sizeof(struct smb_query_info) + 64);
++	memset(qi, 0, sizeof(qi) + 64);
++	qi->info_type = 0x9009c;
++	qi->file_info_class = 0;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 64;
++	qi->flags = PASSTHRU_FSCTL;
++
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
++	print_objidbuf((uint8_t *)(&qi[1]));
++
++	free(qi);
++}
++
+ static void
+ print_fileaccessinfo(uint8_t *sd, int type)
+ {
+@@ -943,6 +1014,8 @@ int main(int argc, char *argv[])
+ 		secdesc(f);
+ 	else if (!strcmp(argv[optind], "quota"))
+ 		quota(f);
++	else if (!strcmp(argv[1], "fsctl-getobjid"))
++		fsctlgetobjid(f);
+ 	else {
+ 		fprintf(stderr, "Unknown command %s\n", argv[optind]);
+ 		exit(1);
+diff --git a/smbinfo.rst b/smbinfo.rst
+index 9bfd313..fd7f0ff 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -62,6 +62,8 @@ COMMAND
+ 
+ `filestandardinfo`: Prints the FileStandardInformation class
+ 
++`fsctl-getobjid`: Prints the ObjectID
++
+ `quota`: Print the quota for the volume in the form
+ - SID Length
+ - Change Time
+-- 
+2.17.1
+
diff --git a/debian/patches/0010-smbinfo-missing-help-for-fsctl-getobjid.patch b/debian/patches/0010-smbinfo-missing-help-for-fsctl-getobjid.patch
new file mode 100644
index 0000000..3d09e4c
--- /dev/null
+++ b/debian/patches/0010-smbinfo-missing-help-for-fsctl-getobjid.patch
@@ -0,0 +1,34 @@
+From 49eb190518c5000d48c929b21304edd2e8522ea6 Mon Sep 17 00:00:00 2001
+From: Steve French <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=49eb190518c5000d48c929b21304edd2e8522ea6
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Sat, 16 Mar 2019 15:42:40 -0500
+Subject: [PATCH] smbinfo: missing help for fsctl-getobjid
+
+Add usage description for new option fsctl-getobjid
+
+See section 2.1.3.1 of MS-FSCC
+
+Signed-off-by: Steve French <[e-mail]>
+---
+ smbinfo.c | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 268114b..33fca95 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -88,7 +88,9 @@ usage(char *name)
+ 		"  secdesc:\n"
+ 		"      Prints the security descriptor for a cifs file.\n"
+ 		"  quota:\n"
+-		"      Prints the quota for a cifs file.\n",
++		"      Prints the quota for a cifs file.\n"
++		"  fsctl-getobjid:\n"
++		"      Prints the objectid of the file and GUID of the underlying volume.\n",
+ 		name);
+ 	exit(1);
+ }
+-- 
+2.17.1
+
diff --git a/debian/patches/0011-smbinfo-Add-ability-to-query-snapshots-previous-vers.patch b/debian/patches/0011-smbinfo-Add-ability-to-query-snapshots-previous-vers.patch
new file mode 100644
index 0000000..81be456
--- /dev/null
+++ b/debian/patches/0011-smbinfo-Add-ability-to-query-snapshots-previous-vers.patch
@@ -0,0 +1,173 @@
+From 74ae05342aeb0abe94f1ab9adfdecbbb6ce16dcb Mon Sep 17 00:00:00 2001
+From: Steve French <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=74ae05342aeb0abe94f1ab9adfdecbbb6ce16dcb
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 29 Mar 2019 03:05:55 -0500
+Subject: [PATCH] smbinfo: Add ability to query snapshots (previous versions)
+
+ "smbinfo list-snapshots"
+
+Signed-off-by: Steve French <[e-mail]>
+Signed-off-by: Pavel Shilovsky <[e-mail]>
+Reviewed-by: Paulo Alcantara <[e-mail]>
+---
+ smbinfo.c   | 108 +++++++++++++++++++++++++++++++++++++++++++++++++++-
+ smbinfo.rst |   2 +
+ 2 files changed, 109 insertions(+), 1 deletion(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 33fca95..adfd85e 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -89,6 +89,8 @@ usage(char *name)
+ 		"      Prints the security descriptor for a cifs file.\n"
+ 		"  quota:\n"
+ 		"      Prints the quota for a cifs file.\n"
++		"  list-snapshots:\n"
++		"      List the previous versions of the volume that backs this file.\n"
+ 		"  fsctl-getobjid:\n"
+ 		"      Prints the objectid of the file and GUID of the underlying volume.\n",
+ 		name);
+@@ -882,7 +884,6 @@ print_quota(unsigned char *sd)
+ 	uint32_t u32, neo;
+ 	uint64_t u64;
+ 	struct timeval tv;
+-	struct tm;
+ 	int i, off = 0;
+ 
+ one_more:
+@@ -966,6 +967,109 @@ quota(int f)
+ 	free(qi);
+ }
+ 
++
++struct smb_snapshot_array {
++	int32_t	number_of_snapshots;
++	int32_t	number_of_snapshots_returned;
++	int32_t	snapshot_array_size;
++	char snapshot_data[0];
++};
++
++
++#define GMT_NAME_LEN 24 /* length of a @GMT- name */
++#define GMT_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
++
++#define NTFS_TIME_OFFSET ((unsigned long long)(369*365 + 89) * 24 * 3600 * 10000000)
++
++static void print_snapshots(struct smb_snapshot_array *psnap)
++{
++	int current_snapshot_entry = 0;
++	char gmt_token[GMT_NAME_LEN + 1] = {0};
++	int i;
++	int j = 0;
++	struct tm tm;
++	unsigned long long dce_time;
++
++	printf("Number of snapshots: %d Number of snapshots returned: %d\n",
++		psnap->number_of_snapshots,
++		psnap->number_of_snapshots_returned);
++	printf("Snapshot list in GMT (Coordinated UTC Time) and SMB format (100 nanosecond units needed for snapshot mounts):");
++	for (i = 0; i < psnap->snapshot_array_size; i++) {
++		if (psnap->snapshot_data[i] == '@') {
++			j = 0;
++			current_snapshot_entry++;
++			printf("\n%d) GMT:", current_snapshot_entry);
++		}
++		if (psnap->snapshot_data[i] != 0) {
++			gmt_token[j] = psnap->snapshot_data[i];
++			j++;
++		}
++		if (j == GMT_NAME_LEN) {
++			printf("%s", gmt_token);
++			j = 0;
++			strptime(gmt_token, GMT_FORMAT, &tm);
++			dce_time = timegm(&tm) * 10000000 + NTFS_TIME_OFFSET;
++			printf("\n   SMB3:%llu", dce_time);
++		}
++	}
++	printf("\n");
++}
++
++#define CIFS_ENUMERATE_SNAPSHOTS _IOR(CIFS_IOCTL_MAGIC, 6, struct smb_snapshot_array)
++
++#define MIN_SNAPSHOT_ARRAY_SIZE 16 /* See MS-SMB2 section 3.3.5.15.1 */
++
++static void
++list_snapshots(int f)
++{
++
++	struct smb_snapshot_array snap_inf;
++	struct smb_snapshot_array *buf;
++
++	/*
++	 * When first field in structure we pass in here is zero, cifs.ko can
++	 * recognize that this is the first query and that it must set the SMB3
++	 * FSCTL response buffer size (in the request) to exactly 16 bytes
++	 * (which is required by some servers to process the initial query)
++	 */
++	snap_inf.number_of_snapshots = 0;
++	snap_inf.number_of_snapshots_returned = 0;
++	snap_inf.snapshot_array_size = sizeof(struct smb_snapshot_array);
++
++	/* Query the number of snapshots so we know how much to allocate */
++	if (ioctl(f, CIFS_ENUMERATE_SNAPSHOTS, &snap_inf) < 0) {
++		fprintf(stderr, "Querying snapshots failed with %s\n", strerror(errno));
++		exit(1);
++	}
++
++	if (snap_inf.number_of_snapshots == 0)
++		return;
++
++	/* Now that we know the size, query the list from the server */
++
++	buf = malloc(snap_inf.snapshot_array_size + MIN_SNAPSHOT_ARRAY_SIZE);
++
++	if (buf == NULL) {
++		printf("Failed, out of memory.\n");
++		exit(1);
++	}
++	/*
++	 * first parm is non-zero which allows cifs.ko to recognize that this is
++	 * the second query (it has to set response buf size larger)
++	 */
++	buf->number_of_snapshots = snap_inf.number_of_snapshots;
++
++	buf->snapshot_array_size = snap_inf.snapshot_array_size;
++
++	if (ioctl(f, CIFS_ENUMERATE_SNAPSHOTS, buf) < 0) {
++		fprintf(stderr, "Querying snapshots failed with %s\n", strerror(errno));
++		exit(1);
++	}
++
++	print_snapshots(buf);
++	free(buf);
++}
++
+ int main(int argc, char *argv[])
+ {
+ 	int c;
+@@ -1016,6 +1120,8 @@ int main(int argc, char *argv[])
+ 		secdesc(f);
+ 	else if (!strcmp(argv[optind], "quota"))
+ 		quota(f);
++	else if (!strcmp(argv[optind], "list-snapshots"))
++		list_snapshots(f);
+ 	else if (!strcmp(argv[1], "fsctl-getobjid"))
+ 		fsctlgetobjid(f);
+ 	else {
+diff --git a/smbinfo.rst b/smbinfo.rst
+index fd7f0ff..0c96050 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -64,6 +64,8 @@ COMMAND
+ 
+ `fsctl-getobjid`: Prints the ObjectID
+ 
++`list-snapshots`: Lists the previous versions of the volume that backs this file
++
+ `quota`: Print the quota for the volume in the form
+ - SID Length
+ - Change Time
+-- 
+2.17.1
+
diff --git a/debian/patches/0012-smbinfo-make-argument-order-consistent.patch b/debian/patches/0012-smbinfo-make-argument-order-consistent.patch
new file mode 100644
index 0000000..9b0b841
--- /dev/null
+++ b/debian/patches/0012-smbinfo-make-argument-order-consistent.patch
@@ -0,0 +1,62 @@
+From 98907475550ecd459cb6eae9787c53b7e032448d Mon Sep 17 00:00:00 2001
+From: Pavel Shilovsky <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=98907475550ecd459cb6eae9787c53b7e032448d
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Tue, 2 Apr 2019 11:40:40 -0700
+Subject: [PATCH] smbinfo: make argument order consistent
+
+Signed-off-by: Pavel Shilovsky <[e-mail]>
+Reviewed-by: Paulo Alcantara <[e-mail]>
+---
+ smbinfo.c | 24 ++++++++++++------------
+ 1 file changed, 12 insertions(+), 12 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index adfd85e..f9de7fd 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -85,14 +85,14 @@ usage(char *name)
+ 		"      Prints FilePositionInfo for a cifs file.\n"
+ 		"  filestandardinfo:\n"
+ 		"      Prints FileStandardInfo for a cifs file.\n"
+-		"  secdesc:\n"
+-		"      Prints the security descriptor for a cifs file.\n"
+-		"  quota:\n"
+-		"      Prints the quota for a cifs file.\n"
++		"  fsctl-getobjid:\n"
++		"      Prints the objectid of the file and GUID of the underlying volume.\n"
+ 		"  list-snapshots:\n"
+ 		"      List the previous versions of the volume that backs this file.\n"
+-		"  fsctl-getobjid:\n"
+-		"      Prints the objectid of the file and GUID of the underlying volume.\n",
++		"  quota:\n"
++		"      Prints the quota for a cifs file.\n"
++		"  secdesc:\n"
++		"      Prints the security descriptor for a cifs file.\n",
+ 		name);
+ 	exit(1);
+ }
+@@ -1116,14 +1116,14 @@ int main(int argc, char *argv[])
+ 		filepositioninfo(f);
+ 	else if (!strcmp(argv[optind], "filestandardinfo"))
+ 		filestandardinfo(f);
+-	else if (!strcmp(argv[optind], "secdesc"))
+-		secdesc(f);
+-	else if (!strcmp(argv[optind], "quota"))
+-		quota(f);
++	else if (!strcmp(argv[optind], "fsctl-getobjid"))
++		fsctlgetobjid(f);
+ 	else if (!strcmp(argv[optind], "list-snapshots"))
+ 		list_snapshots(f);
+-	else if (!strcmp(argv[1], "fsctl-getobjid"))
+-		fsctlgetobjid(f);
++	else if (!strcmp(argv[optind], "quota"))
++		quota(f);
++	else if (!strcmp(argv[optind], "secdesc"))
++		secdesc(f);
+ 	else {
+ 		fprintf(stderr, "Unknown command %s\n", argv[optind]);
+ 		exit(1);
+-- 
+2.17.1
+
diff --git a/debian/patches/0013-smbinfo-use-constant-for-input-buffer-length.patch b/debian/patches/0013-smbinfo-use-constant-for-input-buffer-length.patch
new file mode 100644
index 0000000..f42901d
--- /dev/null
+++ b/debian/patches/0013-smbinfo-use-constant-for-input-buffer-length.patch
@@ -0,0 +1,35 @@
+From aee01e0e61837fc8eb273039c5d1e11634b2e56a Mon Sep 17 00:00:00 2001
+From: Pavel Shilovsky <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=aee01e0e61837fc8eb273039c5d1e11634b2e56a
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 5 Apr 2019 10:01:48 -0700
+Subject: [PATCH] smbinfo: use constant for input buffer length
+
+Signed-off-by: Pavel Shilovsky <[e-mail]>
+---
+ smbinfo.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index f9de7fd..4bc503a 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -941,12 +941,12 @@ quota(int f)
+ 	char *buf;
+ 	int i;
+ 
+-	qi = malloc(sizeof(struct smb_query_info) + 16384);
+-	memset(qi, 0, sizeof(struct smb_query_info) + 16384);
++	qi = malloc(sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
++	memset(qi, 0, sizeof(struct smb_query_info) + INPUT_BUFFER_LENGTH);
+ 	qi->info_type = 0x04;
+ 	qi->file_info_class = 0;
+ 	qi->additional_information = 0; /* Owner, Group, Dacl */
+-	qi->input_buffer_length = 16384;
++	qi->input_buffer_length = INPUT_BUFFER_LENGTH;
+ 
+ 	buf = (char *)&qi[1];
+ 	buf[0] = 0; /* return single */
+-- 
+2.17.1
+
diff --git a/debian/patches/0014-smbinfo-Improve-help-usage-and-add-h-option.patch b/debian/patches/0014-smbinfo-Improve-help-usage-and-add-h-option.patch
new file mode 100644
index 0000000..0d5231c
--- /dev/null
+++ b/debian/patches/0014-smbinfo-Improve-help-usage-and-add-h-option.patch
@@ -0,0 +1,108 @@
+From 12c2f088fa3d666fc5aa48a700e740523d8d2023 Mon Sep 17 00:00:00 2001
+From: Kenneth D'souza <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=12c2f088fa3d666fc5aa48a700e740523d8d2023
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Wed, 17 Apr 2019 15:36:46 +0530
+Subject: [PATCH] smbinfo: Improve help usage and add -h option.
+
+Call usage only for -h case. This avoids cluttering the screen with long
+help output.
+As we are adding more options to the utility, the end error is just hidden.
+Call short_usage wherever necessary.
+
+Signed-off-by: Kenneth D'souza <[e-mail]>
+---
+ smbinfo.c   | 27 ++++++++++++++++++++++-----
+ smbinfo.rst |  5 ++++-
+ 2 files changed, 26 insertions(+), 6 deletions(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 4bc503a..6e258c2 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -64,6 +64,8 @@ usage(char *name)
+ {
+ 	fprintf(stderr, "Usage: %s [-V] <command> <file>\n"
+ 		"-V for verbose output\n"
++		"-h display this help text\n"
++		"-v print smbinfo version\n"
+ 		"Commands are\n"
+ 		"  fileaccessinfo:\n"
+ 		"      Prints FileAccessInfo for a cifs file.\n"
+@@ -97,6 +99,14 @@ usage(char *name)
+ 	exit(1);
+ }
+ 
++static void
++short_usage(char *name)
++{
++	fprintf(stderr, "Usage: %s [-v] [-V] <command> <file>\n"
++		"Try 'smbinfo -h' for more information.\n", name);
++	exit(1);
++}
++
+ static void
+ win_to_timeval(uint64_t smb2_time, struct timeval *tv)
+ {
+@@ -1075,7 +1085,11 @@ int main(int argc, char *argv[])
+ 	int c;
+ 	int f;
+ 
+-	while ((c = getopt_long(argc, argv, "vV", NULL, NULL)) != -1) {
++	if (argc < 2) {
++		short_usage(argv[0]);
++	}
++
++	while ((c = getopt_long(argc, argv, "vVh", NULL, NULL)) != -1) {
+ 		switch (c) {
+ 		case 'v':
+ 			printf("smbinfo version %s\n", VERSION);
+@@ -1083,15 +1097,18 @@ int main(int argc, char *argv[])
+ 		case 'V':
+ 			verbose = 1;
+ 			break;
+-		default:
++		case 'h':
+ 			usage(argv[0]);
++			break;
++		default:
++			short_usage(argv[0]);
+ 		}
+ 	}
+ 
+-	if (optind >= argc - 1)
+-		usage(argv[0]);
++	if (optind >= argc -1)
++		short_usage(argv[0]);
+ 
+-	if ((f = open(argv[optind + 1], O_RDONLY)) < 0) {
++	if ((f = open(argv[optind + 1 ], O_RDONLY)) < 0) {
+ 		fprintf(stderr, "Failed to open %s\n", argv[optind + 1]);
+ 		exit(1);
+ 	}
+diff --git a/smbinfo.rst b/smbinfo.rst
+index 0c96050..be4c829 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -11,7 +11,7 @@ Userspace helper to display SMB-specific file information for the Linux SMB clie
+ SYNOPSIS
+ ********
+ 
+-  smbinfo [-v] [-V] {command} {file system object}
++  smbinfo [-v] [-h] [-V] {command} {file system object}
+ 
+ ***********
+ DESCRIPTION
+@@ -38,6 +38,9 @@ OPTIONS
+ -V
+   Verbose output.
+ 
++-h
++  Print help explaining the command line options.
++
+ *******
+ COMMAND
+ *******
+-- 
+2.17.1
+
diff --git a/debian/patches/0015-smbinfo-add-GETCOMPRESSION-support.patch b/debian/patches/0015-smbinfo-add-GETCOMPRESSION-support.patch
new file mode 100644
index 0000000..e16aba5
--- /dev/null
+++ b/debian/patches/0015-smbinfo-add-GETCOMPRESSION-support.patch
@@ -0,0 +1,102 @@
+From 1e4fca25948d52fc29410963663f3af72275bcb6 Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=1e4fca25948d52fc29410963663f3af72275bcb6
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Thu, 11 Apr 2019 12:23:06 +1000
+Subject: [PATCH] smbinfo: add GETCOMPRESSION support
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
+ smbinfo.rst |  2 ++
+ 2 files changed, 50 insertions(+)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 6e258c2..b4d497b 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -89,6 +89,8 @@ usage(char *name)
+ 		"      Prints FileStandardInfo for a cifs file.\n"
+ 		"  fsctl-getobjid:\n"
+ 		"      Prints the objectid of the file and GUID of the underlying volume.\n"
++		"  getcompression:\n"
++		"      Prints the compression setting for the file.\n"
+ 		"  list-snapshots:\n"
+ 		"      List the previous versions of the volume that backs this file.\n"
+ 		"  quota:\n"
+@@ -252,6 +254,50 @@ fsctlgetobjid(int f)
+ 	free(qi);
+ }
+ 
++static void
++print_getcompression(uint8_t *sd)
++{
++	uint16_t u16;
++
++	memcpy(&u16, &sd[0], 2);
++	u16 = le16toh(u16);
++
++	printf("Compression: ");
++	switch (u16) {
++	case 0:
++		printf("(0) NONE\n");
++		break;
++	case 2:
++		printf("(2) LZNT1\n");
++		break;
++	default:
++		printf("(%d) UNKNOWN\n", u16);
++		break;
++	}
++}
++
++static void
++getcompression(int f)
++{
++	struct smb_query_info *qi;
++
++	qi = malloc(sizeof(struct smb_query_info) + 2);
++	memset(qi, 0, sizeof(qi) + 2);
++	qi->info_type = 0x9003c;
++	qi->file_info_class = 0;
++	qi->additional_information = 0;
++	qi->input_buffer_length = 2;
++	qi->flags = PASSTHRU_FSCTL;
++
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
++	print_getcompression((uint8_t *)(&qi[1]));
++
++	free(qi);
++}
++
+ static void
+ print_fileaccessinfo(uint8_t *sd, int type)
+ {
+@@ -1135,6 +1181,8 @@ int main(int argc, char *argv[])
+ 		filestandardinfo(f);
+ 	else if (!strcmp(argv[optind], "fsctl-getobjid"))
+ 		fsctlgetobjid(f);
++	else if (!strcmp(argv[optind], "getcompression"))
++		getcompression(f);
+ 	else if (!strcmp(argv[optind], "list-snapshots"))
+ 		list_snapshots(f);
+ 	else if (!strcmp(argv[optind], "quota"))
+diff --git a/smbinfo.rst b/smbinfo.rst
+index be4c829..500ce0e 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -67,6 +67,8 @@ COMMAND
+ 
+ `fsctl-getobjid`: Prints the ObjectID
+ 
++`getcompression`: Prints the compression setting for the file.
++
+ `list-snapshots`: Lists the previous versions of the volume that backs this file
+ 
+ `quota`: Print the quota for the volume in the form
+-- 
+2.17.1
+
diff --git a/debian/patches/0016-smbinfo-print-the-security-information-needed-to-dec.patch b/debian/patches/0016-smbinfo-print-the-security-information-needed-to-dec.patch
new file mode 100644
index 0000000..909cf22
--- /dev/null
+++ b/debian/patches/0016-smbinfo-print-the-security-information-needed-to-dec.patch
@@ -0,0 +1,108 @@
+From 6df98da5cd3fbb33f6f535c6784f037bbadadb84 Mon Sep 17 00:00:00 2001
+From: Steve French <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=6df98da5cd3fbb33f6f535c6784f037bbadadb84
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Thu, 19 Sep 2019 04:21:16 -0500
+Subject: [PATCH] smbinfo: print the security information needed to decrypt
+ wireshark trace
+
+CCM encryption
+Session Id:   e2 3e ea ae 00 00 00 00
+Session Key:  65 7e 0e d5 3c 06 5a 06 50 a3 ef 96 c1 64 3d 1f
+Server Encryption Key:  5e 42 a7 b5 57 75 d6 56 4a 5d 33 97 e6 45 07 76
+Server Decryption Key:  1f 64 db a3 0f 24 e3 4d b6 31 00 ab 9a af 22 47
+
+Signed-off-by: Steve French <[e-mail]>
+---
+ smbinfo.c | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 52 insertions(+), 1 deletion(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index b4d497b..2aa5eee 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -54,7 +54,17 @@ struct smb_query_info {
+ 	/* char buffer[]; */
+ } __packed;
+ 
++#define SMB3_SIGN_KEY_SIZE 16
++struct smb3_key_debug_info {
++	uint64_t Suid;
++	uint16_t cipher_type;
++	uint8_t auth_key[16]; /* SMB2_NTLMV2_SESSKEY_SIZE */
++	uint8_t	smb3encryptionkey[SMB3_SIGN_KEY_SIZE];
++	uint8_t	smb3decryptionkey[SMB3_SIGN_KEY_SIZE];
++} __attribute__((packed));
++
+ #define CIFS_QUERY_INFO _IOWR(CIFS_IOCTL_MAGIC, 7, struct smb_query_info)
++#define CIFS_DUMP_KEY _IOWR(CIFS_IOCTL_MAGIC, 8, struct smb3_key_debug_info)
+ #define INPUT_BUFFER_LENGTH 16384
+ 
+ int verbose;
+@@ -96,7 +106,9 @@ usage(char *name)
+ 		"  quota:\n"
+ 		"      Prints the quota for a cifs file.\n"
+ 		"  secdesc:\n"
+-		"      Prints the security descriptor for a cifs file.\n",
++		"      Prints the security descriptor for a cifs file.\n"
++		"  keys:\n"
++		"      Prints the decryption information needed to view encrypted network traces.\n",
+ 		name);
+ 	exit(1);
+ }
+@@ -1071,6 +1083,43 @@ static void print_snapshots(struct smb_snapshot_array *psnap)
+ 	printf("\n");
+ }
+ 
++static void
++dump_keys(int f)
++{
++	struct smb3_key_debug_info keys_info;
++	uint8_t *psess_id;
++
++	if (ioctl(f, CIFS_DUMP_KEY, &keys_info) < 0) {
++		fprintf(stderr, "Querying keys information failed with %s\n", strerror(errno));
++		exit(1);
++	}
++
++	if (keys_info.cipher_type == 1)
++		printf("CCM encryption");
++	else if (keys_info.cipher_type == 2)
++		printf("GCM encryption");
++	else if (keys_info.cipher_type == 0)
++		printf("SMB3.0 CCM encryption");
++	else
++		printf("unknown encryption type");
++
++	printf("\nSession Id:  ");
++	psess_id = (uint8_t *)&keys_info.Suid;
++	for (int i = 0; i < 8; i++)
++		printf(" %02x", psess_id[i]);
++
++	printf("\nSession Key: ");
++	for (int i = 0; i < 16; i++)
++		printf(" %02x", keys_info.auth_key[i]);
++	printf("\nServer Encryption Key: ");
++	for (int i = 0; i < SMB3_SIGN_KEY_SIZE; i++)
++		printf(" %02x", keys_info.smb3encryptionkey[i]);
++	printf("\nServer Decryption Key: ");
++	for (int i = 0; i < SMB3_SIGN_KEY_SIZE; i++)
++		printf(" %02x", keys_info.smb3decryptionkey[i]);
++	printf("\n");
++}
++
+ #define CIFS_ENUMERATE_SNAPSHOTS _IOR(CIFS_IOCTL_MAGIC, 6, struct smb_snapshot_array)
+ 
+ #define MIN_SNAPSHOT_ARRAY_SIZE 16 /* See MS-SMB2 section 3.3.5.15.1 */
+@@ -1189,6 +1238,8 @@ int main(int argc, char *argv[])
+ 		quota(f);
+ 	else if (!strcmp(argv[optind], "secdesc"))
+ 		secdesc(f);
++	else if (!strcmp(argv[optind], "keys"))
++		dump_keys(f);
+ 	else {
+ 		fprintf(stderr, "Unknown command %s\n", argv[optind]);
+ 		exit(1);
+-- 
+2.17.1
+
diff --git a/debian/patches/0017-smbinfo-Add-SETCOMPRESSION-support.patch b/debian/patches/0017-smbinfo-Add-SETCOMPRESSION-support.patch
new file mode 100644
index 0000000..7068b53
--- /dev/null
+++ b/debian/patches/0017-smbinfo-Add-SETCOMPRESSION-support.patch
@@ -0,0 +1,119 @@
+From 07c5812c062ac584511f244f91fcdfd5d08c8b68 Mon Sep 17 00:00:00 2001
+From: Ronnie Sahlberg <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=07c5812c062ac584511f244f91fcdfd5d08c8b68
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Fri, 4 Oct 2019 09:29:02 +1000
+Subject: [PATCH] smbinfo: Add SETCOMPRESSION support
+
+Signed-off-by: Ronnie Sahlberg <[e-mail]>
+---
+ smbinfo.c   | 48 +++++++++++++++++++++++++++++++++++++++++++++++-
+ smbinfo.rst |  2 ++
+ 2 files changed, 49 insertions(+), 1 deletion(-)
+
+diff --git a/smbinfo.c b/smbinfo.c
+index 2aa5eee..636f1bd 100644
+--- a/smbinfo.c
++++ b/smbinfo.c
+@@ -101,6 +101,8 @@ usage(char *name)
+ 		"      Prints the objectid of the file and GUID of the underlying volume.\n"
+ 		"  getcompression:\n"
+ 		"      Prints the compression setting for the file.\n"
++		"  setcompression <no|default|lznt1>:\n"
++		"      Sets the compression level for the file.\n"
+ 		"  list-snapshots:\n"
+ 		"      List the previous versions of the volume that backs this file.\n"
+ 		"  quota:\n"
+@@ -310,6 +312,30 @@ getcompression(int f)
+ 	free(qi);
+ }
+ 
++static void
++setcompression(int f, uint16_t level)
++{
++	struct smb_query_info *qi;
++
++	qi = malloc(sizeof(struct smb_query_info) + 2);
++	memset(qi, 0, sizeof(qi) + 2);
++	qi->info_type = 0x9c040;
++	qi->file_info_class = 0;
++	qi->additional_information = 0;
++	qi->output_buffer_length = 2;
++	qi->flags = PASSTHRU_FSCTL;
++
++	level = htole16(level);
++	memcpy(&qi[1], &level, 2);
++
++	if (ioctl(f, CIFS_QUERY_INFO, qi) < 0) {
++		fprintf(stderr, "ioctl failed with %s\n", strerror(errno));
++		exit(1);
++	}
++
++	free(qi);
++}
++
+ static void
+ print_fileaccessinfo(uint8_t *sd, int type)
+ {
+@@ -1175,17 +1201,35 @@ list_snapshots(int f)
+ 	free(buf);
+ }
+ 
++static int
++parse_compression(const char *arg)
++{
++	if (!strcmp(arg, "no"))
++		return 0;
++	else if (!strcmp(arg, "default"))
++		return 1;
++	else if (!strcmp(arg, "lznt1"))
++		return 2;
++
++	fprintf(stderr, "compression must be no|default|lznt1\n");
++	exit(10);
++}
++
+ int main(int argc, char *argv[])
+ {
+ 	int c;
+ 	int f;
++	int compression = 1;
+ 
+ 	if (argc < 2) {
+ 		short_usage(argv[0]);
+ 	}
+ 
+-	while ((c = getopt_long(argc, argv, "vVh", NULL, NULL)) != -1) {
++	while ((c = getopt_long(argc, argv, "c:vVh", NULL, NULL)) != -1) {
+ 		switch (c) {
++		case 'c':
++			compression = parse_compression(optarg);
++			break;
+ 		case 'v':
+ 			printf("smbinfo version %s\n", VERSION);
+ 			return 0;
+@@ -1232,6 +1276,8 @@ int main(int argc, char *argv[])
+ 		fsctlgetobjid(f);
+ 	else if (!strcmp(argv[optind], "getcompression"))
+ 		getcompression(f);
++	else if (!strcmp(argv[optind], "setcompression"))
++		setcompression(f, compression);
+ 	else if (!strcmp(argv[optind], "list-snapshots"))
+ 		list_snapshots(f);
+ 	else if (!strcmp(argv[optind], "quota"))
+diff --git a/smbinfo.rst b/smbinfo.rst
+index 500ce0e..c8f76e6 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -69,6 +69,8 @@ COMMAND
+ 
+ `getcompression`: Prints the compression setting for the file.
+ 
++`setcompression -c <no|default|lznt1>`: Sets the compression setting for the file.
++
+ `list-snapshots`: Lists the previous versions of the volume that backs this file
+ 
+ `quota`: Print the quota for the volume in the form
+-- 
+2.17.1
+
diff --git a/debian/patches/0018-smbinfo.rst-document-new-keys-command.patch b/debian/patches/0018-smbinfo.rst-document-new-keys-command.patch
new file mode 100644
index 0000000..cfe48d5
--- /dev/null
+++ b/debian/patches/0018-smbinfo.rst-document-new-keys-command.patch
@@ -0,0 +1,30 @@
+From 74a1ced5f706ea6a9cab885693c7755657b81a2a Mon Sep 17 00:00:00 2001
+From: Aurelien Aptel <[e-mail]>
+Origin: Upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=74a1ced5f706ea6a9cab885693c7755657b81a2a
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1886551
+Date: Mon, 14 Oct 2019 19:06:25 +0200
+Subject: [PATCH] smbinfo.rst: document new `keys` command
+
+Signed-off-by: Aurelien Aptel <[e-mail]>
+---
+ smbinfo.rst | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/smbinfo.rst b/smbinfo.rst
+index c8f76e6..7413849 100644
+--- a/smbinfo.rst
++++ b/smbinfo.rst
+@@ -90,6 +90,10 @@ COMMAND
+ - File types
+ - File flags
+ 
++`keys`: Dump session id, encryption keys and decryption keys so that
++the SMB3 traffic of this mount can be decryped e.g. via wireshark
++(requires root).
++
+ *****
+ NOTES
+ *****
+-- 
+2.17.1
+
diff --git a/debian/patches/series b/debian/patches/series
index 8e67634..de0e82b 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,4 +1,26 @@
+<<<<<<< debian/patches/series
 0001-Fix-fPIE-casing.patch
 0002-destdir.patch
 0003-python2or3.patch
 0004-Fix-manpage-warning-by-separating-binary-names-using.patch
+=======
+setcifsacl-fix-adding-ACE-when-owner-sid-in-unexpect.patch
+0001-smbinfo-add-a-utility-to-display-smb-specific-inform.patch
+0002-smbinfo.rst-document-kernel-version.patch
+0003-smbinfo-Add-more-File-Information-classes.patch
+0004-smbinfo-update-help-text.patch
+0005-smbinfo-Update-the-usage-text-with-the-new-infolevel.patch
+0006-smbinfo-add-FileFsFullSizeInformation.patch
+0007-smbinfo-decode-the-ACEs.patch
+0008-smbinfo-fix-code-style.patch
+0009-smbinfo-add-fsctl-getobjid-support.patch
+0010-smbinfo-missing-help-for-fsctl-getobjid.patch
+0011-smbinfo-Add-ability-to-query-snapshots-previous-vers.patch
+0012-smbinfo-make-argument-order-consistent.patch
+0013-smbinfo-use-constant-for-input-buffer-length.patch
+0014-smbinfo-Improve-help-usage-and-add-h-option.patch
+0015-smbinfo-add-GETCOMPRESSION-support.patch
+0016-smbinfo-print-the-security-information-needed-to-dec.patch
+0017-smbinfo-Add-SETCOMPRESSION-support.patch
+0018-smbinfo.rst-document-new-keys-command.patch
+>>>>>>> debian/patches/series
diff --git a/debian/patches/setcifsacl-fix-adding-ACE-when-owner-sid-in-unexpect.patch b/debian/patches/setcifsacl-fix-adding-ACE-when-owner-sid-in-unexpect.patch
new file mode 100644
index 0000000..6f56099
--- /dev/null
+++ b/debian/patches/setcifsacl-fix-adding-ACE-when-owner-sid-in-unexpect.patch
@@ -0,0 +1,53 @@
+Description: setcifsacl: fix adding ACE when owner sid in unexpected location
+ If owner information is after the ACEs instead of before (e.g. Azure servers) in the ACL query
+ then we would get "invalid argument" returned on setcifsacl -a (adding an ACE).
+
+ This fixes that.
+
+ Signed-off-by: Steve French <[e-mail]>
+
+Author: Steve French <[e-mail]>
+Origin: upstream, https://git.samba.org/?p=cifs-utils.git;a=commit;h=0feb1a80f3777f4c244b46958aa9f730de9e18b6
+Bug-Ubuntu: https://launchpad.net/bugs/1886548
+Index: cifs-utils-6.8/setcifsacl.c
+===================================================================
+--- cifs-utils-6.8.orig/setcifsacl.c
++++ cifs-utils-6.8/setcifsacl.c
+@@ -106,13 +106,32 @@ copy_sec_desc(const struct cifs_ntsd *pn
+ 
+ 	/* copy owner sid */
+ 	owner_sid_ptr = (struct cifs_sid *)((char *)pntsd + osidsoffset);
+-	nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + osidsoffset);
+-	size = copy_cifs_sid(nowner_sid_ptr, owner_sid_ptr);
+-	bufsize += size;
++	group_sid_ptr = (struct cifs_sid *)((char *)pntsd + gsidsoffset);
++	/*
++	 * some servers like Azure return the owner and group SIDs at end rather
++	 * than at the beginning of the ACL so don't want to overwrite the last ACEs
++         */
++	if (dacloffset <= osidsoffset) {
++		/* owners placed at end of ACL */
++		nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + dacloffset + size);
++		pnntsd->osidoffset = dacloffset + size;
++		size = copy_cifs_sid(nowner_sid_ptr, owner_sid_ptr);
++		bufsize += size;
++		/* put group SID after owner SID */
++		ngroup_sid_ptr = (struct cifs_sid *)((char *)nowner_sid_ptr + size);
++		pnntsd->gsidoffset = pnntsd->osidoffset + size;
++	} else {
++		/*
++		 * Most servers put the owner information at the beginning,
++		 * before the ACL
++		 */
++		nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + osidsoffset);
++		size = copy_cifs_sid(nowner_sid_ptr, owner_sid_ptr);
++		bufsize += size;
++		ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + gsidsoffset);
++	}
+ 
+ 	/* copy group sid */
+-	group_sid_ptr = (struct cifs_sid *)((char *)pntsd + gsidsoffset);
+-	ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + gsidsoffset);
+ 	size = copy_cifs_sid(ngroup_sid_ptr, group_sid_ptr);
+ 	bufsize += size;
+