Compare revisions

Thomas Guillem · Felix Paul Kühne · Thomas Guillem · Felix Paul Kühne · Thomas Guillem · Felix Paul Kühne
--- a/contrib/src/libdsm/SHA512SUMS
+++ b/contrib/src/libdsm/SHA512SUMS
-59963c1d12839004c7e3717cf5f029ffc5f10d72b133d88c33c1367f4343befb170c2b10f7cbc690d1700b380e298436e34b80fc214546f6ded104c649ee21eb  libdsm-0.3.2.tar.gz
+9ee82c8812a807054ebe3ceb2a6ba37c36d188052cfbd7f5ba5b435ede8f6bee09690fb0d0c94e1e4d0022bbbdfa2837f09c69ccc00d17f79efe002cc158825a  libdsm-0.4.2.tar.xz
--- a/contrib/src/libdsm/rules.mak
+++ b/contrib/src/libdsm/rules.mak
 # libdsm

-#LIBDSM_GITURL := git://github.com/videolabs/libdsm.git
-LIBDSM_VERSION := 0.3.2
-LIBDSM_URL := https://github.com/videolabs/libdsm/releases/download/v$(LIBDSM_VERSION)/libdsm-$(LIBDSM_VERSION).tar.gz
+LIBDSM_VERSION := 0.4.2
+LIBDSM_URL := https://github.com/videolabs/libdsm/releases/download/v$(LIBDSM_VERSION)/libdsm-$(LIBDSM_VERSION).tar.xz

 ifeq ($(call need_pkg,"libdsm >= 0.2.0"),)
 PKGS_FOUND += libdsm
 endif

-$(TARBALLS)/libdsm-$(LIBDSM_VERSION).tar.gz:
+$(TARBALLS)/libdsm-$(LIBDSM_VERSION).tar.xz:
 	$(call download_pkg,$(LIBDSM_URL),libdsm)

 LIBDSM_CONF = $(HOSTCONF)
@@ -16,9 +15,9 @@ LIBDSM_CONF = $(HOSTCONF)
 ifndef WITH_OPTIMIZATION
 LIBDSM_CONF += --enable-debug
 endif
-.sum-libdsm: libdsm-$(LIBDSM_VERSION).tar.gz
+.sum-libdsm: libdsm-$(LIBDSM_VERSION).tar.xz

-libdsm: libdsm-$(LIBDSM_VERSION).tar.gz .sum-libdsm
+libdsm: libdsm-$(LIBDSM_VERSION).tar.xz .sum-libdsm
 	$(UNPACK)
 	$(MOVE)

@@ -27,11 +26,8 @@ ifdef HAVE_WIN32
 DEPS_libdsm += pthreads $(DEPS_pthreads)
 endif

-.libdsm: libdsm
-	cd $< && touch "config.rpath"
-	$(RECONF)
-	cd $< && $(HOSTVARS_PIC) ./configure --disable-programs $(LIBDSM_CONF)
-	cd $< && $(MAKE)
-	$(call pkg_static,"libdsm.pc")
-	cd $< && $(MAKE) install
+.libdsm: libdsm crossfile.meson
+	cd $< && rm -rf ./build
+	cd $< && $(HOSTVARS_MESON) $(MESON) -Dauto_features=disabled -Dbinaries=false build
+	cd $< && cd build && ninja install
 	touch $@
--- a/contrib/src/smb2/SHA512SUMS
+++ b/contrib/src/smb2/SHA512SUMS
-ba70459966ec2a927058d16870f5dd73960d38a36c28500b9f1186ad7aca94449b0e8908e4c7ce46cafb8d05a8e93517df615c3ef2dbd559fd409ba98bd3a824  libsmb2-08c1682f44b00fa694836703ed16ec74987f77d2.tar.gz
+d62d05f946d104995faefa8e4fdb3a9121f697a29aac031ddd6f2c3ec9ce97edbd18d84ace56103c19e0f56356b531f7d2db826428aff52abb4930603a5fb50f  libsmb2-4.0.0.tar.gz
--- a/contrib/src/smb2/rules.mak
+++ b/contrib/src/smb2/rules.mak
 # SMB2
-SMB2_VERSION := 08c1682f44b00fa694836703ed16ec74987f77d2
-SMB2_URL := https://github.com/sahlberg/libsmb2/archive/$(SMB2_VERSION).tar.gz
+SMB2_VERSION := 4.0.0
+SMB2_URL := https://github.com/sahlberg/libsmb2/archive/v$(SMB2_VERSION).tar.gz

 ifeq ($(call need_pkg,"smb2"),)
 PKGS_FOUND += smb2

--- a/modules/access/dsm/access.c
+++ b/modules/access/dsm/access.c
@@ -121,7 +121,6 @@ static int add_item( stream_t *p_access,  struct vlc_readdir_helper *p_rdh,

 struct access_sys_t
 {
-    netbios_ns         *p_ns;               /**< Netbios name service */
    smb_session        *p_session;          /**< bdsm SMB Session object */

    vlc_url_t           url;
@@ -136,6 +135,53 @@ struct access_sys_t
    smb_tid             i_tid;              /**< SMB Tree ID we're connected to */
 };

+#if BDSM_VERSION_CURRENT >= 5
+
+static void
+smb_session_interrupt_callback( void *data )
+{
+    smb_session_abort( data );
+}
+
+static inline void
+smb_session_interrupt_register( access_sys_t *sys )
+{
+    vlc_interrupt_register( smb_session_interrupt_callback, sys->p_session );
+}
+
+static inline void
+smb_session_interrupt_unregister( void )
+{
+    vlc_interrupt_unregister();
+}
+
+static void
+netbios_ns_interrupt_callback( void *data )
+{
+    netbios_ns_abort( data );
+}
+
+static inline void
+netbios_ns_interrupt_register( netbios_ns *ns )
+{
+    vlc_interrupt_register( netbios_ns_interrupt_callback, ns );
+}
+
+static inline void
+netbios_ns_interrupt_unregister( void )
+{
+    vlc_interrupt_unregister();
+}
+
+#else
+
+#define smb_session_interrupt_register( sys ) do {} while (0)
+#define smb_session_interrupt_unregister() do {} while(0)
+#define netbios_ns_interrupt_register( ns ) do {} while (0)
+#define netbios_ns_interrupt_unregister() do {} while (0)
+
+#endif
+
 /*****************************************************************************
 * Open: Initialize module's data structures and libdsm
 *****************************************************************************/
@@ -151,10 +197,6 @@ static int Open( vlc_object_t *p_this )
    if( p_access->p_sys == NULL )
        return VLC_ENOMEM;

-    p_sys->p_ns = netbios_ns_new();
-    if( p_sys->p_ns == NULL )
-        goto error;
-
    p_sys->p_session = smb_session_new();
    if( p_sys->p_session == NULL )
        goto error;
@@ -171,18 +213,6 @@ static int Open( vlc_object_t *p_this )
    msg_Dbg( p_access, "Session: Host name = %s, ip = %s", p_sys->netbios_name,
             inet_ntoa( p_sys->addr ) );

-    /* Now that we have the required data, let's establish a session */
-    status = smb_session_connect( p_sys->p_session, p_sys->netbios_name,
-                                  p_sys->addr.s_addr, SMB_TRANSPORT_TCP );
-    if( status != DSM_SUCCESS )
-    {
-        msg_Err( p_access, "Unable to connect/negotiate SMB session");
-        /* FIXME: libdsm wrongly return network error when the server can't
-         * handle the SMBv1 protocol */
-        status = DSM_ERROR_GENERIC;
-        goto error;
-    }
-
    get_path( p_access );

    if( login( p_access ) != VLC_SUCCESS )
@@ -194,20 +224,27 @@ static int Open( vlc_object_t *p_this )

    /* If there is no shares, browse them */
    if( !p_sys->psz_share )
+    {
        return BrowserInit( p_access );
+    }

    assert(p_sys->i_fd > 0);

    msg_Dbg( p_access, "Path: Share name = %s, path = %s", p_sys->psz_share,
             p_sys->psz_path );

+    smb_session_interrupt_register( p_sys );
+
    st = smb_stat_fd( p_sys->p_session, p_sys->i_fd );
    if( smb_stat_get( st, SMB_STAT_ISDIR ) )
    {
        smb_fclose( p_sys->p_session, p_sys->i_fd );
+        smb_session_interrupt_unregister();
        return BrowserInit( p_access );
    }

+    smb_session_interrupt_unregister();
+
    msg_Dbg( p_access, "Successfully opened smb://%s", p_access->psz_location );

    ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
@@ -250,8 +287,6 @@ static void Close( vlc_object_t *p_this )
    stream_t     *p_access = (stream_t*)p_this;
    access_sys_t *p_sys = p_access->p_sys;

-    if( p_sys->p_ns )
-        netbios_ns_destroy( p_sys->p_ns );
    if( p_sys->i_fd )
        smb_fclose( p_sys->p_session, p_sys->i_fd );
    if( p_sys->p_session )
@@ -277,11 +312,22 @@ static int get_address( stream_t *p_access )
        /* This is not an ip address, let's try netbios/dns resolve */
        struct addrinfo *p_info = NULL;

+        netbios_ns *p_ns = netbios_ns_new();
+        if( p_ns == NULL )
+            return VLC_EGENERIC;
+        netbios_ns_interrupt_register( p_ns );
+
        /* Is this a netbios name on this LAN ? */
-        if( netbios_ns_resolve( p_sys->p_ns, p_sys->url.psz_host,
-                                NETBIOS_FILESERVER,
-                                &p_sys->addr.s_addr) == 0 )
+        uint32_t ip4_addr;
+
+        int ret = netbios_ns_resolve( p_ns, p_sys->url.psz_host,
+                                      NETBIOS_FILESERVER, &ip4_addr);
+        netbios_ns_interrupt_unregister();
+        netbios_ns_destroy( p_ns );
+
+        if( ret == 0 )
        {
+            p_sys->addr.s_addr = ip4_addr;
            strlcpy( p_sys->netbios_name, p_sys->url.psz_host, 16);
            return VLC_SUCCESS;
        }
@@ -304,8 +350,17 @@ static int get_address( stream_t *p_access )
            return VLC_EGENERIC;
    }

+    netbios_ns *p_ns = netbios_ns_new();
+    if( p_ns == NULL )
+        return VLC_EGENERIC;
+    netbios_ns_interrupt_register( p_ns );
+
    /* We have an IP address, let's find the NETBIOS name */
-    const char *psz_nbt = netbios_ns_inverse( p_sys->p_ns, p_sys->addr.s_addr );
+    const char *psz_nbt = netbios_ns_inverse( p_ns, p_sys->addr.s_addr );
+
+    netbios_ns_interrupt_unregister();
+    netbios_ns_destroy( p_ns );
+
    if( psz_nbt != NULL )
        strlcpy( p_sys->netbios_name, psz_nbt, 16 );
    else
@@ -382,10 +437,29 @@ static int login( stream_t *p_access )
    }
    psz_domain = credential.psz_realm ? credential.psz_realm : p_sys->netbios_name;

+    smb_session_interrupt_register( p_sys );
+
+    /* Now that we have the required data, let's establish a session */
+    int status = smb_session_connect( p_sys->p_session, p_sys->netbios_name,
+                                      p_sys->addr.s_addr, SMB_TRANSPORT_TCP );
+    if( status != DSM_SUCCESS )
+    {
+        msg_Err( p_access, "Unable to connect/negotiate SMB session");
+        /* FIXME: libdsm wrongly return network error when the server can't
+         * handle the SMBv1 protocol */
+        smb_session_interrupt_unregister();
+        goto error;
+    }
+
    /* Try to authenticate on the remote machine */
    int connect_err = smb_connect( p_access, psz_login, psz_password, psz_domain );
    if( connect_err == ENOENT )
+    {
+        smb_session_interrupt_unregister();
        goto error;
+    }
+
+    smb_session_interrupt_unregister();

    if( connect_err == EACCES )
    {
@@ -405,7 +479,10 @@ static int login( stream_t *p_access )
            psz_password = credential.psz_password;
            psz_domain = credential.psz_realm ? credential.psz_realm
                                              : p_sys->netbios_name;
+
+            smb_session_interrupt_register( p_sys );
            connect_err = smb_connect( p_access, psz_login, psz_password, psz_domain );
+            smb_session_interrupt_unregister();
        }

        if( connect_err != 0 )
@@ -505,7 +582,11 @@ static int Seek( stream_t *p_access, uint64_t i_pos )

    msg_Dbg( p_access, "seeking to %"PRId64, i_pos );

-    if (smb_fseek(p_sys->p_session, p_sys->i_fd, i_pos, SMB_SEEK_SET) == -1)
+    smb_session_interrupt_register( p_sys );
+    int ret = smb_fseek(p_sys->p_session, p_sys->i_fd, i_pos, SMB_SEEK_SET);
+    smb_session_interrupt_unregister();
+
+    if (ret == -1)
        return VLC_EGENERIC;

    return VLC_SUCCESS;
@@ -519,7 +600,10 @@ static ssize_t Read( stream_t *p_access, void *p_buffer, size_t i_len )
    access_sys_t *p_sys = p_access->p_sys;
    int i_read;

+    smb_session_interrupt_register( p_sys );
    i_read = smb_fread( p_sys->p_session, p_sys->i_fd, p_buffer, i_len );
+    smb_session_interrupt_unregister();
+
    if( i_read < 0 )
    {
        msg_Err( p_access, "read failed" );
@@ -602,9 +686,16 @@ static int BrowseShare( stream_t *p_access, input_item_node_t *p_node )
    size_t          share_count;
    int             i_ret = VLC_SUCCESS;

+    smb_session_interrupt_register( p_sys );
+
    if( smb_share_get_list( p_sys->p_session, &shares, &share_count )
        != DSM_SUCCESS )
+    {
+        smb_session_interrupt_unregister();
        return VLC_EGENERIC;
+    }
+
+    smb_session_interrupt_unregister();

    struct vlc_readdir_helper rdh;
    vlc_readdir_helper_init( &rdh, p_access, p_node );
@@ -639,11 +730,18 @@ static int BrowseDirectory( stream_t *p_access, input_item_node_t *p_node )
    {
        if( asprintf( &psz_query, "%s\\*", p_sys->psz_path ) == -1 )
            return VLC_ENOMEM;
+
+        smb_session_interrupt_register( p_sys );
        files = smb_find( p_sys->p_session, p_sys->i_tid, psz_query );
+        smb_session_interrupt_unregister();
        free( psz_query );
    }
    else
+    {
+        smb_session_interrupt_register( p_sys );
        files = smb_find( p_sys->p_session, p_sys->i_tid, "\\*" );
+        smb_session_interrupt_unregister();
+    }

    if( files == NULL )
        return VLC_EGENERIC;

--- a/modules/access/smb2.c
+++ b/modules/access/smb2.c
@@ -48,8 +48,34 @@
 #include <smb2/libsmb2-raw.h>

 #ifdef HAVE_DSM
-# include <bdsm/netbios_ns.h>
-# include <bdsm/netbios_defs.h>
+# include <bdsm/bdsm.h>
+
+#if BDSM_VERSION_CURRENT >= 5
+
+static void
+netbios_ns_interrupt_callback(void *data)
+{
+    netbios_ns_abort(data);
+}
+
+static inline void
+netbios_ns_interrupt_register(netbios_ns *ns)
+{
+    vlc_interrupt_register(netbios_ns_interrupt_callback, ns);
+}
+
+static inline void
+netbios_ns_interrupt_unregister(void)
+{
+    vlc_interrupt_unregister();
+}
+
+#else
+
+#define netbios_ns_interrupt_register( ns ) do {} while (0)
+#define netbios_ns_interrupt_unregister() do {} while (0)
+#endif
+
 #endif

 #ifdef HAVE_ARPA_INET_H
@@ -85,7 +111,16 @@ struct access_sys
    vlc_url_t               encoded_url;
    bool                    eof;
    bool                    smb2_connected;
-    int                     error_status;
+};
+
+struct vlc_smb2_op
+{
+    vlc_object_t *log;
+
+    struct smb2_context *smb2;
+    struct smb2_context **smb2p;
+
+    int error_status;

    bool res_done;
    union {
@@ -93,43 +128,65 @@ struct access_sys
        {
            size_t len;
        } read;
+        void *data;
    } res;
 };

-static int
-smb2_check_status(stream_t *access, int status, const char *psz_func)
+#define VLC_SMB2_OP(access, smb2p_) { \
+    .log = access ? VLC_OBJECT(access) : NULL, \
+    .smb2p = smb2p_, \
+    .smb2 = (assert(*smb2p_ != NULL), *smb2p_), \
+    .error_status = 0, \
+    .res_done = false, \
+};
+
+static inline void
+vlc_smb2_op_reset(struct vlc_smb2_op *op, struct smb2_context **smb2p)
 {
-    struct access_sys *sys = access->p_sys;
+    op->res_done = false;
+    op->smb2p = smb2p;
+    op->smb2 = *smb2p;
+    op->error_status = 0;
+}

+static int
+smb2_check_status(struct vlc_smb2_op *op, const char *psz_func, int status)
+{
    if (status < 0)
    {
-        const char *psz_error = smb2_get_error(sys->smb2);
-        msg_Warn(access, "%s failed: %d, '%s'", psz_func, status, psz_error);
-        sys->error_status = status;
+        const char *psz_error = smb2_get_error(op->smb2);
+        if (op->log)
+            msg_Warn(op->log, "%s failed: %d, '%s'", psz_func, status, psz_error);
+        op->error_status = status;
        return -1;
    }
    else
    {
-        sys->res_done = true;
+        op->res_done = true;
        return 0;
    }
 }

 static void
-smb2_set_error(stream_t *access, const char *psz_func, int err)
+smb2_set_error(struct vlc_smb2_op *op, const char *psz_func, int err)
 {
-    struct access_sys *sys = access->p_sys;
+    if (op->log && err != -EINTR)
+        msg_Err(op->log, "%s failed: %d, %s", psz_func, err, smb2_get_error(op->smb2));

-    msg_Err(access, "%s failed: %d, %s", psz_func, err,
-            smb2_get_error(sys->smb2));
-    sys->error_status = err;
+    /* Don't override if set via smb2_check_status */
+    if (op->error_status == 0)
+        op->error_status = err;
+
+    smb2_destroy_context(op->smb2);
+    op->smb2 = NULL;
+    *op->smb2p = NULL;
 }

-#define VLC_SMB2_CHECK_STATUS(access, status) \
-    smb2_check_status(access, status, __func__)
+#define VLC_SMB2_CHECK_STATUS(op, status) \
+    smb2_check_status(op, __func__, status)

-#define VLC_SMB2_SET_ERROR(access, func, err) \
-    smb2_set_error(access, func, err)
+#define VLC_SMB2_SET_ERROR(op, func, err) \
+    smb2_set_error(op, func, err)

 #define VLC_SMB2_STATUS_DENIED(x) (x == -ECONNREFUSED || x == -EACCES)

@@ -162,37 +219,14 @@ smb2_service_fd(struct smb2_context *smb2, int fd, int revents)
 #endif

 static int
-vlc_smb2_mainloop(stream_t *access, bool teardown)
+vlc_smb2_mainloop(struct vlc_smb2_op *op)
 {
-#define TEARDOWN_TIMEOUT 250 /* in ms */
-    struct access_sys *sys = access->p_sys;
-
-    int timeout = -1;
-    int (*poll_func)(struct pollfd *, unsigned, int) = vlc_poll_i11e;
-
-    /* vlc_smb2_mainloop() can be called to clean-up after an error, but this
-     * function can override the error_status (from async cbs). Therefore,
-     * store the original error_status in order to restore it at the end of
-     * this call (since we want to keep the first and original error status). */
-    int original_error_status = sys->error_status;
-
-    if (teardown)
-    {
-        /* Don't use vlc_poll_i11e that will return immediately with the EINTR
-         * errno if VLC's input is interrupted. Use the posix poll with a
-         * timeout to let a chance for a clean teardown. */
-        timeout = TEARDOWN_TIMEOUT;
-        poll_func = (void *)poll;
-        sys->error_status = 0;
-    }
-
-    sys->res_done = false;
-    while (sys->error_status == 0 && !sys->res_done)
+    while (op->error_status == 0 && !op->res_done)
    {
        int ret, smb2_timeout;
        size_t fd_count;
-        const t_socket *fds = smb2_get_fds(sys->smb2, &fd_count, &smb2_timeout);
-        int events = smb2_which_events(sys->smb2);
+        const t_socket *fds = smb2_get_fds(op->smb2, &fd_count, &smb2_timeout);
+        int events = smb2_which_events(op->smb2);

        struct pollfd p_fds[fd_count];
        for (size_t i = 0; i < fd_count; ++i)
@@ -200,61 +234,46 @@ vlc_smb2_mainloop(stream_t *access, bool teardown)
            p_fds[i].events = events;
            p_fds[i].fd = fds[i];
        }
-        if (smb2_timeout != -1)
-            timeout = smb2_timeout;

-        if (fds == NULL || (ret = poll_func(p_fds, fd_count, timeout)) < 0)
+        if (fds == NULL || (ret = vlc_poll_i11e(p_fds, fd_count, smb2_timeout)) < 0)
        {
-            if (errno == EINTR)
-            {
-                msg_Warn(access, "vlc_poll_i11e interrupted");
-                if (poll_func != (void *) poll)
-                {
-                    /* Try again with a timeout to let the command complete.
-                     * Indeed, if this command is interrupted, every future
-                     * commands will fail and we won't be able to teardown. */
-                    timeout = TEARDOWN_TIMEOUT;
-                    poll_func = (void *) poll;
-                }
-                else
-                    sys->error_status = -errno;
-            }
-            else
-            {
-                msg_Err(access, "vlc_poll_i11e failed");
-                sys->error_status = -errno;
-            }
+            if (op->log && errno == EINTR)
+                msg_Warn(op->log, "vlc_poll_i11e interrupted");
+            VLC_SMB2_SET_ERROR(op, "poll", -errno);
        }
        else if (ret == 0)
        {
-            if (teardown)
-                sys->error_status = -ETIMEDOUT;
-            else if (smb2_service_fd(sys->smb2, -1, 0) < 0)
-                VLC_SMB2_SET_ERROR(access, "smb2_service", 1);
+            if (smb2_service_fd(op->smb2, -1, 0) < 0)
+                VLC_SMB2_SET_ERROR(op, "smb2_service", -EINVAL);
        }
        else
        {
            for (size_t i = 0; i < fd_count; ++i)
            {
                if (p_fds[i].revents
-                 && smb2_service_fd(sys->smb2, p_fds[i].fd, p_fds[i].revents) < 0)
-                    VLC_SMB2_SET_ERROR(access, "smb2_service", 1);
+                 && smb2_service_fd(op->smb2, p_fds[i].fd, p_fds[i].revents) < 0)
+                    VLC_SMB2_SET_ERROR(op, "smb2_service", -EINVAL);
            }
        }
    }

-    int ret = sys->error_status == 0 ? 0 : -1;
-    if (original_error_status != 0)
-        sys->error_status = original_error_status;
-    return ret;
+    if (op->error_status != 0 && op->smb2 != NULL)
+    {
+        /* An error was signalled from a smb2 cb. Destroy the smb2 context now
+         * since this call might still trigger callbacks using the current op
+         * (that is allocated on the stack). */
+        smb2_destroy_context(op->smb2);
+        op->smb2 = NULL;
+        *op->smb2p = NULL;
+    }
+
+    return op->error_status;
 }

 #define VLC_SMB2_GENERIC_CB() \
-    VLC_UNUSED(smb2); \
-    stream_t *access = private_data; \
-    struct access_sys *sys = access->p_sys; \
-    assert(sys->smb2 == smb2); \
-    if (VLC_SMB2_CHECK_STATUS(access, status)) \
+    struct vlc_smb2_op *op = private_data; \
+    assert(op->smb2 == smb2); (void) smb2; \
+    if (VLC_SMB2_CHECK_STATUS(op, status)) \
        return

 static void
@@ -272,10 +291,7 @@ smb2_read_cb(struct smb2_context *smb2, int status, void *data,
    VLC_UNUSED(data);
    VLC_SMB2_GENERIC_CB();

-    if (status == 0)
-        sys->eof = true;
-    else
-        sys->res.read.len = status;
+    op->res.read.len = status;
 }

 static ssize_t
@@ -283,7 +299,7 @@ FileRead(stream_t *access, void *buf, size_t len)
 {
    struct access_sys *sys = access->p_sys;

-    if (sys->eof || sys->error_status != 0)
+    if (sys->eof || sys->smb2 == NULL)
        return 0;

    /* Limit the read size since smb2_read_async() will complete only after
@@ -292,18 +308,24 @@ FileRead(stream_t *access, void *buf, size_t len)
    if (len > 262144)
        len = 262144;

-    sys->res.read.len = 0;
-    if (smb2_read_async(sys->smb2, sys->smb2fh, buf, len,
-                        smb2_read_cb, access) < 0)
+    struct vlc_smb2_op op = VLC_SMB2_OP(access, &sys->smb2);
+    op.res.read.len = 0;
+
+    int err = smb2_read_async(sys->smb2, sys->smb2fh, buf, len,
+                              smb2_read_cb, &op);
+    if (err < 0)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_read_async", 1);
+        VLC_SMB2_SET_ERROR(&op, "smb2_read_async", err);
        return 0;
    }

-    if (vlc_smb2_mainloop(access, false) < 0)
+    if (vlc_smb2_mainloop(&op) < 0)
        return 0;

-    return sys->res.read.len;
+    if (op.res.read.len == 0)
+        sys->eof = true;
+
+    return op.res.read.len;
 }

 static int
@@ -311,14 +333,24 @@ FileSeek(stream_t *access, uint64_t i_pos)
 {
    struct access_sys *sys = access->p_sys;

-    if (sys->error_status != 0)
+    if (sys->smb2 == NULL)
        return VLC_EGENERIC;

-    if (smb2_lseek(sys->smb2, sys->smb2fh, i_pos, SEEK_SET, NULL) < 0)
+    if (i_pos > INT64_MAX)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_seek_async", 1);
+        msg_Err(access, "can't seek past INT64_MAX (requested: %"PRIu64")\n",
+                i_pos);
        return VLC_EGENERIC;
    }
+
+    struct vlc_smb2_op op = VLC_SMB2_OP(access, &sys->smb2);
+
+    int64_t err = smb2_lseek(op.smb2, sys->smb2fh, i_pos, SEEK_SET, NULL);
+    if (err < 0)
+    {
+        VLC_SMB2_SET_ERROR(&op, "smb2_lseek", err);
+        return err;
+    }
    sys->eof = false;

    return VLC_SUCCESS;
@@ -465,49 +497,34 @@ ShareEnum(stream_t *access, input_item_node_t *p_node)
 }

 static int
-vlc_smb2_close_fh(stream_t *access)
+vlc_smb2_close_fh(stream_t *access, struct smb2_context **smb2p,
+                  struct smb2fh *smb2fh)
 {
-    struct access_sys *sys = access->p_sys;
-
-    assert(sys->smb2fh);
+    struct vlc_smb2_op op = VLC_SMB2_OP(access, smb2p);

-    if (smb2_close_async(sys->smb2, sys->smb2fh, smb2_generic_cb, access) < 0)
+    int err = smb2_close_async(op.smb2, smb2fh, smb2_generic_cb, &op);
+    if (err < 0)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_close_async", 1);
+        VLC_SMB2_SET_ERROR(&op, "smb2_close_async", err);
        return -1;
    }

-    sys->smb2fh = NULL;
-
-    return vlc_smb2_mainloop(access, true);
+    return vlc_smb2_mainloop(&op);
 }

 static int
-vlc_smb2_disconnect_share(stream_t *access)
+vlc_smb2_disconnect_share(stream_t *access, struct smb2_context **smb2p)
 {
-    struct access_sys *sys = access->p_sys;
+    struct vlc_smb2_op op = VLC_SMB2_OP(access, smb2p);

-    if (!sys->smb2_connected)
-        return 0;
-
-    if (smb2_disconnect_share_async(sys->smb2, smb2_generic_cb, access) < 0)
+    int err = smb2_disconnect_share_async(op.smb2, smb2_generic_cb, &op);
+    if (err < 0)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_connect_share_async", 1);
+        VLC_SMB2_SET_ERROR(&op, "smb2_connect_share_async", err);
        return -1;
    }

-    int ret = vlc_smb2_mainloop(access, true);
-    sys->smb2_connected = false;
-    return ret;
-}
-
-static void
-smb2_opendir_cb(struct smb2_context *smb2, int status, void *data,
-                void *private_data)
-{
-    VLC_SMB2_GENERIC_CB();
-
-    sys->smb2dir = data;
+    return vlc_smb2_mainloop(&op);
 }

 static void
@@ -516,16 +533,7 @@ smb2_open_cb(struct smb2_context *smb2, int status, void *data,
 {
    VLC_SMB2_GENERIC_CB();

-    sys->smb2fh = data;
-}
-
-static void
-smb2_share_enum_cb(struct smb2_context *smb2, int status, void *data,
-                   void *private_data)
-{
-    VLC_SMB2_GENERIC_CB();
-
-    sys->share_enum = data;
+    op->res.data = data;
 }

 static void
@@ -561,8 +569,77 @@ vlc_smb2_print_addr(stream_t *access)
 }

 static int
-vlc_smb2_open_share(stream_t *access, const char *url,
-                    const vlc_credential *credential)
+vlc_smb2_open_share(stream_t *access, struct smb2_context **smb2p,
+                    struct smb2_url *smb2_url, bool do_enum)
+{
+    struct access_sys *sys = access->p_sys;
+    struct smb2_stat_64 smb2_stat;
+
+    struct vlc_smb2_op op = VLC_SMB2_OP(access, smb2p);
+
+    int ret;
+    if (do_enum)
+        ret = smb2_share_enum_async(op.smb2, smb2_open_cb, &op);
+    else
+    {
+        ret = smb2_stat_async(op.smb2, smb2_url->path, &smb2_stat,
+                              smb2_generic_cb, &op);
+        if (ret < 0)
+        {
+            VLC_SMB2_SET_ERROR(&op, "smb2_stat_async", ret);
+            goto error;
+        }
+
+        if (vlc_smb2_mainloop(&op) != 0)
+            goto error;
+
+        if (smb2_stat.smb2_type == SMB2_TYPE_FILE)
+        {
+            vlc_smb2_op_reset(&op, smb2p);
+
+            sys->smb2_size = smb2_stat.smb2_size;
+            ret = smb2_open_async(op.smb2, smb2_url->path, O_RDONLY,
+                                  smb2_open_cb, &op);
+        }
+        else if (smb2_stat.smb2_type == SMB2_TYPE_DIRECTORY)
+        {
+            vlc_smb2_op_reset(&op, smb2p);
+
+            ret = smb2_opendir_async(op.smb2, smb2_url->path, smb2_open_cb, &op);
+        }
+        else
+        {
+            msg_Err(access, "smb2_stat_cb: file type not handled");
+            ret = -ENOENT;
+        }
+    }
+
+    if (ret < 0)
+    {
+        VLC_SMB2_SET_ERROR(&op, "smb2_open*_async", ret);
+        goto error;
+    }
+
+    if (vlc_smb2_mainloop(&op) != 0)
+        goto error;
+
+    if (do_enum)
+        sys->share_enum = op.res.data;
+    else if (smb2_stat.smb2_type == SMB2_TYPE_FILE)
+        sys->smb2fh = op.res.data;
+    else if (smb2_stat.smb2_type == SMB2_TYPE_DIRECTORY)
+        sys->smb2dir = op.res.data;
+    else
+        vlc_assert_unreachable();
+
+    return 0;
+error:
+    return op.error_status;
+}
+
+static int
+vlc_smb2_connect_open_share(stream_t *access, const char *url,
+                            const vlc_credential *credential)
 {
    struct access_sys *sys = access->p_sys;

@@ -572,7 +649,7 @@ vlc_smb2_open_share(stream_t *access, const char *url,
    if (sys->smb2 == NULL)
    {
        msg_Err(access, "smb2_init_context failed");
-        goto error;
+        return -1;
    }
    smb2_url = smb2_parse_url(sys->smb2, url);

@@ -590,78 +667,57 @@ vlc_smb2_open_share(stream_t *access, const char *url,
    if (!username)
    {
        username = "Guest";
-        /* A NULL password enable ntlmssp anonymous login */
-        password = NULL;
+        /* An empty password enable ntlmssp anonymous login */
+        password = "";
    }

    smb2_set_security_mode(sys->smb2, SMB2_NEGOTIATE_SIGNING_ENABLED);
    smb2_set_password(sys->smb2, password);
    smb2_set_domain(sys->smb2, domain ? domain : "");

+    struct vlc_smb2_op op = VLC_SMB2_OP(access, &sys->smb2);
    int err = smb2_connect_share_async(sys->smb2, smb2_url->server, share,
-                                       username, smb2_generic_cb, access);
+                                       username, smb2_generic_cb, &op);
    if (err < 0)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_connect_share_async", err);
+        VLC_SMB2_SET_ERROR(&op, "smb2_connect_share_async", err);
        goto error;
    }
-    if (vlc_smb2_mainloop(access, false) != 0)
+    if (vlc_smb2_mainloop(&op) != 0)
        goto error;
+
    sys->smb2_connected = true;

    vlc_smb2_print_addr(access);

-    int ret;
-    if (do_enum)
-        ret = smb2_share_enum_async(sys->smb2, smb2_share_enum_cb, access);
-    else
-    {
-        struct smb2_stat_64 smb2_stat;
-        if (smb2_stat_async(sys->smb2, smb2_url->path, &smb2_stat,
-                            smb2_generic_cb, access) < 0)
-            VLC_SMB2_SET_ERROR(access, "smb2_stat_async", 1);
-
-        if (vlc_smb2_mainloop(access, false) != 0)
-            goto error;
-
-        if (smb2_stat.smb2_type == SMB2_TYPE_FILE)
-        {
-            sys->smb2_size = smb2_stat.smb2_size;
-            ret = smb2_open_async(sys->smb2, smb2_url->path, O_RDONLY,
-                                  smb2_open_cb, access);
-        }
-        else if (smb2_stat.smb2_type == SMB2_TYPE_DIRECTORY)
-            ret = smb2_opendir_async(sys->smb2, smb2_url->path,
-                                     smb2_opendir_cb, access);
-        else
-        {
-            msg_Err(access, "smb2_stat_cb: file type not handled");
-            sys->error_status = 1;
-            goto error;
-        }
-    }
-
-    if (ret < 0)
+    err = vlc_smb2_open_share(access, &sys->smb2, smb2_url, do_enum);
+    if (err < 0)
    {
-        VLC_SMB2_SET_ERROR(access, "smb2_open*_async", 1);
+        op.error_status = err;
        goto error;
    }

-    if (vlc_smb2_mainloop(access, false) != 0)
-        goto error;
    smb2_destroy_url(smb2_url);
    return 0;

 error:
    if (smb2_url != NULL)
        smb2_destroy_url(smb2_url);
+
    if (sys->smb2 != NULL)
    {
-        vlc_smb2_disconnect_share(access);
-        smb2_destroy_context(sys->smb2);
-        sys->smb2 = NULL;
+        if (sys->smb2_connected)
+        {
+            vlc_smb2_disconnect_share(access, &sys->smb2);
+            sys->smb2_connected = false;
+        }
+        if (sys->smb2 != NULL)
+        {
+            smb2_destroy_context(sys->smb2);
+            sys->smb2 = NULL;
+        }
    }
-    return -1;
+    return op.error_status;
 }

 static char *
@@ -689,6 +745,9 @@ vlc_smb2_resolve(stream_t *access, const char *host, unsigned port)
    /* Test if the host is a netbios name */
    char *out_host = NULL;
    netbios_ns *ns = netbios_ns_new();
+    if (!ns)
+        return NULL;
+    netbios_ns_interrupt_register(ns);
    uint32_t ip4_addr;
    if (netbios_ns_resolve(ns, host, NETBIOS_FILESERVER, &ip4_addr) == 0)
    {
@@ -696,6 +755,7 @@ vlc_smb2_resolve(stream_t *access, const char *host, unsigned port)
        if (inet_ntop(AF_INET, &ip4_addr, ip, sizeof(ip)))
            out_host = strdup(ip);
    }
+    netbios_ns_interrupt_unregister();
    netbios_ns_destroy(ns);
    return out_host;
 #else
@@ -710,6 +770,7 @@ Open(vlc_object_t *p_obj)
    stream_t *access = (stream_t *)p_obj;
    struct access_sys *sys = vlc_obj_calloc(p_obj, 1, sizeof (*sys));
    char *var_domain = NULL;
+    int ret;

    if (unlikely(sys == NULL))
        return VLC_ENOMEM;
@@ -742,10 +803,10 @@ Open(vlc_object_t *p_obj)
    {
        free(url);
        free(resolved_host);
+        ret = -ENOMEM;
        goto error;
    }

-    int ret = -1;
    vlc_credential credential;
    vlc_credential_init(&credential, &sys->encoded_url);
    var_domain = var_InheritString(access, "smb-domain");
@@ -755,17 +816,13 @@ Open(vlc_object_t *p_obj)
     * keystore/user interaction) */
    vlc_credential_get(&credential, access, "smb-user", "smb-pwd", NULL,
                       NULL);
-    ret = vlc_smb2_open_share(access, url, &credential);
+    ret = vlc_smb2_connect_open_share(access, url, &credential);

-    while (ret == -1
-        && (!sys->error_status || VLC_SMB2_STATUS_DENIED(sys->error_status))
+    while (VLC_SMB2_STATUS_DENIED(ret)
        && vlc_credential_get(&credential, access, "smb-user", "smb-pwd",
                              SMB_LOGIN_DIALOG_TITLE, SMB_LOGIN_DIALOG_TEXT,
                              sys->encoded_url.psz_host))
-    {
-        sys->error_status = 0;
-        ret = vlc_smb2_open_share(access, url, &credential);
-    }
+        ret = vlc_smb2_connect_open_share(access, url, &credential);
    free(resolved_host);
    free(url);
    if (ret == 0)
@@ -821,8 +878,7 @@ error:
     * case of network error (EIO) or when the user asked to cancel it
     * (vlc_killed()). Indeed, in these cases, it is useless to try next smb
     * modules. */
-    return vlc_killed() || sys->error_status == -EIO ? VLC_ETIMEOUT
-         : VLC_EGENERIC;
+    return vlc_killed() || ret == -EIO ? VLC_ETIMEOUT : VLC_EGENERIC;
 }

 static void
@@ -832,7 +888,10 @@ Close(vlc_object_t *p_obj)
    struct access_sys *sys = access->p_sys;

    if (sys->smb2fh != NULL)
-        vlc_smb2_close_fh(access);
+    {
+        if (sys->smb2)
+            vlc_smb2_close_fh(access, &sys->smb2, sys->smb2fh);
+    }
    else if (sys->smb2dir != NULL)
        smb2_closedir(sys->smb2, sys->smb2dir);
    else if (sys->share_enum != NULL)
@@ -840,8 +899,14 @@ Close(vlc_object_t *p_obj)
    else
        vlc_assert_unreachable();

-    vlc_smb2_disconnect_share(access);
-    smb2_destroy_context(sys->smb2);
+    assert(sys->smb2_connected);
+
+    if (sys->smb2 != NULL)
+    {
+        vlc_smb2_disconnect_share(access, &sys->smb2);
+        if (sys->smb2 != NULL)
+            smb2_destroy_context(sys->smb2);
+    }

    vlc_UrlClean(&sys->encoded_url);
 }
No results found