lib/vfs/utilvfs.c

   1 /*
   2    Utilities for VFS modules.
   3
   4    Copyright (C) 1988-2016
   5    Free Software Foundation, Inc.
   6
   7    Copyright (C) 1995, 1996 Miguel de Icaza
   8
   9    This file is part of the Midnight Commander.
  10
  11    The Midnight Commander is free software: you can redistribute it
  12    and/or modify it under the terms of the GNU General Public License as
  13    published by the Free Software Foundation, either version 3 of the License,
  14    or (at your option) any later version.
  15
  16    The Midnight Commander is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 /**
  26  * \file
  27  * \brief Source: Utilities for VFS modules
  28  * \author Miguel de Icaza
  29  * \date 1995, 1996
  30  */
  31
  32 #include <config.h>
  33
  34 #include <ctype.h>
  35 #include <sys/types.h>
  36 #include <pwd.h>
  37 #include <grp.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40
  41 #include "lib/global.h"
  42 #include "lib/unixcompat.h"
  43 #include "lib/util.h"           /* mc_mkstemps() */
  44 #include "lib/widget.h"         /* message() */
  45 #include "lib/strutil.h"        /* INVALID_CONV */
  46
  47 #include "vfs.h"
  48 #include "utilvfs.h"
  49
  50 /*** global variables ****************************************************************************/
  51
  52 /*** file scope macro definitions ****************************************************************/
  53
  54 #ifndef TUNMLEN
  55 #define TUNMLEN 256
  56 #endif
  57 #ifndef TGNMLEN
  58 #define TGNMLEN 256
  59 #endif
  60
  61 #define MC_HISTORY_VFS_PASSWORD       "mc.vfs.password"
  62
  63 /*
  64  * FIXME2, the "-993" is to reduce the chance of a hit on the first lookup.
  65  */
  66 #define GUID_DEFAULT_CONST -993
  67
  68 /*** file scope type declarations ****************************************************************/
  69
  70 /*** file scope variables ************************************************************************/
  71
  72 /*** file scope functions ************************************************************************/
  73 /* --------------------------------------------------------------------------------------------- */
  74
  75
  76 /* --------------------------------------------------------------------------------------------- */
  77 /*** public functions ****************************************************************************/
  78 /* --------------------------------------------------------------------------------------------- */
  79 /** Get current username
  80  *
  81  * @return g_malloc()ed string with the name of the currently logged in
  82  *         user ("anonymous" if uid is not registered in the system)
  83  */
  84
  85 char *
  86 vfs_get_local_username (void)
  87 {
  88     struct passwd *p_i;
  89
  90     p_i = getpwuid (geteuid ());
  91
  92     return (p_i && p_i->pw_name) ? g_strdup (p_i->pw_name) : g_strdup ("anonymous");    /* Unknown UID, strange */
  93 }
  94
  95 /* --------------------------------------------------------------------------------------------- */
  96 /**
  97  * Look up a user or group name from a uid/gid, maintaining a cache.
  98  * FIXME, for now it's a one-entry cache.
  99  * This file should be modified for non-unix systems to do something
 100  * reasonable.
 101  */
 102
 103 /* --------------------------------------------------------------------------------------------- */
 104
 105 int
 106 vfs_finduid (const char *uname)
 107 {
 108     static int saveuid = GUID_DEFAULT_CONST;
 109     static char saveuname[TUNMLEN] = "\0";
 110
 111     if (uname[0] != saveuname[0]        /* Quick test w/o proc call */
 112         || 0 != strncmp (uname, saveuname, TUNMLEN))
 113     {
 114         struct passwd *pw;
 115
 116         g_strlcpy (saveuname, uname, TUNMLEN);
 117         pw = getpwnam (uname);
 118         if (pw)
 119         {
 120             saveuid = pw->pw_uid;
 121         }
 122         else
 123         {
 124             static int my_uid = GUID_DEFAULT_CONST;
 125
 126             if (my_uid < 0)
 127                 my_uid = getuid ();
 128
 129             saveuid = my_uid;
 130         }
 131     }
 132     return saveuid;
 133 }
 134
 135 /* --------------------------------------------------------------------------------------------- */
 136
 137 int
 138 vfs_findgid (const char *gname)
 139 {
 140     static int savegid = GUID_DEFAULT_CONST;
 141     static char savegname[TGNMLEN] = "\0";
 142
 143
 144     if (gname[0] != savegname[0]        /* Quick test w/o proc call */
 145         || 0 != strncmp (gname, savegname, TUNMLEN))
 146     {
 147         struct group *gr;
 148
 149         g_strlcpy (savegname, gname, TUNMLEN);
 150         gr = getgrnam (gname);
 151         if (gr)
 152         {
 153             savegid = gr->gr_gid;
 154         }
 155         else
 156         {
 157             static int my_gid = GUID_DEFAULT_CONST;
 158
 159             if (my_gid < 0)
 160                 my_gid = getgid ();
 161
 162             savegid = my_gid;
 163         }
 164     }
 165     return savegid;
 166 }
 167
 168 /* --------------------------------------------------------------------------------------------- */
 169 /**
 170  * Create a temporary file with a name resembling the original.
 171  * This is needed e.g. for local copies requested by extfs.
 172  * Some extfs scripts may look at the extension.
 173  * We also protect stupid scripts agains dangerous names.
 174  */
 175
 176 int
 177 vfs_mkstemps (vfs_path_t ** pname_vpath, const char *prefix, const char *param_basename)
 178 {
 179     const char *p;
 180     char *suffix, *q;
 181     int shift;
 182     int fd;
 183
 184     /* Strip directories */
 185     p = strrchr (param_basename, PATH_SEP);
 186     if (!p)
 187         p = param_basename;
 188     else
 189         p++;
 190
 191     /* Protection against very long names */
 192     shift = strlen (p) - (MC_MAXPATHLEN - 16);
 193     if (shift > 0)
 194         p += shift;
 195
 196     suffix = g_malloc (MC_MAXPATHLEN);
 197
 198     /* Protection against unusual characters */
 199     q = suffix;
 200     while (*p && (*p != '#'))
 201     {
 202         if (strchr (".-_@", *p) || isalnum ((unsigned char) *p))
 203             *q++ = *p;
 204         p++;
 205     }
 206     *q = 0;
 207
 208     fd = mc_mkstemps (pname_vpath, prefix, suffix);
 209     g_free (suffix);
 210     return fd;
 211 }
 212
 213 /* --------------------------------------------------------------------------------------------- */
 214 /**  Extract the hostname and username from the path
 215  *
 216  * Format of the path is [user@]hostname:port/remote-dir, e.g.:
 217  *
 218  * ftp://sunsite.unc.edu/pub/linux
 219  * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
 220  * ftp://tsx-11.mit.edu:8192/
 221  * ftp://joe@foo.edu:11321/private
 222  * ftp://joe:password@foo.se
 223  *
 224  * @param path is an input string to be parsed
 225  * @param default_port is an input default port
 226  * @param flags are parsing modifier flags (@see vfs_url_flags_t)
 227  *
 228  * @return g_malloc()ed url info.
 229  *         If the user is empty, e.g. ftp://@roxanne/private, and URL_USE_ANONYMOUS
 230  *         is not set, then the current login name is supplied.
 231  *         Return value is a g_malloc()ed structure with the pathname relative to the
 232  *         host.
 233  */
 234
 235 vfs_path_element_t *
 236 vfs_url_split (const char *path, int default_port, vfs_url_flags_t flags)
 237 {
 238     vfs_path_element_t *path_element;
 239
 240     char *pcopy;
 241     size_t pcopy_len;
 242     const char *pend;
 243     char *dir, *colon, *at, *rest;
 244
 245     path_element = g_new0 (vfs_path_element_t, 1);
 246     path_element->port = default_port;
 247
 248     pcopy_len = strlen (path);
 249     pcopy = g_strndup (path, pcopy_len);
 250     pend = pcopy + pcopy_len;
 251     dir = pcopy;
 252
 253     if ((flags & URL_NOSLASH) == 0)
 254     {
 255         /* locate path component */
 256         while (!IS_PATH_SEP (*dir) && *dir != '\0')
 257             dir++;
 258         if (*dir == '\0')
 259             path_element->path = g_strdup (PATH_SEP_STR);
 260         else
 261         {
 262             path_element->path = g_strndup (dir, pcopy_len - (size_t) (dir - pcopy));
 263             *dir = '\0';
 264         }
 265     }
 266
 267     /* search for any possible user */
 268     at = strrchr (pcopy, '@');
 269
 270     /* We have a username */
 271     if (at == NULL)
 272         rest = pcopy;
 273     else
 274     {
 275         char *inner_colon;
 276
 277         *at = '\0';
 278         inner_colon = strchr (pcopy, ':');
 279         if (inner_colon != NULL)
 280         {
 281             *inner_colon = '\0';
 282             inner_colon++;
 283             path_element->password = g_strdup (inner_colon);
 284         }
 285
 286         if (*pcopy != '\0')
 287             path_element->user = g_strdup (pcopy);
 288
 289         if (pend == at + 1)
 290             rest = at;
 291         else
 292             rest = at + 1;
 293     }
 294
 295     if ((flags & URL_USE_ANONYMOUS) == 0)
 296         path_element->user = vfs_get_local_username ();
 297
 298     /* Check if the host comes with a port spec, if so, chop it */
 299     if (*rest != '[')
 300         colon = strchr (rest, ':');
 301     else
 302     {
 303         colon = strchr (++rest, ']');
 304         if (colon != NULL)
 305         {
 306             colon[0] = '\0';
 307             colon[1] = '\0';
 308             colon++;
 309         }
 310         else
 311         {
 312             vfs_path_element_free (path_element);
 313             return NULL;
 314         }
 315     }
 316
 317     if (colon != NULL)
 318     {
 319         *colon = '\0';
 320         /* cppcheck-suppress invalidscanf */
 321         if (sscanf (colon + 1, "%d", &path_element->port) == 1)
 322         {
 323             if (path_element->port <= 0 || path_element->port >= 65536)
 324                 path_element->port = default_port;
 325         }
 326         else
 327             while (*(++colon) != '\0')
 328             {
 329                 switch (*colon)
 330                 {
 331                 case 'C':
 332                     path_element->port = 1;
 333                     break;
 334                 case 'r':
 335                     path_element->port = 2;
 336                     break;
 337                 default:
 338                     break;
 339                 }
 340             }
 341     }
 342
 343     path_element->host = g_strdup (rest);
 344 #ifdef HAVE_CHARSET
 345     path_element->dir.converter = INVALID_CONV;
 346 #endif
 347
 348     return path_element;
 349 }
 350
 351 /* --------------------------------------------------------------------------------------------- */
 352
 353 void
 354 vfs_die (const char *m)
 355 {
 356     message (D_ERROR, _("Internal error:"), "%s", m);
 357     exit (EXIT_FAILURE);
 358 }
 359
 360 /* --------------------------------------------------------------------------------------------- */
 361
 362 char *
 363 vfs_get_password (const char *msg)
 364 {
 365     return input_dialog (msg, _("Password:"), MC_HISTORY_VFS_PASSWORD, INPUT_PASSWORD,
 366                          INPUT_COMPLETE_NONE);
 367 }
 368
 369 /* --------------------------------------------------------------------------------------------- */