modules/access/nfs.c

   1 /*****************************************************************************
   2  * nfs.c: NFS VLC access plug-in
   3  *****************************************************************************
   4  * Copyright © 2016  VLC authors, VideoLAN and VideoLabs
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #ifdef HAVE_POLL
  33 # include <poll.h>
  34 #endif
  35
  36 #include <vlc_common.h>
  37 #include <vlc_access.h>
  38 #include <vlc_dialog.h>
  39 #include <vlc_input_item.h>
  40 #include <vlc_plugin.h>
  41 #include <vlc_url.h>
  42 #include <vlc_interrupt.h>
  43
  44 #include <nfsc/libnfs.h>
  45 #include <nfsc/libnfs-raw.h>
  46 #include <nfsc/libnfs-raw-nfs.h>
  47 #include <nfsc/libnfs-raw-mount.h>
  48
  49 #define AUTO_GUID_TEXT N_("Set NFS uid/guid automatically")
  50 #define AUTO_GUID_LONGTEXT N_("If uid/gid are not specified in " \
  51     "the url, VLC will automatically set a uid/gid.")
  52
  53 static int Open(vlc_object_t *);
  54 static void Close(vlc_object_t *);
  55
  56 vlc_module_begin()
  57     set_shortname(N_("NFS"))
  58     set_description(N_("NFS input"))
  59     set_category(CAT_INPUT)
  60     set_subcategory(SUBCAT_INPUT_ACCESS)
  61     add_bool("nfs-auto-guid", true, AUTO_GUID_TEXT, AUTO_GUID_LONGTEXT, true)
  62     set_capability("access", 2)
  63     add_shortcut("nfs")
  64     set_callbacks(Open, Close)
  65 vlc_module_end()
  66
  67 struct access_sys_t
  68 {
  69     struct rpc_context *    p_mount; /* used to to get exports mount point */
  70     struct nfs_context *    p_nfs;
  71     struct nfs_url *        p_nfs_url;
  72     struct nfs_stat_64      stat;
  73     struct nfsfh *          p_nfsfh;
  74     struct nfsdir *         p_nfsdir;
  75     vlc_url_t               encoded_url;
  76     char *                  psz_url_decoded;
  77     char *                  psz_url_decoded_slash;
  78     bool                    b_eof;
  79     bool                    b_error;
  80     bool                    b_auto_guid;
  81
  82     union {
  83         struct
  84         {
  85             char **         ppsz_names;
  86             int             i_count;
  87         } exports;
  88         struct
  89         {
  90             uint8_t *p_buf;
  91             size_t i_len;
  92         } read;
  93         struct
  94         {
  95             bool b_done;
  96         } seek;
  97     } res;
  98 };
  99
 100 static bool
 101 nfs_check_status(stream_t *p_access, int i_status, const char *psz_error,
 102                  const char *psz_func)
 103 {
 104     access_sys_t *sys = p_access->p_sys;
 105
 106     if (i_status < 0)
 107     {
 108         if (i_status != -EINTR)
 109         {
 110             msg_Err(p_access, "%s failed: %d, '%s'", psz_func, i_status,
 111                     psz_error);
 112             if (!sys->b_error)
 113                 vlc_dialog_display_error(p_access,
 114                                          _("NFS operation failed"), "%s",
 115                                          psz_error);
 116         }
 117         else
 118             msg_Warn(p_access, "%s interrupted", psz_func);
 119         sys->b_error = true;
 120         return true;
 121     }
 122     else
 123         return false;
 124 }
 125 #define NFS_CHECK_STATUS(p_access, i_status, p_data) \
 126     nfs_check_status(p_access, i_status, (const char *)p_data, __func__)
 127
 128 static int
 129 vlc_rpc_mainloop(stream_t *p_access, struct rpc_context *p_rpc_ctx,
 130                  bool (*pf_until_cb)(stream_t *))
 131 {
 132     access_sys_t *p_sys = p_access->p_sys;
 133
 134     while (!p_sys->b_error && !pf_until_cb(p_access))
 135     {
 136         struct pollfd p_fds[1];
 137         int i_ret;
 138         p_fds[0].fd = rpc_get_fd(p_rpc_ctx);
 139         p_fds[0].events = rpc_which_events(p_rpc_ctx);
 140
 141         if ((i_ret = vlc_poll_i11e(p_fds, 1, -1)) < 0)
 142         {
 143             if (errno == EINTR)
 144                 msg_Warn(p_access, "vlc_poll_i11e interrupted");
 145             else
 146                 msg_Err(p_access, "vlc_poll_i11e failed");
 147             p_sys->b_error = true;
 148         }
 149         else if (i_ret > 0 && p_fds[0].revents
 150              && rpc_service(p_rpc_ctx, p_fds[0].revents) < 0)
 151         {
 152             msg_Err(p_access, "nfs_service failed");
 153             p_sys->b_error = true;
 154         }
 155     }
 156     return p_sys->b_error ? -1 : 0;
 157 }
 158
 159 static int
 160 vlc_nfs_mainloop(stream_t *p_access, bool (*pf_until_cb)(stream_t *))
 161 {
 162     access_sys_t *p_sys = p_access->p_sys;
 163     assert(p_sys->p_nfs != NULL);
 164     return vlc_rpc_mainloop(p_access, nfs_get_rpc_context(p_sys->p_nfs),
 165                             pf_until_cb);
 166 }
 167
 168 static int
 169 vlc_mount_mainloop(stream_t *p_access, bool (*pf_until_cb)(stream_t *))
 170 {
 171     access_sys_t *p_sys = p_access->p_sys;
 172     assert(p_sys->p_mount != NULL);
 173     return vlc_rpc_mainloop(p_access, p_sys->p_mount, pf_until_cb);
 174 }
 175
 176 static void
 177 nfs_read_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 178             void *p_private_data)
 179 {
 180     VLC_UNUSED(p_nfs);
 181     stream_t *p_access = p_private_data;
 182     access_sys_t *p_sys = p_access->p_sys;
 183     assert(p_sys->p_nfs == p_nfs);
 184     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 185         return;
 186
 187     if (i_status == 0)
 188         p_sys->b_eof = true;
 189     else
 190     {
 191         p_sys->res.read.i_len = i_status;
 192         memcpy(p_sys->res.read.p_buf, p_data, i_status);
 193     }
 194 }
 195
 196 static bool
 197 nfs_read_finished_cb(stream_t *p_access)
 198 {
 199     access_sys_t *p_sys = p_access->p_sys;
 200     return p_sys->res.read.i_len > 0 || p_sys->b_eof;
 201 }
 202
 203 static ssize_t
 204 FileRead(stream_t *p_access, void *p_buf, size_t i_len)
 205 {
 206     access_sys_t *p_sys = p_access->p_sys;
 207
 208     if (p_sys->b_eof)
 209         return 0;
 210
 211     p_sys->res.read.i_len = 0;
 212     p_sys->res.read.p_buf = p_buf;
 213     if (nfs_read_async(p_sys->p_nfs, p_sys->p_nfsfh, i_len, nfs_read_cb,
 214                        p_access) < 0)
 215     {
 216         msg_Err(p_access, "nfs_read_async failed");
 217         return -1;
 218     }
 219
 220     if (vlc_nfs_mainloop(p_access, nfs_read_finished_cb) < 0)
 221         return -1;
 222
 223     return p_sys->res.read.i_len;
 224 }
 225
 226 static void
 227 nfs_seek_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 228             void *p_private_data)
 229 {
 230     VLC_UNUSED(p_nfs);
 231     stream_t *p_access = p_private_data;
 232     access_sys_t *p_sys = p_access->p_sys;
 233     assert(p_sys->p_nfs == p_nfs);
 234     (void) p_data;
 235     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 236         return;
 237
 238     p_sys->res.seek.b_done = true;
 239 }
 240
 241 static bool
 242 nfs_seek_finished_cb(stream_t *p_access)
 243 {
 244     access_sys_t *p_sys = p_access->p_sys;
 245     return p_sys->res.seek.b_done;
 246 }
 247
 248 static int
 249 FileSeek(stream_t *p_access, uint64_t i_pos)
 250 {
 251     access_sys_t *p_sys = p_access->p_sys;
 252
 253     p_sys->res.seek.b_done = false;
 254     if (nfs_lseek_async(p_sys->p_nfs, p_sys->p_nfsfh, i_pos, SEEK_SET,
 255                         nfs_seek_cb, p_access) < 0)
 256     {
 257         msg_Err(p_access, "nfs_seek_async failed");
 258         return VLC_EGENERIC;
 259     }
 260
 261     if (vlc_nfs_mainloop(p_access, nfs_seek_finished_cb) < 0)
 262         return VLC_EGENERIC;
 263
 264     return VLC_SUCCESS;
 265 }
 266
 267 static int
 268 FileControl(stream_t *p_access, int i_query, va_list args)
 269 {
 270     access_sys_t *p_sys = p_access->p_sys;
 271
 272     switch (i_query)
 273     {
 274         case STREAM_CAN_SEEK:
 275             *va_arg(args, bool *) = true;
 276             break;
 277
 278         case STREAM_CAN_FASTSEEK:
 279             *va_arg(args, bool *) = false;
 280             break;
 281
 282         case STREAM_CAN_PAUSE:
 283         case STREAM_CAN_CONTROL_PACE:
 284             *va_arg(args, bool *) = true;
 285             break;
 286
 287         case STREAM_GET_SIZE:
 288         {
 289             *va_arg(args, uint64_t *) = p_sys->stat.nfs_size;
 290             break;
 291         }
 292
 293         case STREAM_GET_PTS_DELAY:
 294             *va_arg(args, int64_t *) = var_InheritInteger(p_access,
 295                                                           "network-caching");
 296             break;
 297
 298         case STREAM_SET_PAUSE_STATE:
 299             break;
 300
 301         default:
 302             return VLC_EGENERIC;
 303     }
 304     return VLC_SUCCESS;
 305 }
 306
 307 static char *
 308 NfsGetUrl(vlc_url_t *p_url, const char *psz_file)
 309 {
 310     /* nfs://<psz_host><psz_path><psz_file>?<psz_option> */
 311     char *psz_url;
 312     if (asprintf(&psz_url, "nfs://%s%s%s%s%s%s", p_url->psz_host,
 313                  p_url->psz_path != NULL ? p_url->psz_path : "",
 314                  p_url->psz_path != NULL && p_url->psz_path[0] != '\0' &&
 315                  p_url->psz_path[strlen(p_url->psz_path) - 1] != '/' ? "/" : "",
 316                  psz_file,
 317                  p_url->psz_option != NULL ? "?" : "",
 318                  p_url->psz_option != NULL ? p_url->psz_option : "") == -1)
 319         return NULL;
 320     else
 321         return psz_url;
 322 }
 323
 324 static int
 325 DirRead(stream_t *p_access, input_item_node_t *p_node)
 326 {
 327     access_sys_t *p_sys = p_access->p_sys;
 328     struct nfsdirent *p_nfsdirent;
 329     int i_ret = VLC_SUCCESS;
 330     assert(p_sys->p_nfsdir);
 331
 332     struct vlc_readdir_helper rdh;
 333     vlc_readdir_helper_init(&rdh, p_access, p_node);
 334
 335     while (i_ret == VLC_SUCCESS
 336         && (p_nfsdirent = nfs_readdir(p_sys->p_nfs, p_sys->p_nfsdir)) != NULL)
 337     {
 338         char *psz_name_encoded = vlc_uri_encode(p_nfsdirent->name);
 339         if (psz_name_encoded == NULL)
 340         {
 341             i_ret = VLC_ENOMEM;
 342             break;
 343         }
 344         char *psz_url = NfsGetUrl(&p_sys->encoded_url, psz_name_encoded);
 345         free(psz_name_encoded);
 346         if (psz_url == NULL)
 347         {
 348             i_ret = VLC_ENOMEM;
 349             break;
 350         }
 351
 352         int i_type;
 353         switch (p_nfsdirent->type)
 354         {
 355         case NF3REG:
 356             i_type = ITEM_TYPE_FILE;
 357             break;
 358         case NF3DIR:
 359             i_type = ITEM_TYPE_DIRECTORY;
 360             break;
 361         default:
 362             i_type = ITEM_TYPE_UNKNOWN;
 363         }
 364         i_ret = vlc_readdir_helper_additem(&rdh, psz_url, NULL, p_nfsdirent->name,
 365                                            i_type, ITEM_NET);
 366         free(psz_url);
 367     }
 368
 369     vlc_readdir_helper_finish(&rdh, i_ret == VLC_SUCCESS);
 370
 371     return i_ret;
 372 }
 373
 374 static int
 375 MountRead(stream_t *p_access, input_item_node_t *p_node)
 376 {
 377     access_sys_t *p_sys = p_access->p_sys;
 378     assert(p_sys->p_mount != NULL && p_sys->res.exports.i_count >= 0);
 379     int i_ret = VLC_SUCCESS;
 380
 381     struct vlc_readdir_helper rdh;
 382     vlc_readdir_helper_init(&rdh, p_access, p_node);
 383
 384     for (int i = 0; i < p_sys->res.exports.i_count && i_ret == VLC_SUCCESS; ++i)
 385     {
 386         char *psz_name = p_sys->res.exports.ppsz_names[i];
 387
 388         char *psz_url = NfsGetUrl(&p_sys->encoded_url, psz_name);
 389         if (psz_url == NULL)
 390         {
 391             i_ret = VLC_ENOMEM;
 392             break;
 393         }
 394         i_ret = vlc_readdir_helper_additem(&rdh, psz_url, NULL, psz_name,
 395                                             ITEM_TYPE_DIRECTORY, ITEM_NET);
 396         free(psz_url);
 397     }
 398
 399     vlc_readdir_helper_finish(&rdh, i_ret == VLC_SUCCESS);
 400
 401     return i_ret;
 402 }
 403
 404 static void
 405 nfs_opendir_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 406                void *p_private_data)
 407 {
 408     VLC_UNUSED(p_nfs);
 409     stream_t *p_access = p_private_data;
 410     access_sys_t *p_sys = p_access->p_sys;
 411     assert(p_sys->p_nfs == p_nfs);
 412     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 413         return;
 414
 415     p_sys->p_nfsdir = p_data;
 416 }
 417
 418 static void
 419 nfs_open_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 420             void *p_private_data)
 421 {
 422     VLC_UNUSED(p_nfs);
 423     stream_t *p_access = p_private_data;
 424     access_sys_t *p_sys = p_access->p_sys;
 425     assert(p_sys->p_nfs == p_nfs);
 426     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 427         return;
 428
 429     p_sys->p_nfsfh = p_data;
 430 }
 431
 432 static void
 433 nfs_stat64_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 434               void *p_private_data)
 435 {
 436     VLC_UNUSED(p_nfs);
 437     stream_t *p_access = p_private_data;
 438     access_sys_t *p_sys = p_access->p_sys;
 439     assert(p_sys->p_nfs == p_nfs);
 440     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 441         return;
 442
 443     struct nfs_stat_64 *p_stat = p_data;
 444     p_sys->stat = *p_stat;
 445
 446     if (p_sys->b_auto_guid)
 447     {
 448         nfs_set_uid(p_sys->p_nfs, p_sys->stat.nfs_uid);
 449         nfs_set_gid(p_sys->p_nfs, p_sys->stat.nfs_gid);
 450     }
 451
 452     if (S_ISDIR(p_sys->stat.nfs_mode))
 453     {
 454         msg_Dbg(p_access, "nfs_opendir: '%s'", p_sys->p_nfs_url->file);
 455         if (nfs_opendir_async(p_sys->p_nfs, p_sys->p_nfs_url->file,
 456                               nfs_opendir_cb, p_access) != 0)
 457         {
 458             msg_Err(p_access, "nfs_opendir_async failed");
 459             p_sys->b_error = true;
 460         }
 461     }
 462     else if (S_ISREG(p_sys->stat.nfs_mode))
 463     {
 464         msg_Dbg(p_access, "nfs_open: '%s'", p_sys->p_nfs_url->file);
 465         if (nfs_open_async(p_sys->p_nfs, p_sys->p_nfs_url->file, O_RDONLY,
 466                            nfs_open_cb, p_access) < 0)
 467         {
 468             msg_Err(p_access, "nfs_open_async failed");
 469             p_sys->b_error = true;
 470         }
 471     }
 472     else
 473     {
 474         msg_Err(p_access, "nfs_stat64_cb: file type not handled");
 475         p_sys->b_error = true;
 476     }
 477 }
 478
 479 static void
 480 nfs_mount_cb(int i_status, struct nfs_context *p_nfs, void *p_data,
 481              void *p_private_data)
 482 {
 483     VLC_UNUSED(p_nfs);
 484     stream_t *p_access = p_private_data;
 485     access_sys_t *p_sys = p_access->p_sys;
 486     assert(p_sys->p_nfs == p_nfs);
 487     (void) p_data;
 488
 489     /* If a directory url doesn't end with '/', there is no way to know which
 490      * part of the url is the export point and which part is the path. An
 491      * example with "nfs://myhost/mnt/data": we can't know if /mnt or /mnt/data
 492      * is the export point. Therefore, in case of EACCES error, retry to mount
 493      * the url by adding a '/' to the decoded path. */
 494     if (i_status == -EACCES && p_sys->psz_url_decoded_slash == NULL)
 495     {
 496         vlc_url_t url;
 497         vlc_UrlParse(&url, p_sys->psz_url_decoded);
 498         if (url.psz_path == NULL || url.psz_path[0] == '\0'
 499          || url.psz_path[strlen(url.psz_path) - 1] == '/'
 500          || (p_sys->psz_url_decoded_slash = NfsGetUrl(&url, "/")) == NULL)
 501         {
 502             vlc_UrlClean(&url);
 503             NFS_CHECK_STATUS(p_access, i_status, p_data);
 504             return;
 505         }
 506         else
 507         {
 508             vlc_UrlClean(&url);
 509             msg_Warn(p_access, "trying to mount '%s' again by adding a '/'",
 510                      p_access->psz_url);
 511             return;
 512         }
 513     }
 514
 515     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 516         return;
 517
 518     if (nfs_stat64_async(p_sys->p_nfs, p_sys->p_nfs_url->file, nfs_stat64_cb,
 519                          p_access) < 0)
 520     {
 521         msg_Err(p_access, "nfs_stat64_async failed");
 522         p_sys->b_error = true;
 523     }
 524 }
 525
 526 static bool
 527 nfs_mount_open_finished_cb(stream_t *p_access)
 528 {
 529     access_sys_t *p_sys = p_access->p_sys;
 530     return p_sys->p_nfsfh != NULL || p_sys->p_nfsdir != NULL
 531         || p_sys->psz_url_decoded_slash != NULL;
 532 }
 533
 534 static bool
 535 nfs_mount_open_slash_finished_cb(stream_t *p_access)
 536 {
 537     access_sys_t *p_sys = p_access->p_sys;
 538     return p_sys->p_nfsfh != NULL || p_sys->p_nfsdir != NULL;
 539 }
 540
 541 static void
 542 mount_export_cb(struct rpc_context *p_ctx, int i_status, void *p_data,
 543                 void *p_private_data)
 544 {
 545     VLC_UNUSED(p_ctx);
 546     stream_t *p_access = p_private_data;
 547     access_sys_t *p_sys = p_access->p_sys;
 548     assert(p_sys->p_mount == p_ctx);
 549     if (NFS_CHECK_STATUS(p_access, i_status, p_data))
 550         return;
 551
 552     exports p_export = *(exports *)p_data;
 553     p_sys->res.exports.i_count = 0;
 554
 555     /* Dup the export linked list into an array of const char * */
 556     while (p_export != NULL)
 557     {
 558         p_sys->res.exports.i_count++;
 559         p_export = p_export->ex_next;
 560     }
 561     if (p_sys->res.exports.i_count == 0)
 562         return;
 563
 564     p_sys->res.exports.ppsz_names = calloc(p_sys->res.exports.i_count,
 565                                            sizeof(char *));
 566     if (p_sys->res.exports.ppsz_names == NULL)
 567     {
 568         p_sys->b_error = true;
 569         return;
 570     }
 571
 572     p_export = *(exports *)p_data;
 573     unsigned int i_idx = 0;
 574     while (p_export != NULL)
 575     {
 576         p_sys->res.exports.ppsz_names[i_idx] = strdup(p_export->ex_dir);
 577         if (p_sys->res.exports.ppsz_names[i_idx] == NULL)
 578         {
 579             for (unsigned int i = 0; i < i_idx; ++i)
 580                 free(p_sys->res.exports.ppsz_names[i]);
 581             free(p_sys->res.exports.ppsz_names);
 582             p_sys->res.exports.ppsz_names = NULL;
 583             p_sys->res.exports.i_count = 0;
 584             p_sys->b_error = true;
 585             return;
 586         }
 587         i_idx++;
 588         p_export = p_export->ex_next;
 589     }
 590 }
 591
 592 static bool
 593 mount_getexports_finished_cb(stream_t *p_access)
 594 {
 595     access_sys_t *p_sys = p_access->p_sys;
 596     return p_sys->res.exports.i_count != -1;
 597 }
 598
 599 static int
 600 NfsInit(stream_t *p_access, const char *psz_url_decoded)
 601 {
 602     access_sys_t *p_sys = p_access->p_sys;
 603     p_sys->p_nfs = nfs_init_context();
 604     if (p_sys->p_nfs == NULL)
 605     {
 606         msg_Err(p_access, "nfs_init_context failed");
 607         return -1;
 608     }
 609
 610     p_sys->p_nfs_url = nfs_parse_url_incomplete(p_sys->p_nfs, psz_url_decoded);
 611     if (p_sys->p_nfs_url == NULL || p_sys->p_nfs_url->server == NULL)
 612     {
 613         msg_Err(p_access, "nfs_parse_url_incomplete failed: '%s'",
 614                 nfs_get_error(p_sys->p_nfs));
 615         return -1;
 616     }
 617     return 0;
 618 }
 619
 620 static int
 621 Open(vlc_object_t *p_obj)
 622 {
 623     stream_t *p_access = (stream_t *)p_obj;
 624     access_sys_t *p_sys = vlc_obj_calloc(p_obj, 1, sizeof (*p_sys));
 625
 626     if (unlikely(p_sys == NULL))
 627         return VLC_ENOMEM;
 628     p_access->p_sys = p_sys;
 629
 630     p_sys->b_auto_guid = var_InheritBool(p_obj, "nfs-auto-guid");
 631
 632     /* nfs_* functions need a decoded url */
 633     p_sys->psz_url_decoded = vlc_uri_decode_duplicate(p_access->psz_url);
 634     if (p_sys->psz_url_decoded == NULL)
 635         goto error;
 636
 637     /* Parse the encoded URL */
 638     vlc_UrlParse(&p_sys->encoded_url, p_access->psz_url);
 639     if (p_sys->encoded_url.psz_option)
 640     {
 641         if (strstr(p_sys->encoded_url.psz_option, "uid")
 642          || strstr(p_sys->encoded_url.psz_option, "gid"))
 643             p_sys->b_auto_guid = false;
 644     }
 645
 646     if (NfsInit(p_access, p_sys->psz_url_decoded) == -1)
 647         goto error;
 648
 649     if (p_sys->p_nfs_url->path != NULL && p_sys->p_nfs_url->file != NULL)
 650     {
 651         /* The url has a valid path and file, mount the path and open/opendir
 652          * the file */
 653         msg_Dbg(p_access, "nfs_mount: server: '%s', path: '%s'",
 654                 p_sys->p_nfs_url->server, p_sys->p_nfs_url->path);
 655
 656         if (nfs_mount_async(p_sys->p_nfs, p_sys->p_nfs_url->server,
 657                             p_sys->p_nfs_url->path, nfs_mount_cb, p_access) < 0)
 658         {
 659             msg_Err(p_access, "nfs_mount_async failed");
 660             goto error;
 661         }
 662
 663         if (vlc_nfs_mainloop(p_access, nfs_mount_open_finished_cb) < 0)
 664             goto error;
 665
 666         if (p_sys->psz_url_decoded_slash != NULL)
 667         {
 668             /* Retry to mount by adding a '/' to the path, see comment in
 669              * nfs_mount_cb */
 670             nfs_destroy_url(p_sys->p_nfs_url);
 671             nfs_destroy_context(p_sys->p_nfs);
 672             p_sys->p_nfs_url = NULL;
 673             p_sys->p_nfs = NULL;
 674
 675             if (NfsInit(p_access, p_sys->psz_url_decoded_slash) == -1
 676              || p_sys->p_nfs_url->path == NULL || p_sys->p_nfs_url->file == NULL)
 677                 goto error;
 678
 679             if (nfs_mount_async(p_sys->p_nfs, p_sys->p_nfs_url->server,
 680                                 p_sys->p_nfs_url->path, nfs_mount_cb, p_access) < 0)
 681             {
 682                 msg_Err(p_access, "nfs_mount_async failed");
 683                 goto error;
 684             }
 685
 686             if (vlc_nfs_mainloop(p_access, nfs_mount_open_slash_finished_cb) < 0)
 687                 goto error;
 688         }
 689
 690         if (p_sys->p_nfsfh != NULL)
 691         {
 692             p_access->pf_read = FileRead;
 693             p_access->pf_seek = FileSeek;
 694             p_access->pf_control = FileControl;
 695         }
 696         else if (p_sys->p_nfsdir != NULL)
 697         {
 698             p_access->pf_readdir = DirRead;
 699             p_access->pf_seek = NULL;
 700             p_access->pf_control = access_vaDirectoryControlHelper;
 701         }
 702         else
 703             vlc_assert_unreachable();
 704     }
 705     else
 706     {
 707         /* url is just a server: fetch exports point */
 708         nfs_destroy_context(p_sys->p_nfs);
 709         p_sys->p_nfs = NULL;
 710
 711         p_sys->p_mount = rpc_init_context();
 712         if (p_sys->p_mount == NULL)
 713         {
 714             msg_Err(p_access, "rpc_init_context failed");
 715             goto error;
 716         }
 717
 718         p_sys->res.exports.ppsz_names = NULL;
 719         p_sys->res.exports.i_count = -1;
 720
 721         if (mount_getexports_async(p_sys->p_mount, p_sys->p_nfs_url->server,
 722                                    mount_export_cb, p_access) < 0)
 723         {
 724             msg_Err(p_access, "mount_getexports_async failed");
 725             goto error;
 726         }
 727
 728         if (vlc_mount_mainloop(p_access, mount_getexports_finished_cb) < 0)
 729             goto error;
 730
 731         p_access->pf_readdir = MountRead;
 732         p_access->pf_seek = NULL;
 733         p_access->pf_control = access_vaDirectoryControlHelper;
 734     }
 735
 736     return VLC_SUCCESS;
 737
 738 error:
 739     Close(p_obj);
 740     return VLC_EGENERIC;
 741 }
 742
 743 static void
 744 Close(vlc_object_t *p_obj)
 745 {
 746     stream_t *p_access = (stream_t *)p_obj;
 747     access_sys_t *p_sys = p_access->p_sys;
 748
 749     if (p_sys->p_nfsfh != NULL)
 750         nfs_close(p_sys->p_nfs, p_sys->p_nfsfh);
 751
 752     if (p_sys->p_nfsdir != NULL)
 753         nfs_closedir(p_sys->p_nfs, p_sys->p_nfsdir);
 754
 755     if (p_sys->p_nfs != NULL)
 756         nfs_destroy_context(p_sys->p_nfs);
 757
 758     if (p_sys->p_mount != NULL)
 759     {
 760         for (int i = 0; i < p_sys->res.exports.i_count; ++i)
 761             free(p_sys->res.exports.ppsz_names[i]);
 762         free(p_sys->res.exports.ppsz_names);
 763         rpc_destroy_context(p_sys->p_mount);
 764     }
 765
 766     if (p_sys->p_nfs_url != NULL)
 767         nfs_destroy_url(p_sys->p_nfs_url);
 768
 769     vlc_UrlClean(&p_sys->encoded_url);
 770
 771     free(p_sys->psz_url_decoded);
 772     free(p_sys->psz_url_decoded_slash);
 773 }