mc/lib/vfs/utilvfs.c

/* Utilities for VFS modules.

   Copyright (C) 1988, 1992, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   2005, 2006, 2007 Free Software Foundation, Inc.
   Copyright (C) 1995, 1996 Miguel de Icaza

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library 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 Library General Public License for more details.

   You should have received a copy of the GNU Library 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.  */

/**
 * \file
 * \brief Source: Utilities for VFS modules
 * \author Miguel de Icaza
 * \date 1995, 1996
 */

#include <config.h>

#include <ctype.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "lib/global.h"
#include "lib/unixcompat.h"
#include "lib/util.h"           /* mc_mkstemps() */
#include "lib/widget.h"         /* message() */

#include "vfs.h"
#include "utilvfs.h"

/*** global variables ****************************************************************************/

/*** file scope macro definitions ****************************************************************/

#ifndef TUNMLEN
#define TUNMLEN 256
#endif
#ifndef TGNMLEN
#define TGNMLEN 256
#endif

#define myuid   ( my_uid < 0? (my_uid = getuid()): my_uid )
#define mygid   ( my_gid < 0? (my_gid = getgid()): my_gid )

/* Parsing code is used by ftpfs, fish and extfs */
#define MAXCOLS         30

#define MC_HISTORY_VFS_PASSWORD       "mc.vfs.password"

/*** file scope type declarations ****************************************************************/

/*** file scope variables ************************************************************************/

static char *columns[MAXCOLS];  /* Points to the string in column n */
static int column_ptr[MAXCOLS]; /* Index from 0 to the starting positions of the columns */

/*** file scope functions ************************************************************************/
/* --------------------------------------------------------------------------------------------- */

static int
is_num (int idx)
{
    char *column = columns[idx];

    if (!column || column[0] < '0' || column[0] > '9')
        return 0;

    return 1;
}

/* --------------------------------------------------------------------------------------------- */
/* Return 1 for MM-DD-YY and MM-DD-YYYY */

static int
is_dos_date (const char *str)
{
    int len;

    if (!str)
        return 0;

    len = strlen (str);
    if (len != 8 && len != 10)
        return 0;

    if (str[2] != str[5])
        return 0;

    if (!strchr ("\\-/", (int) str[2]))
        return 0;

    return 1;
}

/* --------------------------------------------------------------------------------------------- */

static int
is_week (const char *str, struct tm *tim)
{
    static const char *week = "SunMonTueWedThuFriSat";
    const char *pos;

    if (!str)
        return 0;

    pos = strstr (week, str);
    if (pos != NULL)
    {
        if (tim != NULL)
            tim->tm_wday = (pos - week) / 3;
        return 1;
    }
    return 0;
}

/* --------------------------------------------------------------------------------------------- */

static int
is_month (const char *str, struct tm *tim)
{
    static const char *month = "JanFebMarAprMayJunJulAugSepOctNovDec";
    const char *pos;

    if (!str)
        return 0;

    pos = strstr (month, str);
    if (pos != NULL)
    {
        if (tim != NULL)
            tim->tm_mon = (pos - month) / 3;
        return 1;
    }
    return 0;
}

/* --------------------------------------------------------------------------------------------- */
/**
 * Check for possible locale's abbreviated month name (Jan..Dec).
 * Any 3 bytes long string without digit, control and punctuation characters.
 * isalpha() is locale specific, so it cannot be used if current
 * locale is "C" and ftp server use Cyrillic.
 * NB: It is assumed there are no whitespaces in month.
 */
static int
is_localized_month (const char *month)
{
    int i = 0;

    if (!month)
        return 0;

    while ((i < 3) && *month && !isdigit ((unsigned char) *month)
           && !iscntrl ((unsigned char) *month) && !ispunct ((unsigned char) *month))
    {
        i++;
        month++;
    }
    return ((i == 3) && (*month == 0));
}

/* --------------------------------------------------------------------------------------------- */

static int
is_time (const char *str, struct tm *tim)
{
    const char *p, *p2;

    if (str == NULL)
        return 0;

    p = strchr (str, ':');
    p2 = strrchr (str, ':');
    if (p != NULL && p2 != NULL)
    {
        if (p != p2)
        {
            if (sscanf (str, "%2d:%2d:%2d", &tim->tm_hour, &tim->tm_min, &tim->tm_sec) != 3)
                return 0;
        }
        else
        {
            if (sscanf (str, "%2d:%2d", &tim->tm_hour, &tim->tm_min) != 2)
                return 0;
        }
    }
    else
        return 0;

    return 1;
}

/* --------------------------------------------------------------------------------------------- */

static int
is_year (char *str, struct tm *tim)
{
    long year;

    if (!str)
        return 0;

    if (strchr (str, ':'))
        return 0;

    if (strlen (str) != 4)
        return 0;

    if (sscanf (str, "%ld", &year) != 1)
        return 0;

    if (year < 1900 || year > 3000)
        return 0;

    tim->tm_year = (int) (year - 1900);

    return 1;
}

/* --------------------------------------------------------------------------------------------- */
/*** public functions ****************************************************************************/
/* --------------------------------------------------------------------------------------------- */
/** Get current username
 *
 * @return g_malloc()ed string with the name of the currently logged in
 *         user ("anonymous" if uid is not registered in the system)
 */

char *
vfs_get_local_username (void)
{
    struct passwd *p_i;

    p_i = getpwuid (geteuid ());

    return (p_i && p_i->pw_name) ? g_strdup (p_i->pw_name) : g_strdup ("anonymous");    /* Unknown UID, strange */
}

/* --------------------------------------------------------------------------------------------- */
/**
 * Look up a user or group name from a uid/gid, maintaining a cache.
 * FIXME, for now it's a one-entry cache.
 * FIXME2, the "-993" is to reduce the chance of a hit on the first lookup.
 * This file should be modified for non-unix systems to do something
 * reasonable.
 */

/* --------------------------------------------------------------------------------------------- */

int
vfs_finduid (const char *uname)
{
    static int saveuid = -993;
    static char saveuname[TUNMLEN];
    static int my_uid = -993;

    struct passwd *pw;

    if (uname[0] != saveuname[0]        /* Quick test w/o proc call */
        || 0 != strncmp (uname, saveuname, TUNMLEN))
    {
        g_strlcpy (saveuname, uname, TUNMLEN);
        pw = getpwnam (uname);
        if (pw)
        {
            saveuid = pw->pw_uid;
        }
        else
        {
            saveuid = myuid;
        }
    }
    return saveuid;
}

/* --------------------------------------------------------------------------------------------- */

int
vfs_findgid (const char *gname)
{
    static int savegid = -993;
    static char savegname[TGNMLEN];
    static int my_gid = -993;

    struct group *gr;

    if (gname[0] != savegname[0]        /* Quick test w/o proc call */
        || 0 != strncmp (gname, savegname, TUNMLEN))
    {
        g_strlcpy (savegname, gname, TUNMLEN);
        gr = getgrnam (gname);
        if (gr)
        {
            savegid = gr->gr_gid;
        }
        else
        {
            savegid = mygid;
        }
    }
    return savegid;
}

/* --------------------------------------------------------------------------------------------- */
/**
 * Create a temporary file with a name resembling the original.
 * This is needed e.g. for local copies requested by extfs.
 * Some extfs scripts may look at the extension.
 * We also protect stupid scripts agains dangerous names.
 */

int
vfs_mkstemps (char **pname, const char *prefix, const char *param_basename)
{
    const char *p;
    char *suffix, *q;
    int shift;
    int fd;

    /* Strip directories */
    p = strrchr (param_basename, PATH_SEP);
    if (!p)
        p = param_basename;
    else
        p++;

    /* Protection against very long names */
    shift = strlen (p) - (MC_MAXPATHLEN - 16);
    if (shift > 0)
        p += shift;

    suffix = g_malloc (MC_MAXPATHLEN);

    /* Protection against unusual characters */
    q = suffix;
    while (*p && (*p != '#'))
    {
        if (strchr (".-_@", *p) || isalnum ((unsigned char) *p))
            *q++ = *p;
        p++;
    }
    *q = 0;

    fd = mc_mkstemps (pname, prefix, suffix);
    g_free (suffix);
    return fd;
}

/* --------------------------------------------------------------------------------------------- */
/**  Extract the hostname and username from the path
 *
 * Format of the path is [user@]hostname:port/remote-dir, e.g.:
 *
 * ftp://sunsite.unc.edu/pub/linux
 * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
 * ftp://tsx-11.mit.edu:8192/
 * ftp://joe@foo.edu:11321/private
 * ftp://joe:password@foo.se
 *
 * @param path is an input string to be parsed
 * @param default_port is an input default port
 * @param flags are parsing modifier flags (@see vfs_url_flags_t)
 *
 * @return g_malloc()ed url info.
 *         If the user is empty, e.g. ftp://@roxanne/private, and URL_USE_ANONYMOUS
 *         is not set, then the current login name is supplied.
 *         Return value is a g_malloc()ed structure with the pathname relative to the
 *         host.
 */

vfs_path_element_t *
vfs_url_split (const char *path, int default_port, vfs_url_flags_t flags)
{
    vfs_path_element_t *path_element;

    char *pcopy;
    const char *pend;
    char *dir, *colon, *inner_colon, *at, *rest;

    path_element = g_new0 (vfs_path_element_t, 1);
    path_element->port = default_port;

    pcopy = g_strdup (path);
    pend = pcopy + strlen (pcopy);
    dir = pcopy;

    if ((flags & URL_NOSLASH) == 0)
    {
        /* locate path component */
        while (*dir != PATH_SEP && *dir != '\0')
            dir++;
        if (*dir == '\0')
            path_element->path = g_strdup (PATH_SEP_STR);
        else
        {
            path_element->path = g_strdup (dir);
            *dir = '\0';
        }
    }

    /* search for any possible user */
    at = strrchr (pcopy, '@');

    /* We have a username */
    if (at == NULL)
        rest = pcopy;
    else
    {
        *at = '\0';
        inner_colon = strchr (pcopy, ':');
        if (inner_colon != NULL)
        {
            *inner_colon = '\0';
            inner_colon++;
            path_element->password = g_strdup (inner_colon);
        }

        if (*pcopy != '\0')
            path_element->user = g_strdup (pcopy);

        if (pend == at + 1)
            rest = at;
        else
            rest = at + 1;
    }

    if ((flags & URL_USE_ANONYMOUS) == 0)
        path_element->user = vfs_get_local_username ();

    /* Check if the host comes with a port spec, if so, chop it */
    if (*rest != '[')
        colon = strchr (rest, ':');
    else
    {
        colon = strchr (++rest, ']');
        if (colon != NULL)
        {
            colon[0] = '\0';
            colon[1] = '\0';
            colon++;
        }
        else
        {
            vfs_path_element_free (path_element);
            return NULL;
        }
    }

    if (colon != NULL)
    {
        *colon = '\0';
        if (sscanf (colon + 1, "%d", &path_element->port) == 1)
        {
            if (path_element->port <= 0 || path_element->port >= 65536)
                path_element->port = default_port;
        }
        else
            while (*(++colon) != '\0')
            {
                switch (*colon)
                {
                case 'C':
                    path_element->port = 1;
                    break;
                case 'r':
                    path_element->port = 2;
                    break;
                }
            }
    }

    path_element->host = g_strdup (rest);

    return path_element;
}

/* --------------------------------------------------------------------------------------------- */

int
vfs_split_text (char *p)
{
    char *original = p;
    int numcols;

    memset (columns, 0, sizeof (columns));

    for (numcols = 0; *p && numcols < MAXCOLS; numcols++)
    {
        while (*p == ' ' || *p == '\r' || *p == '\n')
        {
            *p = 0;
            p++;
        }
        columns[numcols] = p;
        column_ptr[numcols] = p - original;
        while (*p && *p != ' ' && *p != '\r' && *p != '\n')
            p++;
    }
    return numcols;
}

/* --------------------------------------------------------------------------------------------- */

gboolean
vfs_parse_filetype (const char *s, size_t * ret_skipped, mode_t * ret_type)
{
    mode_t type;

    switch (*s)
    {
    case 'd':
        type = S_IFDIR;
        break;
    case 'b':
        type = S_IFBLK;
        break;
    case 'c':
        type = S_IFCHR;
        break;
    case 'l':
        type = S_IFLNK;
        break;
#ifdef S_IFSOCK
    case 's':
        type = S_IFSOCK;
        break;
#else
    case 's':
        type = S_IFIFO;
        break;
#endif
#ifdef S_IFDOOR                 /* Solaris door */
    case 'D':
        type = S_IFDOOR;
        break;
#else
    case 'D':
        type = S_IFIFO;
        break;
#endif
    case 'p':
        type = S_IFIFO;
        break;
#ifdef S_IFNAM                  /* Special named files */
    case 'n':
        type = S_IFNAM;
        break;
#else
    case 'n':
        type = S_IFREG;
        break;
#endif
    case 'm':                  /* Don't know what these are :-) */
    case '-':
    case '?':
        type = S_IFREG;
        break;
    default:
        return FALSE;
    }

    *ret_type = type;
    *ret_skipped = 1;
    return TRUE;
}

/* --------------------------------------------------------------------------------------------- */

gboolean
vfs_parse_fileperms (const char *s, size_t * ret_skipped, mode_t * ret_perms)
{
    const char *p;
    mode_t perms;

    p = s;
    perms = 0;

    switch (*p++)
    {
    case '-':
        break;
    case 'r':
        perms |= S_IRUSR;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'w':
        perms |= S_IWUSR;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'S':
        perms |= S_ISUID;
        break;
    case 's':
        perms |= S_IXUSR | S_ISUID;
        break;
    case 'x':
        perms |= S_IXUSR;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'r':
        perms |= S_IRGRP;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'w':
        perms |= S_IWGRP;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'S':
        perms |= S_ISGID;
        break;
    case 'l':
        perms |= S_ISGID;
        break;                  /* found on Solaris */
    case 's':
        perms |= S_IXGRP | S_ISGID;
        break;
    case 'x':
        perms |= S_IXGRP;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'r':
        perms |= S_IROTH;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'w':
        perms |= S_IWOTH;
        break;
    default:
        return FALSE;
    }
    switch (*p++)
    {
    case '-':
        break;
    case 'T':
        perms |= S_ISVTX;
        break;
    case 't':
        perms |= S_IXOTH | S_ISVTX;
        break;
    case 'x':
        perms |= S_IXOTH;
        break;
    default:
        return FALSE;
    }
    if (*p == '+')
    {                           /* ACLs on Solaris, HP-UX and others */
        p++;
    }

    *ret_skipped = p - s;
    *ret_perms = perms;
    return TRUE;
}

/* --------------------------------------------------------------------------------------------- */

gboolean
vfs_parse_filemode (const char *s, size_t * ret_skipped, mode_t * ret_mode)
{
    const char *p;
    mode_t type, perms;
    size_t skipped;

    p = s;

    if (!vfs_parse_filetype (p, &skipped, &type))
        return FALSE;
    p += skipped;

    if (!vfs_parse_fileperms (p, &skipped, &perms))
        return FALSE;
    p += skipped;

    *ret_skipped = p - s;
    *ret_mode = type | perms;
    return TRUE;
}

/* --------------------------------------------------------------------------------------------- */

gboolean
vfs_parse_raw_filemode (const char *s, size_t * ret_skipped, mode_t * ret_mode)
{
    const char *p;
    mode_t remote_type = 0, local_type, perms = 0;

    p = s;

    /* isoctal */
    while (*p >= '0' && *p <= '7')
    {
        perms *= 010;
        perms += (*p - '0');
        ++p;
    }

    if (*p++ != ' ')
        return FALSE;

    while (*p >= '0' && *p <= '7')
    {
        remote_type *= 010;
        remote_type += (*p - '0');
        ++p;
    }

    if (*p++ != ' ')
        return FALSE;

    /* generated with:
       $ perl -e 'use Fcntl ":mode";
       my @modes = (S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFREG);
       foreach $t (@modes) { printf ("%o\n", $t); };'
       TODO: S_IFDOOR, S_IFIFO, S_IFSOCK (if supported by os)
       (see vfs_parse_filetype)
     */

    switch (remote_type)
    {
    case 020000:
        local_type = S_IFCHR;
        break;
    case 040000:
        local_type = S_IFDIR;
        break;
    case 060000:
        local_type = S_IFBLK;
        break;
    case 0120000:
        local_type = S_IFLNK;
        break;
    case 0100000:
    default:                   /* don't know what is it */
        local_type = S_IFREG;
        break;
    }

    *ret_skipped = p - s;
    *ret_mode = local_type | perms;
    return TRUE;
}

/* --------------------------------------------------------------------------------------------- */
/** This function parses from idx in the columns[] array */

int
vfs_parse_filedate (int idx, time_t * t)
{
    char *p;
    struct tm tim;
    int d[3];
    int got_year = 0;
    int l10n = 0;               /* Locale's abbreviated month name */
    time_t current_time;
    struct tm *local_time;

    /* Let's setup default time values */
    current_time = time (NULL);
    local_time = localtime (&current_time);
    tim.tm_mday = local_time->tm_mday;
    tim.tm_mon = local_time->tm_mon;
    tim.tm_year = local_time->tm_year;

    tim.tm_hour = 0;
    tim.tm_min = 0;
    tim.tm_sec = 0;
    tim.tm_isdst = -1;          /* Let mktime() try to guess correct dst offset */

    p = columns[idx++];

    /* We eat weekday name in case of extfs */
    if (is_week (p, &tim))
        p = columns[idx++];

    /* Month name */
    if (is_month (p, &tim))
    {
        /* And we expect, it followed by day number */
        if (is_num (idx))
            tim.tm_mday = (int) atol (columns[idx++]);
        else
            return 0;           /* No day */

    }
    else
    {
        /* We expect:
           3 fields max or we'll see oddities with certain file names.
           So both year and time is not allowed.
           Mon DD hh:mm[:ss]
           Mon DD YYYY
           But in case of extfs we allow these date formats:
           MM-DD-YY hh:mm[:ss]
           where Mon is Jan-Dec, DD, MM, YY two digit day, month, year,
           YYYY four digit year, hh, mm, ss two digit hour, minute or second. */

        /* Special case with MM-DD-YY or MM-DD-YYYY */
        if (is_dos_date (p))
        {
            p[2] = p[5] = '-';

            if (sscanf (p, "%2d-%2d-%d", &d[0], &d[1], &d[2]) == 3)
            {
                /* Months are zero based */
                if (d[0] > 0)
                    d[0]--;

                if (d[2] > 1900)
                {
                    d[2] -= 1900;
                }
                else
                {
                    /* Y2K madness */
                    if (d[2] < 70)
                        d[2] += 100;
                }

                tim.tm_mon = d[0];
                tim.tm_mday = d[1];
                tim.tm_year = d[2];
                got_year = 1;
            }
            else
                return 0;       /* sscanf failed */
        }
        else
        {
            /* Locale's abbreviated month name followed by day number */
            if (is_localized_month (p) && (is_num (idx++)))
                l10n = 1;
            else
                return 0;       /* unsupported format */
        }
    }

    /* Here we expect to find time or year */
    if (is_num (idx) && (is_time (columns[idx], &tim) || (got_year = is_year (columns[idx], &tim))))
        idx++;
    else
        return 0;               /* Neither time nor date */

    /*
     * If the date is less than 6 months in the past, it is shown without year
     * other dates in the past or future are shown with year but without time
     * This does not check for years before 1900 ... I don't know, how
     * to represent them at all
     */
    if (!got_year && local_time->tm_mon < 6
        && local_time->tm_mon < tim.tm_mon && tim.tm_mon - local_time->tm_mon >= 6)

        tim.tm_year--;

    *t = mktime (&tim);
    if (l10n || (*t < 0))
        *t = 0;
    return idx;
}

/* --------------------------------------------------------------------------------------------- */

int
vfs_parse_ls_lga (const char *p, struct stat *s, char **filename, char **linkname)
{
    int idx, idx2, num_cols;
    int i;
    char *p_copy = NULL;
    char *t = NULL;
    const char *line = p;
    size_t skipped;

    if (strncmp (p, "total", 5) == 0)
        return 0;

    if (!vfs_parse_filetype (p, &skipped, &s->st_mode))
        goto error;
    p += skipped;

    if (*p == ' ')              /* Notwell 4 */
        p++;
    if (*p == '[')
    {
        if (strlen (p) <= 8 || p[8] != ']')
            goto error;
        /* Should parse here the Notwell permissions :) */
        if (S_ISDIR (s->st_mode))
            s->st_mode |= (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IXUSR | S_IXGRP | S_IXOTH);
        else
            s->st_mode |= (S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR);
        p += 9;
    }
    else
    {
        size_t lc_skipped;
        mode_t perms;

        if (!vfs_parse_fileperms (p, &lc_skipped, &perms))
            goto error;
        p += lc_skipped;
        s->st_mode |= perms;
    }

    p_copy = g_strdup (p);
    num_cols = vfs_split_text (p_copy);

    s->st_nlink = atol (columns[0]);
    if (s->st_nlink <= 0)
        goto error;

    if (!is_num (1))
        s->st_uid = vfs_finduid (columns[1]);
    else
        s->st_uid = (uid_t) atol (columns[1]);

    /* Mhm, the ls -lg did not produce a group field */
    for (idx = 3; idx <= 5; idx++)
        if (is_month (columns[idx], NULL) || is_week (columns[idx], NULL)
            || is_dos_date (columns[idx]) || is_localized_month (columns[idx]))
            break;

    if (idx == 6 || (idx == 5 && !S_ISCHR (s->st_mode) && !S_ISBLK (s->st_mode)))
        goto error;

    /* We don't have gid */
    if (idx == 3 || (idx == 4 && (S_ISCHR (s->st_mode) || S_ISBLK (s->st_mode))))
        idx2 = 2;
    else
    {
        /* We have gid field */
        if (is_num (2))
            s->st_gid = (gid_t) atol (columns[2]);
        else
            s->st_gid = vfs_findgid (columns[2]);
        idx2 = 3;
    }

    /* This is device */
    if (S_ISCHR (s->st_mode) || S_ISBLK (s->st_mode))
    {
        int maj, min;

        /* Corner case: there is no whitespace(s) between maj & min */
        if (!is_num (idx2) && idx2 == 2)
        {
            if (!is_num (++idx2) || sscanf (columns[idx2], " %d,%d", &maj, &min) != 2)
                goto error;
        }
        else
        {
            if (!is_num (idx2) || sscanf (columns[idx2], " %d,", &maj) != 1)
                goto error;

            if (!is_num (++idx2) || sscanf (columns[idx2], " %d", &min) != 1)
                goto error;
        }
#ifdef HAVE_STRUCT_STAT_ST_RDEV
        s->st_rdev = makedev (maj, min);
#endif
        s->st_size = 0;

    }
    else
    {
        /* Common file size */
        if (!is_num (idx2))
            goto error;

#ifdef HAVE_ATOLL
        s->st_size = (off_t) atoll (columns[idx2]);
#else
        s->st_size = (off_t) atof (columns[idx2]);
#endif
#ifdef HAVE_STRUCT_STAT_ST_RDEV
        s->st_rdev = 0;
#endif
    }

    idx = vfs_parse_filedate (idx, &s->st_mtime);
    if (!idx)
        goto error;
    /* Use resulting time value */
    s->st_atime = s->st_ctime = s->st_mtime;
    /* s->st_dev and s->st_ino must be initialized by vfs_s_new_inode () */
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
    s->st_blksize = 512;
#endif
#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
    s->st_blocks = (s->st_size + 511) / 512;
#endif

    for (i = idx + 1, idx2 = 0; i < num_cols; i++)
        if (strcmp (columns[i], "->") == 0)
        {
            idx2 = i;
            break;
        }

    if (((S_ISLNK (s->st_mode) || (num_cols == idx + 3 && s->st_nlink > 1)))    /* Maybe a hardlink? (in extfs) */
        && idx2)
    {

        if (filename)
        {
            *filename = g_strndup (p + column_ptr[idx], column_ptr[idx2] - column_ptr[idx] - 1);
        }
        if (linkname)
        {
            t = g_strdup (p + column_ptr[idx2 + 1]);
            *linkname = t;
        }
    }
    else
    {
        /* Extract the filename from the string copy, not from the columns
         * this way we have a chance of entering hidden directories like ". ."
         */
        if (filename)
        {
            /*
             * filename = g_strdup (columns [idx++]);
             */

            t = g_strdup (p + column_ptr[idx]);
            *filename = t;
        }
        if (linkname)
            *linkname = NULL;
    }

    if (t)
    {
        int p2 = strlen (t);
        if ((--p2 > 0) && (t[p2] == '\r' || t[p2] == '\n'))
            t[p2] = 0;
        if ((--p2 > 0) && (t[p2] == '\r' || t[p2] == '\n'))
            t[p2] = 0;
    }

    g_free (p_copy);
    return 1;

  error:
    {
        static int errorcount = 0;

        if (++errorcount < 5)
        {
            message (D_ERROR, _("Cannot parse:"), "%s", (p_copy && *p_copy) ? p_copy : line);
        }
        else if (errorcount == 5)
            message (D_ERROR, MSG_ERROR, _("More parsing errors will be ignored."));
    }

    g_free (p_copy);
    return 0;
}

/* --------------------------------------------------------------------------------------------- */

void
vfs_die (const char *m)
{
    message (D_ERROR, _("Internal error:"), "%s", m);
    exit (EXIT_FAILURE);
}

/* --------------------------------------------------------------------------------------------- */

char *
vfs_get_password (const char *msg)
{
    return input_dialog (msg, _("Password:"), MC_HISTORY_VFS_PASSWORD, INPUT_PASSWORD);
}

/* --------------------------------------------------------------------------------------------- */