dvb: don't preparse
[vlc.git] / modules / access / smb.c
index 58b19b3..e5ebb4f 100644 (file)
@@ -1,50 +1,41 @@
 /*****************************************************************************
  * smb.c: SMB input module
  *****************************************************************************
- * Copyright (C) 2001-2009 the VideoLAN team
+ * Copyright (C) 2001-2015 VLC authors and VideoLAN
  * $Id$
  *
  * Authors: Gildas Bazin <gbazin@videolan.org>
  *
- * 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
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser 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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-
-
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 
-#include <vlc_common.h>
-#include <vlc_plugin.h>
-#include <vlc_access.h>
-
-#ifdef WIN32
-#ifdef HAVE_FCNTL_H
+#include <assert.h>
+#include <errno.h>
+#ifdef _WIN32
 #   include <fcntl.h>
-#endif
-#   ifdef HAVE_SYS_STAT_H
-#       include <sys/stat.h>
-#   endif
+#   include <sys/stat.h>
 #   include <io.h>
-#   define smbc_open(a,b,c) open(a,b,c)
-#   define stat _stati64
-#   define smbc_fstat(a,b) _fstati64(a,b)
+#   define smbc_open(a,b,c) vlc_open(a,b,c)
+#   define smbc_stat(a,b) _stati64(a,b)
 #   define smbc_read read
 #   define smbc_lseek _lseeki64
 #   define smbc_close close
 #   include <libsmbclient.h>
 #endif
 
-#include <errno.h>
+#include <vlc_common.h>
+#include <vlc_fs.h>
+#include <vlc_plugin.h>
+#include <vlc_access.h>
+#include <vlc_input_item.h>
+#include <vlc_url.h>
+#include <vlc_keystore.h>
+
+#include "smb_common.h"
 
 /*****************************************************************************
  * Module descriptor
 static int  Open ( vlc_object_t * );
 static void Close( vlc_object_t * );
 
-#define CACHING_TEXT N_("Caching value in ms")
-#define CACHING_LONGTEXT N_( \
-    "Caching value for SMB streams. This " \
-    "value should be set in milliseconds." )
-#define USER_TEXT N_("SMB user name")
-#define USER_LONGTEXT N_("User name that will " \
-    "be used for the connection.")
-#define PASS_TEXT N_("SMB password")
-#define PASS_LONGTEXT N_("Password that will be " \
-    "used for the connection.")
-#define DOMAIN_TEXT N_("SMB domain")
-#define DOMAIN_LONGTEXT N_("Domain/Workgroup that " \
-    "will be used for the connection.")
-
+#define SMB_HELP N_("Samba (Windows network shares) input")
 vlc_module_begin ()
     set_shortname( "SMB" )
     set_description( N_("SMB input") )
+    set_help(SMB_HELP)
     set_capability( "access", 0 )
     set_category( CAT_INPUT )
     set_subcategory( SUBCAT_INPUT_ACCESS )
-    add_integer( "smb-caching", 2 * DEFAULT_PTS_DELAY / 1000, NULL,
-                 CACHING_TEXT, CACHING_LONGTEXT, true )
-        change_safe()
-    add_string( "smb-user", NULL, NULL, USER_TEXT, USER_LONGTEXT,
+    add_string( "smb-user", NULL, SMB_USER_TEXT, SMB_USER_LONGTEXT,
                 false )
-    add_password( "smb-pwd", NULL, NULL, PASS_TEXT,
-                  PASS_LONGTEXT, false )
-    add_string( "smb-domain", NULL, NULL, DOMAIN_TEXT,
-                DOMAIN_LONGTEXT, false )
+    add_password( "smb-pwd", NULL, SMB_PASS_TEXT,
+                  SMB_PASS_LONGTEXT, false )
+    add_string( "smb-domain", NULL, SMB_DOMAIN_TEXT,
+                SMB_DOMAIN_LONGTEXT, false )
     add_shortcut( "smb" )
     set_callbacks( Open, Close )
 vlc_module_end ()
@@ -97,24 +81,69 @@ vlc_module_end ()
  * Local prototypes
  *****************************************************************************/
 static ssize_t Read( access_t *, uint8_t *, size_t );
-static int Seek( access_t *, int64_t );
+static int Seek( access_t *, uint64_t );
 static int Control( access_t *, int, va_list );
+#ifndef _WIN32
+static int DirRead( access_t *, input_item_node_t * );
+static int DirControl( access_t *, int, va_list );
+#endif
 
 struct access_sys_t
 {
     int i_smb;
+    uint64_t size;
+    vlc_url_t url;
 };
 
-#ifdef WIN32
-static void Win32AddConnection( access_t *, char *, char *, char *, char * );
+#ifdef _WIN32
+static void Win32AddConnection( access_t *, const char *, const char *, const char *, const char *, const char * );
 #else
 static void smb_auth( const char *srv, const char *shr, char *wg, int wglen,
                       char *un, int unlen, char *pw, int pwlen )
 {
+    VLC_UNUSED(srv);
+    VLC_UNUSED(shr);
+    VLC_UNUSED(wg);
+    VLC_UNUSED(wglen);
+    VLC_UNUSED(un);
+    VLC_UNUSED(unlen);
+    VLC_UNUSED(pw);
+    VLC_UNUSED(pwlen);
     //wglen = unlen = pwlen = 0;
 }
 #endif
 
+/* Build an SMB URI
+ * smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]] */
+static int smb_get_uri( access_t *p_access, char **ppsz_uri,
+                        const char *psz_domain,
+                        const char *psz_user, const char *psz_pwd,
+                        const char *psz_server, const char *psz_share_path,
+                        const char *psz_name )
+{
+    assert(psz_server);
+#define PSZ_SHARE_PATH_OR_NULL psz_share_path ? psz_share_path : ""
+#define PSZ_NAME_OR_NULL psz_name ? "/" : "", psz_name ? psz_name : ""
+#ifdef _WIN32
+    if( psz_user )
+        Win32AddConnection( p_access, psz_server, psz_share_path,
+                            psz_user, psz_pwd, psz_domain );
+    return asprintf( ppsz_uri, "//%s%s%s%s", psz_server, PSZ_SHARE_PATH_OR_NULL,
+                     PSZ_NAME_OR_NULL );
+#else
+    (void) p_access;
+    if( psz_user )
+        return asprintf( ppsz_uri, "smb://%s%s%s%s%s@%s%s%s%s",
+                         psz_domain ? psz_domain : "", psz_domain ? ";" : "",
+                         psz_user, psz_pwd ? ":" : "",
+                         psz_pwd ? psz_pwd : "", psz_server,
+                         PSZ_SHARE_PATH_OR_NULL, PSZ_NAME_OR_NULL );
+    else
+        return asprintf( ppsz_uri, "smb://%s%s%s%s", psz_server,
+                         PSZ_SHARE_PATH_OR_NULL, PSZ_NAME_OR_NULL );
+#endif
+}
+
 /****************************************************************************
  * Open: connect to smb server and ask for file
  ****************************************************************************/
@@ -123,93 +152,18 @@ static int Open( vlc_object_t *p_this )
     access_t     *p_access = (access_t*)p_this;
     access_sys_t *p_sys;
     struct stat  filestat;
-    char         *psz_path, *psz_uri;
-    char         *psz_user = NULL, *psz_pwd = NULL, *psz_domain = NULL;
+    vlc_url_t    url;
+    vlc_credential credential;
+    char         *psz_decoded_path = NULL, *psz_uri = NULL,
+                 *psz_var_domain = NULL;
     int          i_ret;
     int          i_smb;
+    uint64_t     i_size;
+    bool         b_is_dir = false;
 
-    /* Parse input URI
-     * [[[domain;]user[:password@]]server[/share[/path[/file]]]] */
-    psz_path = strchr( p_access->psz_path, '/' );
-    if( !psz_path )
-    {
-        msg_Err( p_access, "invalid SMB URI: smb://%s", psz_path );
-        return VLC_EGENERIC;
-    }
-    else
-    {
-        char *psz_tmp = strdup( p_access->psz_path );
-        char *psz_parser;
-
-        psz_tmp[ psz_path - p_access->psz_path ] = 0;
-        psz_path = p_access->psz_path;
-        psz_parser = strchr( psz_tmp, '@' );
-        if( psz_parser )
-        {
-            /* User info is there */
-            *psz_parser = 0;
-            psz_path = p_access->psz_path + (psz_parser - psz_tmp) + 1;
-
-            psz_parser = strchr( psz_tmp, ':' );
-            if( psz_parser )
-            {
-                /* Password found */
-                psz_pwd = strdup( psz_parser+1 );
-                *psz_parser = 0;
-            }
-
-            psz_parser = strchr( psz_tmp, ';' );
-            if( psz_parser )
-            {
-                /* Domain found */
-                *psz_parser = 0; psz_parser++;
-                psz_domain = strdup( psz_tmp );
-            }
-            else psz_parser = psz_tmp;
-
-            psz_user = strdup( psz_parser );
-        }
-
-        free( psz_tmp );
-    }
-
-    /* Build an SMB URI
-     * smb://[[[domain;]user[:password@]]server[/share[/path[/file]]]] */
-
-    if( !psz_user ) psz_user = var_CreateGetString( p_access, "smb-user" );
-    if( psz_user && !*psz_user ) { free( psz_user ); psz_user = NULL; }
-    if( !psz_pwd ) psz_pwd = var_CreateGetString( p_access, "smb-pwd" );
-    if( psz_pwd && !*psz_pwd ) { free( psz_pwd ); psz_pwd = NULL; }
-    if( !psz_domain ) psz_domain = var_CreateGetString( p_access, "smb-domain" );
-    if( psz_domain && !*psz_domain ) { free( psz_domain ); psz_domain = NULL; }
-
-#ifdef WIN32
-    if( psz_user )
-        Win32AddConnection( p_access, psz_path, psz_user, psz_pwd, psz_domain);
-    i_ret = asprintf( &psz_uri, "//%s", psz_path );
-#else
-    if( psz_user )
-        i_ret = asprintf( &psz_uri, "smb://%s%s%s%s%s@%s",
-                          psz_domain ? psz_domain : "", psz_domain ? ";" : "",
-                          psz_user, psz_pwd ? ":" : "",
-                          psz_pwd ? psz_pwd : "", psz_path );
-    else
-        i_ret = asprintf( &psz_uri, "smb://%s", psz_path );
-#endif
-
-    free( psz_user );
-    free( psz_pwd );
-    free( psz_domain );
-
-    if( i_ret == -1 )
-        return VLC_ENOMEM;
-
-#ifndef WIN32
+#ifndef _WIN32
     if( smbc_init( smb_auth, 0 ) )
-    {
-        free( psz_uri );
         return VLC_EGENERIC;
-    }
 #endif
 
 /*
@@ -220,31 +174,101 @@ static int Open( vlc_object_t *p_this )
 #if defined(smbc_open) && defined(open)
 # undef open
 #endif
-    if( (i_smb = smbc_open( psz_uri, O_RDONLY, 0 )) < 0 )
+
+    vlc_UrlParse( &url, p_access->psz_url );
+    if( url.psz_path )
     {
-        msg_Err( p_access, "open failed for '%s' (%m)", p_access->psz_path );
-        free( psz_uri );
-        return VLC_EGENERIC;
+        psz_decoded_path = vlc_uri_decode_duplicate( url.psz_path );
+        if( !psz_decoded_path )
+        {
+            vlc_UrlClean( &url );
+            return VLC_EGENERIC;
+        }
     }
 
+    vlc_credential_init( &credential, &url );
+    psz_var_domain = var_InheritString( p_access, "smb-domain" );
+    credential.psz_realm = psz_var_domain;
+    vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
+                        NULL, NULL );
+    for (;;)
+    {
+        if( smb_get_uri( p_access, &psz_uri, credential.psz_realm,
+                         credential.psz_username, credential.psz_password,
+                         url.psz_host, psz_decoded_path, NULL ) == -1 )
+        {
+            vlc_credential_clean( &credential );
+            free(psz_var_domain);
+            free( psz_decoded_path );
+            vlc_UrlClean( &url );
+            return VLC_ENOMEM;
+        }
+
+        if( ( i_ret = smbc_stat( psz_uri, &filestat ) ) && errno == EACCES )
+        {
+            errno = 0;
+            if( vlc_credential_get( &credential, p_access, "smb-user", "smb-pwd",
+                                    SMB_LOGIN_DIALOG_TITLE,
+                                    SMB_LOGIN_DIALOG_TEXT, url.psz_host) )
+                continue;
+        }
+
+        /* smbc_stat fails with servers or shares. Assume they are directory */
+        if( i_ret || S_ISDIR( filestat.st_mode ) )
+            b_is_dir = true;
+        break;
+    }
+
+    vlc_credential_store( &credential, p_access );
+    vlc_credential_clean( &credential );
+    free(psz_var_domain);
+    free( psz_decoded_path );
+
     /* Init p_access */
-    STANDARD_READ_ACCESS_INIT;
+    access_InitFields( p_access );
+    p_sys =
+    p_access->p_sys = (access_sys_t*)calloc( 1, sizeof( access_sys_t ) );
+    if( !p_sys )
+    {
+        free( psz_uri );
+        vlc_UrlClean( &url );
+        return VLC_ENOMEM;
+    }
 
-    i_ret = smbc_fstat( i_smb, &filestat );
-    if( i_ret )
+    if( b_is_dir )
     {
-        errno = i_ret;
-        msg_Err( p_access, "stat failed (%m)" );
+#ifdef _WIN32
+        free( p_sys );
+        free( psz_uri );
+        vlc_UrlClean( &url );
+        return VLC_EGENERIC;
+#else
+        p_sys->url = url;
+        p_access->pf_readdir = DirRead;
+        p_access->pf_control = DirControl;
+        i_smb = smbc_opendir( psz_uri );
+        i_size = 0;
+#endif
     }
     else
-        p_access->info.i_size = filestat.st_size;
-
+    {
+        ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
+        i_smb = smbc_open( psz_uri, O_RDONLY, 0 );
+        i_size = filestat.st_size;
+    }
     free( psz_uri );
 
-    p_sys->i_smb = i_smb;
+    if( i_smb < 0 )
+    {
+        msg_Err( p_access, "open failed for '%s' (%s)",
+                 p_access->psz_location, vlc_strerror_c(errno) );
+        vlc_UrlClean( &p_sys->url );
+        free( p_sys );
+        return VLC_EGENERIC;
+    }
 
-    /* Update default_pts to a suitable value for smb access */
-    var_Create( p_access, "smb-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    p_sys->size = i_size;
+    p_sys->i_smb = i_smb;
 
     return VLC_SUCCESS;
 }
@@ -257,33 +281,38 @@ static void Close( vlc_object_t *p_this )
     access_t     *p_access = (access_t*)p_this;
     access_sys_t *p_sys = p_access->p_sys;
 
-    smbc_close( p_sys->i_smb );
-    smbc_free_context( smbc_set_context(NULL), 1 );
+    vlc_UrlClean( &p_sys->url );
 
+#ifndef _WIN32
+    if( p_access->pf_readdir )
+        smbc_closedir( p_sys->i_smb );
+    else
+#endif
+        smbc_close( p_sys->i_smb );
     free( p_sys );
 }
 
 /*****************************************************************************
  * Seek: try to go at the right place
  *****************************************************************************/
-static int Seek( access_t *p_access, int64_t i_pos )
+static int Seek( access_t *p_access, uint64_t i_pos )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int64_t      i_ret;
 
-    if( i_pos < 0 ) return VLC_EGENERIC;
+    if( i_pos >= INT64_MAX )
+        return VLC_EGENERIC;
 
     msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
 
     i_ret = smbc_lseek( p_sys->i_smb, i_pos, SEEK_SET );
     if( i_ret == -1 )
     {
-        msg_Err( p_access, "seek failed (%m)" );
+        msg_Err( p_access, "seek failed (%s)", vlc_strerror_c(errno) );
         return VLC_EGENERIC;
     }
 
     p_access->info.b_eof = false;
-    p_access->info.i_pos = i_ret;
 
     return VLC_SUCCESS;
 }
@@ -301,113 +330,165 @@ static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
     i_read = smbc_read( p_sys->i_smb, p_buffer, i_len );
     if( i_read < 0 )
     {
-        msg_Err( p_access, "read failed (%m)" );
+        msg_Err( p_access, "read failed (%s)", vlc_strerror_c(errno) );
+        p_access->info.b_eof = true;
         return -1;
     }
 
     if( i_read == 0 ) p_access->info.b_eof = true;
-    else if( i_read > 0 ) p_access->info.i_pos += i_read;
 
     return i_read;
 }
 
+#ifndef _WIN32
+/*****************************************************************************
+ * DirRead:
+ *****************************************************************************/
+static int DirRead (access_t *p_access, input_item_node_t *p_node )
+{
+    access_sys_t *p_sys = p_access->p_sys;
+    struct smbc_dirent *p_entry;
+    int i_ret = VLC_SUCCESS;
+
+    struct access_fsdir fsdir;
+    access_fsdir_init( &fsdir, p_access, p_node );
+
+    while( i_ret == VLC_SUCCESS && ( p_entry = smbc_readdir( p_sys->i_smb ) ) )
+    {
+        char *psz_uri;
+        const char *psz_server = p_sys->url.psz_host;
+        const char *psz_path = p_sys->url.psz_path;
+        const char *psz_name = p_entry->name;
+        int i_type;
+
+        switch( p_entry->smbc_type )
+        {
+        case SMBC_SERVER:
+        case SMBC_WORKGROUP:
+            psz_server = p_sys->url.psz_host;
+            psz_path = NULL;
+            psz_name = NULL;
+        case SMBC_FILE_SHARE:
+        case SMBC_DIR:
+            i_type = ITEM_TYPE_DIRECTORY;
+            break;
+        case SMBC_FILE:
+            i_type = ITEM_TYPE_FILE;
+            break;
+        default:
+        case SMBC_PRINTER_SHARE:
+        case SMBC_COMMS_SHARE:
+        case SMBC_IPC_SHARE:
+        case SMBC_LINK:
+            continue;
+        }
+
+        char *psz_encoded_name = NULL;
+        if( psz_name != NULL
+         && ( psz_encoded_name = vlc_uri_encode( psz_name ) ) == NULL )
+        {
+            i_ret = VLC_ENOMEM;
+            break;
+        }
+        if( smb_get_uri( p_access, &psz_uri, NULL, NULL, NULL,
+                         psz_server, psz_path, psz_encoded_name ) < 0 )
+        {
+            free(psz_encoded_name);
+            i_ret = VLC_ENOMEM;
+            break;
+        }
+        free(psz_encoded_name);
+        i_ret = access_fsdir_additem( &fsdir, psz_uri, p_entry->name,
+                                      i_type, ITEM_NET );
+        free( psz_uri );
+    }
+
+    access_fsdir_finish( &fsdir, i_ret == VLC_SUCCESS );
+
+    return i_ret;
+}
+
+static int DirControl( access_t *p_access, int i_query, va_list args )
+{
+    switch( i_query )
+    {
+    case ACCESS_IS_DIRECTORY:
+        *va_arg( args, bool * ) = true; /* might loop */
+        break;
+    default:
+        return access_vaDirectoryControlHelper( p_access, i_query, args );
+    }
+
+    return VLC_SUCCESS;
+}
+#endif
+
 /*****************************************************************************
  * Control:
  *****************************************************************************/
 static int Control( access_t *p_access, int i_query, va_list args )
 {
-    bool        *pb_bool;
-    int64_t     *pi_64;
-
     switch( i_query )
     {
     case ACCESS_CAN_SEEK:
-        pb_bool = (bool*)va_arg( args, bool* );
-        *pb_bool = true;
+    case ACCESS_CAN_PAUSE:
+    case ACCESS_CAN_CONTROL_PACE:
+        *va_arg( args, bool* ) = true;
         break;
+
     case ACCESS_CAN_FASTSEEK:
-        pb_bool = (bool*)va_arg( args, bool* );
-        *pb_bool = true;
+        *va_arg( args, bool* ) = false;
         break;
-    case ACCESS_CAN_PAUSE:
-        pb_bool = (bool*)va_arg( args, bool* );
-        *pb_bool = true;
-        break;
-    case ACCESS_CAN_CONTROL_PACE:
-        pb_bool = (bool*)va_arg( args, bool* );
-        *pb_bool = true;
+
+    case ACCESS_GET_SIZE:
+        if( p_access->pf_readdir != NULL )
+            return VLC_EGENERIC;
+        *va_arg( args, uint64_t * ) = p_access->p_sys->size;
         break;
 
     case ACCESS_GET_PTS_DELAY:
-        pi_64 = (int64_t*)va_arg( args, int64_t * );
-        *pi_64 = (int64_t)var_GetInteger( p_access, "smb-caching" ) * 1000;
+        *va_arg( args, int64_t * ) = INT64_C(1000)
+            * var_InheritInteger( p_access, "network-caching" );
         break;
 
     case ACCESS_SET_PAUSE_STATE:
         /* Nothing to do */
         break;
 
-    case ACCESS_GET_TITLE_INFO:
-    case ACCESS_SET_TITLE:
-    case ACCESS_SET_SEEKPOINT:
-    case ACCESS_SET_PRIVATE_ID_STATE:
-    case ACCESS_GET_CONTENT_TYPE:
-        return VLC_EGENERIC;
-
     default:
-        msg_Warn( p_access, "unimplemented query in control" );
         return VLC_EGENERIC;
-
     }
 
     return VLC_SUCCESS;
 }
 
-#ifdef WIN32
-static void Win32AddConnection( access_t *p_access, char *psz_path,
-                                char *psz_user, char *psz_pwd,
-                                char *psz_domain )
+#ifdef _WIN32
+static void Win32AddConnection( access_t *p_access, const char *psz_server,
+                                const char *psz_share, const char *psz_user,
+                                const char *psz_pwd, const char *psz_domain )
 {
-    DWORD (*OurWNetAddConnection2)( LPNETRESOURCE, LPCTSTR, LPCTSTR, DWORD );
-    char psz_remote[MAX_PATH], psz_server[MAX_PATH], psz_share[MAX_PATH];
+    char psz_remote[MAX_PATH];
     NETRESOURCE net_resource;
     DWORD i_result;
-    char *psz_parser;
     VLC_UNUSED( psz_domain );
 
-    HINSTANCE hdll = LoadLibrary(_T("MPR.DLL"));
-    if( !hdll )
-    {
-        msg_Warn( p_access, "couldn't load mpr.dll" );
-        return;
-    }
-
-    OurWNetAddConnection2 =
-      (void *)GetProcAddress( hdll, _T("WNetAddConnection2A") );
-    if( !OurWNetAddConnection2 )
-    {
-        msg_Warn( p_access, "couldn't find WNetAddConnection2 in mpr.dll" );
-        return;
-    }
-
     memset( &net_resource, 0, sizeof(net_resource) );
     net_resource.dwType = RESOURCETYPE_DISK;
 
-    /* Find out server and share names */
-    strlcpy( psz_server, psz_path, sizeof( psz_server ) );
-    psz_share[0] = 0;
-    psz_parser = strchr( psz_path, '/' );
-    if( psz_parser )
-    {
-        char *psz_parser2 = strchr( ++psz_parser, '/' );
-        if( psz_parser2 )
-            strlcpy( psz_share, psz_parser, sizeof( psz_share ) );
-   }
+    if (psz_share)
+        psz_share = psz_share + 1; /* skip first '/' */
+    else
+        psz_share = "";
 
     snprintf( psz_remote, sizeof( psz_remote ), "\\\\%s\\%s", psz_server, psz_share );
+    /* remove trailings '/' */
+    char *psz_delim = strchr( psz_remote, '/' );
+    if( psz_delim )
+        *psz_delim = '\0';
+
     net_resource.lpRemoteName = psz_remote;
 
-    i_result = OurWNetAddConnection2( &net_resource, psz_pwd, psz_user, 0 );
+    i_result = WNetAddConnection2( &net_resource, psz_pwd, psz_user, 0 );
 
     if( i_result != NO_ERROR )
     {
@@ -422,7 +503,5 @@ static void Win32AddConnection( access_t *p_access, char *psz_path,
     {
         msg_Dbg( p_access, "failed to connect to %s", psz_remote );
     }
-
-    FreeLibrary( hdll );
 }
-#endif // WIN32
+#endif // _WIN32