epan/filesystem.c

   1 /* filesystem.c
   2  * Filesystem utility routines
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 /*
  30  * Required with GNU libc to get dladdr().
  31  * We define it here because <dlfcn.h> apparently gets included by
  32  * one of the headers we include below.
  33  */
  34 #define _GNU_SOURCE
  35
  36 #ifdef HAVE_DIRENT_H
  37 #include <dirent.h>
  38 #endif
  39
  40 #include <stdio.h>
  41 #include <ctype.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <errno.h>
  45
  46 #include <glib.h>
  47
  48 #ifdef HAVE_UNISTD_H
  49 #include <unistd.h>
  50 #endif
  51
  52 #ifdef HAVE_FCNTL_H
  53 #include <fcntl.h>
  54 #endif
  55
  56 #ifdef HAVE_SYS_STAT_H
  57 #include <sys/stat.h>
  58 #endif
  59
  60 #ifdef _WIN32
  61 #include <windows.h>
  62 #include <tchar.h>
  63 #include <shlobj.h>
  64 #include <wsutil/unicode-utils.h>
  65 #else /* _WIN32 */
  66 #ifdef DLADDR_FINDS_EXECUTABLE_PATH
  67 #include <dlfcn.h>
  68 #endif /* DLADDR_FINDS_EXECUTABLE_PATH */
  69 #include <pwd.h>
  70 #endif /* _WIN32 */
  71
  72 #include "filesystem.h"
  73 #include "report_err.h"
  74 #include <wsutil/privileges.h>
  75 #include <wsutil/file_util.h>
  76
  77 #include <wiretap/wtap.h>       /* for WTAP_ERR_SHORT_WRITE */
  78
  79 #define PROFILES_DIR    "profiles"
  80 #define PLUGINS_DIR_NAME    "plugins"
  81
  82 #define U3_MY_CAPTURES  "\\My Captures"
  83
  84 char *persconffile_dir = NULL;
  85 char *persdatafile_dir = NULL;
  86 char *persconfprofile = NULL;
  87
  88 static gboolean do_store_persconffiles = FALSE;
  89 static GHashTable *profile_files = NULL;
  90
  91 /*
  92  * Given a pathname, return a pointer to the last pathname separator
  93  * character in the pathname, or NULL if the pathname contains no
  94  * separators.
  95  */
  96 char *
  97 find_last_pathname_separator(const char *path)
  98 {
  99         char *separator;
 100
 101 #ifdef _WIN32
 102         char c;
 103
 104         /*
 105          * We have to scan for '\' or '/'.
 106          * Get to the end of the string.
 107          */
 108         separator = strchr(path, '\0');         /* points to ending '\0' */
 109         while (separator > path) {
 110                 c = *--separator;
 111                 if (c == '\\' || c == '/')
 112                         return separator;       /* found it */
 113         }
 114
 115         /*
 116          * OK, we didn't find any, so no directories - but there might
 117          * be a drive letter....
 118          */
 119         return strchr(path, ':');
 120 #else
 121         separator = strrchr(path, '/');
 122 #endif
 123         return separator;
 124 }
 125
 126 /*
 127  * Given a pathname, return the last component.
 128  */
 129 const char *
 130 get_basename(const char *path)
 131 {
 132         const char *filename;
 133
 134         g_assert(path != NULL);
 135         filename = find_last_pathname_separator(path);
 136         if (filename == NULL) {
 137                 /*
 138                  * There're no directories, drive letters, etc. in the
 139                  * name; the pathname *is* the file name.
 140                  */
 141                 filename = path;
 142         } else {
 143                 /*
 144                  * Skip past the pathname or drive letter separator.
 145                  */
 146                 filename++;
 147         }
 148         return filename;
 149 }
 150
 151 /*
 152  * Given a pathname, return a string containing everything but the
 153  * last component.  NOTE: this overwrites the pathname handed into
 154  * it....
 155  */
 156 char *
 157 get_dirname(char *path)
 158 {
 159         char *separator;
 160
 161         g_assert(path != NULL);
 162         separator = find_last_pathname_separator(path);
 163         if (separator == NULL) {
 164                 /*
 165                  * There're no directories, drive letters, etc. in the
 166                  * name; there is no directory path to return.
 167                  */
 168                 return NULL;
 169         }
 170
 171         /*
 172          * Get rid of the last pathname separator and the final file
 173          * name following it.
 174          */
 175         *separator = '\0';
 176
 177         /*
 178          * "path" now contains the pathname of the directory containing
 179          * the file/directory to which it referred.
 180          */
 181         return path;
 182 }
 183
 184 /*
 185  * Given a pathname, return:
 186  *
 187  *      the errno, if an attempt to "stat()" the file fails;
 188  *
 189  *      EISDIR, if the attempt succeeded and the file turned out
 190  *      to be a directory;
 191  *
 192  *      0, if the attempt succeeded and the file turned out not
 193  *      to be a directory.
 194  */
 195
 196 /*
 197  * Visual C++ on Win32 systems doesn't define these.  (Old UNIX systems don't
 198  * define them either.)
 199  *
 200  * Visual C++ on Win32 systems doesn't define S_IFIFO, it defines _S_IFIFO.
 201  */
 202 #ifndef S_ISREG
 203 #define S_ISREG(mode)   (((mode) & S_IFMT) == S_IFREG)
 204 #endif
 205 #ifndef S_IFIFO
 206 #define S_IFIFO _S_IFIFO
 207 #endif
 208 #ifndef S_ISFIFO
 209 #define S_ISFIFO(mode)  (((mode) & S_IFMT) == S_IFIFO)
 210 #endif
 211 #ifndef S_ISDIR
 212 #define S_ISDIR(mode)   (((mode) & S_IFMT) == S_IFDIR)
 213 #endif
 214
 215 int
 216 test_for_directory(const char *path)
 217 {
 218         struct stat statb;
 219
 220         if (ws_stat(path, &statb) < 0)
 221                 return errno;
 222
 223         if (S_ISDIR(statb.st_mode))
 224                 return EISDIR;
 225         else
 226                 return 0;
 227 }
 228
 229 int
 230 test_for_fifo(const char *path)
 231 {
 232         struct stat statb;
 233
 234         if (ws_stat(path, &statb) < 0)
 235                 return errno;
 236
 237         if (S_ISFIFO(statb.st_mode))
 238                 return ESPIPE;
 239         else
 240                 return 0;
 241 }
 242
 243 /*
 244  * Directory from which the executable came.
 245  */
 246 static char *progfile_dir;
 247
 248 /*
 249  * TRUE if we're running from the build directory and we aren't running
 250  * with special privileges.
 251  */
 252 static gboolean running_in_build_directory_flag = FALSE;
 253
 254 /*
 255  * Get the pathname of the directory from which the executable came,
 256  * and save it for future use.  Returns NULL on success, and a
 257  * g_mallocated string containing an error on failure.
 258  */
 259 char *
 260 init_progfile_dir(const char *arg0
 261 #ifdef _WIN32
 262         _U_
 263 #endif
 264 , int (*main_addr)(int, char **)
 265 #if defined(_WIN32) || !defined(DLADDR_FINDS_EXECUTABLE_PATH)
 266         _U_
 267 #endif
 268 )
 269 {
 270 #ifdef _WIN32
 271         TCHAR prog_pathname_w[_MAX_PATH+2];
 272         char *prog_pathname;
 273         DWORD error;
 274         TCHAR *msg_w;
 275         guchar *msg;
 276         size_t msglen;
 277
 278         /*
 279          * Attempt to get the full pathname of the currently running
 280          * program.
 281          */
 282         if (GetModuleFileName(NULL, prog_pathname_w, G_N_ELEMENTS(prog_pathname_w)) != 0 && GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
 283                 /*
 284                  * XXX - Should we use g_utf16_to_utf8(), as in
 285                  * getenv_utf8()?
 286                  */
 287                 prog_pathname = utf_16to8(prog_pathname_w);
 288                 /*
 289                  * We got it; strip off the last component, which would be
 290                  * the file name of the executable, giving us the pathname
 291                  * of the directory where the executable resides.
 292                  */
 293                 progfile_dir = g_path_get_dirname(prog_pathname);
 294                 if (progfile_dir != NULL) {
 295                         return NULL;    /* we succeeded */
 296                 } else {
 297                         /*
 298                          * OK, no. What do we do now?
 299                          */
 300                         return g_strdup_printf("No \\ in executable pathname \"%s\"",
 301                             prog_pathname);
 302                 }
 303         } else {
 304                 /*
 305                  * Oh, well.  Return an indication of the error.
 306                  */
 307                 error = GetLastError();
 308                 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 309                     NULL, error, 0, (LPTSTR) &msg_w, 0, NULL) == 0) {
 310                         /*
 311                          * Gak.  We can't format the message.
 312                          */
 313                         return g_strdup_printf("GetModuleFileName failed: %u (FormatMessage failed: %u)",
 314                             error, GetLastError());
 315                 }
 316                 msg = utf_16to8(msg_w);
 317                 LocalFree(msg_w);
 318                 /*
 319                  * "FormatMessage()" "helpfully" sticks CR/LF at the
 320                  * end of the message.  Get rid of it.
 321                  */
 322                 msglen = strlen(msg);
 323                 if (msglen >= 2) {
 324                         msg[msglen - 1] = '\0';
 325                         msg[msglen - 2] = '\0';
 326                 }
 327                 return g_strdup_printf("GetModuleFileName failed: %s (%u)",
 328                     msg, error);
 329         }
 330 #else
 331 #ifdef DLADDR_FINDS_EXECUTABLE_PATH
 332         Dl_info info;
 333 #endif
 334         char *prog_pathname;
 335         char *curdir;
 336         long path_max;
 337         char *pathstr;
 338         char *path_start, *path_end;
 339         size_t path_component_len;
 340         char *retstr;
 341         char *path;
 342         char *dir_end;
 343
 344         /*
 345          * Check whether WIRESHARK_RUN_FROM_BUILD_DIRECTORY is set in the
 346          * environment; if so, set running_in_build_directory_flag if we
 347          * weren't started with special privileges.  (If we were started
 348          * with special privileges, it's not safe to allow the user to point
 349          * us to some other directory; running_in_build_directory_flag, when
 350          * set, causes us to look for plugins and the like in the build
 351          * directory.)
 352          */
 353         if (getenv("WIRESHARK_RUN_FROM_BUILD_DIRECTORY") != NULL
 354             && !started_with_special_privs())
 355                 running_in_build_directory_flag = TRUE;
 356
 357 #ifdef DLADDR_FINDS_EXECUTABLE_PATH
 358         /*
 359          * Try to use dladdr() to find the pathname of the executable.
 360          * dladdr() is not guaranteed to give you anything better than
 361          * argv[0] (i.e., it might not contain a / at all, much less
 362          * being an absolute path), and doesn't appear to do so on
 363          * Linux, but on other platforms it could give you an absolute
 364          * path and obviate the need for us to determine the absolute
 365          * path.
 366          */
 367         if (dladdr((void *)main_addr, &info))
 368                 arg0 = info.dli_fname;
 369 #endif
 370         /*
 371          * Try to figure out the directory in which the currently running
 372          * program resides, given something purporting to be the executable
 373          * name (from dladdr() or from the argv[0] it was started with.
 374          * That might be the absolute path of the program, or a path relative
 375          * to the current directory of the process that started it, or
 376          * just a name for the program if it was started from the command
 377          * line and was searched for in $PATH.  It's not guaranteed to be
 378          * any of those, however, so there are no guarantees....
 379          */
 380         if (arg0[0] == '/') {
 381                 /*
 382                  * It's an absolute path.
 383                  */
 384                 prog_pathname = g_strdup(arg0);
 385         } else if (strchr(arg0, '/') != NULL) {
 386                 /*
 387                  * It's a relative path, with a directory in it.
 388                  * Get the current directory, and combine it
 389                  * with that directory.
 390                  */
 391                 path_max = pathconf(".", _PC_PATH_MAX);
 392                 if (path_max == -1) {
 393                         /*
 394                          * We have no idea how big a buffer to
 395                          * allocate for the current directory.
 396                          */
 397                         return g_strdup_printf("pathconf failed: %s\n",
 398                             strerror(errno));
 399                 }
 400                 curdir = (char *)g_malloc(path_max);
 401                 if (getcwd(curdir, path_max) == NULL) {
 402                         /*
 403                          * It failed - give up, and just stick
 404                          * with DATAFILE_DIR.
 405                          */
 406                         g_free(curdir);
 407                         return g_strdup_printf("getcwd failed: %s\n",
 408                             strerror(errno));
 409                 }
 410                 path = g_strdup_printf("%s/%s", curdir, arg0);
 411                 g_free(curdir);
 412                 prog_pathname = path;
 413         } else {
 414                 /*
 415                  * It's just a file name.
 416                  * Search the path for a file with that name
 417                  * that's executable.
 418                  */
 419                 prog_pathname = NULL;   /* haven't found it yet */
 420                 pathstr = getenv("PATH");
 421                 path_start = pathstr;
 422                 if (path_start != NULL) {
 423                         while (*path_start != '\0') {
 424                                 path_end = strchr(path_start, ':');
 425                                 if (path_end == NULL)
 426                                         path_end = path_start + strlen(path_start);
 427                                 path_component_len = path_end - path_start;
 428                                 path = (char *)g_malloc(path_component_len + 1
 429                                     + strlen(arg0) + 1);
 430                                 memcpy(path, path_start, path_component_len);
 431                                 path[path_component_len] = '\0';
 432                                 strncat(path, "/", 2);
 433                                 strncat(path, arg0, strlen(arg0) + 1);
 434                                 if (access(path, X_OK) == 0) {
 435                                         /*
 436                                          * Found it!
 437                                          */
 438                                         prog_pathname = path;
 439                                         break;
 440                                 }
 441
 442                                 /*
 443                                  * That's not it.  If there are more
 444                                  * path components to test, try them.
 445                                  */
 446                                 if (*path_end == '\0') {
 447                                         /*
 448                                          * There's nothing more to try.
 449                                          */
 450                                         break;
 451                                 }
 452                                 if (*path_end == ':')
 453                                         path_end++;
 454                                 path_start = path_end;
 455                                 g_free(path);
 456                         }
 457                         if (prog_pathname == NULL) {
 458                                 /*
 459                                  * Program not found in path.
 460                                  */
 461                                 return g_strdup_printf("\"%s\" not found in \"%s\"",
 462                                     arg0, pathstr);
 463                         }
 464                 } else {
 465                         /*
 466                          * PATH isn't set.
 467                          * XXX - should we pick a default?
 468                          */
 469                         return g_strdup("PATH isn't set");
 470                 }
 471         }
 472
 473         /*
 474          * OK, we have what we think is the pathname
 475          * of the program.
 476          *
 477          * First, find the last "/" in the directory,
 478          * as that marks the end of the directory pathname.
 479          */
 480         dir_end = strrchr(prog_pathname, '/');
 481         if (dir_end != NULL) {
 482                 /*
 483                  * Found it.  Strip off the last component,
 484                  * as that's the path of the program.
 485                  */
 486                 *dir_end = '\0';
 487
 488                 /*
 489                  * Is there a "/.libs" at the end?
 490                  */
 491                 dir_end = strrchr(prog_pathname, '/');
 492                 if (dir_end != NULL) {
 493                         if (strcmp(dir_end, "/.libs") == 0) {
 494                                 /*
 495                                  * Yup, it's ".libs".
 496                                  * Strip that off; it's an
 497                                  * artifact of libtool.
 498                                  */
 499                                 *dir_end = '\0';
 500
 501                                 /*
 502                                  * This presumably means we're run from
 503                                  * the libtool wrapper, which probably
 504                                  * means we're being run from the build
 505                                  * directory.  If we weren't started
 506                                  * with special privileges, set
 507                                  * running_in_build_directory_flag.
 508                                  *
 509                                  * XXX - should we check whether what
 510                                  * follows ".libs/" begins with "lt-"?
 511                                  */
 512                                 if (!started_with_special_privs())
 513                                         running_in_build_directory_flag = TRUE;
 514                         }
 515                 }
 516
 517                 /*
 518                  * OK, we have the path we want.
 519                  */
 520                 progfile_dir = prog_pathname;
 521                 return NULL;
 522         } else {
 523                 /*
 524                  * This "shouldn't happen"; we apparently
 525                  * have no "/" in the pathname.
 526                  * Just free up prog_pathname.
 527                  */
 528                 retstr = g_strdup_printf("No / found in \"%s\"", prog_pathname);
 529                 g_free(prog_pathname);
 530                 return retstr;
 531         }
 532 #endif
 533 }
 534
 535 /*
 536  * Get the directory in which the program resides.
 537  */
 538 const char *
 539 get_progfile_dir(void)
 540 {
 541         return progfile_dir;
 542 }
 543
 544 /*
 545  * Get the directory in which the global configuration and data files are
 546  * stored.
 547  *
 548  * On Windows, we use the directory in which the executable for this
 549  * process resides.
 550  *
 551  * On UN*X, we use the DATAFILE_DIR value supplied by the configure
 552  * script, unless we think we're being run from the build directory,
 553  * in which case we use the directory in which the executable for this
 554  * process resides.
 555  *
 556  * XXX - if we ever make libwireshark a real library, used by multiple
 557  * applications (more than just TShark and versions of Wireshark with
 558  * various UIs), should the configuration files belong to the library
 559  * (and be shared by all those applications) or to the applications?
 560  *
 561  * If they belong to the library, that could be done on UNIX by the
 562  * configure script, but it's trickier on Windows, as you can't just
 563  * use the pathname of the executable.
 564  *
 565  * If they belong to the application, that could be done on Windows
 566  * by using the pathname of the executable, but we'd have to have it
 567  * passed in as an argument, in some call, on UNIX.
 568  *
 569  * Note that some of those configuration files might be used by code in
 570  * libwireshark, some of them might be used by dissectors (would they
 571  * belong to libwireshark, the application, or a separate library?),
 572  * and some of them might be used by other code (the Wireshark preferences
 573  * file includes resolver preferences that control the behavior of code
 574  * in libwireshark, dissector preferences, and UI preferences, for
 575  * example).
 576  */
 577 const char *
 578 get_datafile_dir(void)
 579 {
 580 #ifdef _WIN32
 581         char *u3deviceexecpath;
 582 #endif
 583         static const char *datafile_dir = NULL;
 584
 585         if (datafile_dir != NULL)
 586                 return datafile_dir;
 587
 588 #ifdef _WIN32
 589         /*
 590          * See if we are running in a U3 environment.
 591          */
 592         u3deviceexecpath = getenv_utf8("U3_DEVICE_EXEC_PATH");
 593
 594         if (u3deviceexecpath != NULL) {
 595                 /*
 596                  * We are; use the U3 device executable path.
 597                  */
 598                 datafile_dir = u3deviceexecpath;
 599         } else {
 600                 /*
 601                  * Do we have the pathname of the program?  If so, assume we're
 602                  * running an installed version of the program.  If we fail,
 603                  * we don't change "datafile_dir", and thus end up using the
 604                  * default.
 605                  *
 606                  * XXX - does NSIS put the installation directory into
 607                  * "\HKEY_LOCAL_MACHINE\SOFTWARE\Wireshark\InstallDir"?
 608                  * If so, perhaps we should read that from the registry,
 609                  * instead.
 610                  */
 611                 if (progfile_dir != NULL) {
 612                         /*
 613                          * Yes, we do; use that.
 614                          */
 615                         datafile_dir = progfile_dir;
 616                 } else {
 617                         /*
 618                          * No, we don't.
 619                          * Fall back on the default installation directory.
 620                          */
 621                         datafile_dir = "C:\\Program Files\\Wireshark\\";
 622                 }
 623         }
 624 #else
 625         if (running_in_build_directory_flag && progfile_dir != NULL) {
 626                 /*
 627                  * We're (probably) being run from the build directory and
 628                  * weren't started with special privileges, and we were
 629                  * able to determine the directory in which the program
 630                  * was found, so use that.
 631                  */
 632                 datafile_dir = progfile_dir;
 633         } else {
 634                 /*
 635                  * Return the directory specified when the build was
 636                  * configured, prepending the run path prefix if it exists.
 637                  */
 638                 if (getenv("WIRESHARK_DATA_DIR") && !started_with_special_privs()) {
 639                         /*
 640                          * The user specified a different directory for data files
 641                          * and we aren't running with special privileges.
 642                          * XXX - We might be able to dispense with the priv check
 643                          */
 644                         datafile_dir = g_strdup(getenv("WIRESHARK_DATA_DIR"));
 645                 } else {
 646                         datafile_dir = DATAFILE_DIR;
 647                 }
 648         }
 649
 650 #endif
 651         return datafile_dir;
 652 }
 653
 654 #ifdef HAVE_PYTHON
 655 /*
 656  * Find the directory where the python dissectors are stored.
 657  *
 658  * On Windows, we use the "py_dissector" subdirectory of the datafile directory.
 659  *
 660  * On UN*X, we use the PYTHON_DIR value supplied by the configure
 661  * script, unless we think we're being run from the build directory,
 662  * in which case we use the "py_dissector" subdirectory of the datafile directory.
 663  *
 664  * In both cases, we then use the subdirectory of that directory whose
 665  * name is the version number.
 666  *
 667  * XXX - if we think we're being run from the build directory, perhaps we
 668  * should have the plugin code not look in the version subdirectory
 669  * of the plugin directory, but look in all of the subdirectories
 670  * of the plugin directory, so it can just fetch the plugins built
 671  * as part of the build process.
 672  */
 673 static const char *wspython_dir = NULL;
 674
 675 static void
 676 init_wspython_dir(void)
 677 {
 678 #ifdef _WIN32
 679         /*
 680          * On Windows, the data file directory is the installation
 681          * directory; the python dissectors are stored under it.
 682          *
 683          * Assume we're running the installed version of Wireshark;
 684          * on Windows, the data file directory is the directory
 685          * in which the Wireshark binary resides.
 686          */
 687         wspython_dir = g_strdup_printf("%s\\python\\%s", get_datafile_dir(),
 688                                         VERSION);
 689
 690         /*
 691          * Make sure that pathname refers to a directory.
 692          */
 693         if (test_for_directory(wspython_dir) != EISDIR) {
 694                 /*
 695                  * Either it doesn't refer to a directory or it
 696                  * refers to something that doesn't exist.
 697                  *
 698                  * Assume that means we're running a version of
 699                  * Wireshark we've built in a build directory,
 700                  * in which case {datafile dir}\python is the
 701                  * top-level plugins source directory, and use
 702                  * that directory and set the "we're running in
 703                  * a build directory" flag, so the plugin
 704                  * scanner will check all subdirectories of that
 705                  * directory for python dissectors.
 706                  */
 707                 g_free( (gpointer) wspython_dir);
 708                 wspython_dir = g_strdup_printf("%s\\python", get_datafile_dir());
 709                 running_in_build_directory_flag = TRUE;
 710         }
 711 #else
 712         if (running_in_build_directory_flag) {
 713                 /*
 714                  * We're (probably) being run from the build directory and
 715                  * weren't started with special privileges, so we'll use
 716                  * the "python" subdirectory of the datafile directory
 717                  * (the datafile directory is the build directory).
 718                  */
 719                 wspython_dir = g_strdup_printf("%s/epan/wspython/", get_datafile_dir());
 720         } else {
 721                 if (getenv("WIRESHARK_PYTHON_DIR") && !started_with_special_privs()) {
 722                         /*
 723                          * The user specified a different directory for plugins
 724                          * and we aren't running with special privileges.
 725                          */
 726                         wspython_dir = g_strdup(getenv("WIRESHARK_PYTHON_DIR"));
 727                 } else {
 728                         wspython_dir = PYTHON_DIR;
 729                 }
 730         }
 731 #endif
 732 }
 733 #endif /* HAVE_PYTHON */
 734
 735 /*
 736  * Get the directory in which the python dissectors are stored.
 737  */
 738 const char *
 739 get_wspython_dir(void)
 740 {
 741 #ifdef HAVE_PYTHON
 742         if (!wspython_dir) init_wspython_dir();
 743         return wspython_dir;
 744 #else
 745         return NULL;
 746 #endif
 747 }
 748
 749
 750 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA_5_1)
 751 /*
 752  * Find the directory where the plugins are stored.
 753  *
 754  * On Windows, we use the "plugin" subdirectory of the datafile directory.
 755  *
 756  * On UN*X, we use the PLUGIN_DIR value supplied by the configure
 757  * script, unless we think we're being run from the build directory,
 758  * in which case we use the "plugin" subdirectory of the datafile directory.
 759  *
 760  * In both cases, we then use the subdirectory of that directory whose
 761  * name is the version number.
 762  *
 763  * XXX - if we think we're being run from the build directory, perhaps we
 764  * should have the plugin code not look in the version subdirectory
 765  * of the plugin directory, but look in all of the subdirectories
 766  * of the plugin directory, so it can just fetch the plugins built
 767  * as part of the build process.
 768  */
 769 static const char *plugin_dir = NULL;
 770
 771 static void
 772 init_plugin_dir(void)
 773 {
 774 #ifdef _WIN32
 775         /*
 776          * On Windows, the data file directory is the installation
 777          * directory; the plugins are stored under it.
 778          *
 779          * Assume we're running the installed version of Wireshark;
 780          * on Windows, the data file directory is the directory
 781          * in which the Wireshark binary resides.
 782          */
 783         plugin_dir = g_strdup_printf("%s\\plugins\\%s", get_datafile_dir(),
 784             VERSION);
 785
 786         /*
 787          * Make sure that pathname refers to a directory.
 788          */
 789         if (test_for_directory(plugin_dir) != EISDIR) {
 790                 /*
 791                  * Either it doesn't refer to a directory or it
 792                  * refers to something that doesn't exist.
 793                  *
 794                  * Assume that means we're running a version of
 795                  * Wireshark we've built in a build directory,
 796                  * in which case {datafile dir}\plugins is the
 797                  * top-level plugins source directory, and use
 798                  * that directory and set the "we're running in
 799                  * a build directory" flag, so the plugin
 800                  * scanner will check all subdirectories of that
 801                  * directory for plugins.
 802                  */
 803                 g_free( (gpointer) plugin_dir);
 804                 plugin_dir = g_strdup_printf("%s\\plugins", get_datafile_dir());
 805                 running_in_build_directory_flag = TRUE;
 806         }
 807 #else
 808         if (running_in_build_directory_flag) {
 809                 /*
 810                  * We're (probably) being run from the build directory and
 811                  * weren't started with special privileges, so we'll use
 812                  * the "plugins" subdirectory of the datafile directory
 813                  * (the datafile directory is the build directory).
 814                  */
 815                 plugin_dir = g_strdup_printf("%s/plugins", get_datafile_dir());
 816         } else {
 817                 if (getenv("WIRESHARK_PLUGIN_DIR") && !started_with_special_privs()) {
 818                         /*
 819                          * The user specified a different directory for plugins
 820                          * and we aren't running with special privileges.
 821                          */
 822                         plugin_dir = g_strdup(getenv("WIRESHARK_PLUGIN_DIR"));
 823                 } else {
 824                         plugin_dir = PLUGIN_DIR;
 825                 }
 826         }
 827 #endif
 828 }
 829 #endif /* HAVE_PLUGINS || HAVE_LUA_5_1 */
 830
 831 /*
 832  * Get the directory in which the plugins are stored.
 833  */
 834 const char *
 835 get_plugin_dir(void)
 836 {
 837 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA_5_1)
 838         if (!plugin_dir) init_plugin_dir();
 839         return plugin_dir;
 840 #else
 841         return NULL;
 842 #endif
 843 }
 844
 845 /*
 846  * Get the flag indicating whether we're running from a build
 847  * directory.
 848  */
 849 gboolean
 850 running_in_build_directory(void)
 851 {
 852         return running_in_build_directory_flag;
 853 }
 854
 855 /*
 856  * Get the directory in which files that, at least on UNIX, are
 857  * system files (such as "/etc/ethers") are stored; on Windows,
 858  * there's no "/etc" directory, so we get them from the global
 859  * configuration and data file directory.
 860  */
 861 const char *
 862 get_systemfile_dir(void)
 863 {
 864 #ifdef _WIN32
 865         return get_datafile_dir();
 866 #else
 867         return "/etc";
 868 #endif
 869 }
 870
 871 /*
 872  * Name of directory, under the user's home directory, in which
 873  * personal configuration files are stored.
 874  */
 875 #ifdef _WIN32
 876 #define PF_DIR "Wireshark"
 877 #else
 878 /*
 879  * XXX - should this be ".libepan"? For backwards-compatibility, I'll keep
 880  * it ".wireshark" for now.
 881  */
 882 #define PF_DIR ".wireshark"
 883 #endif
 884
 885 #ifdef _WIN32
 886 /* utf8 version of getenv, needed to get win32 filename paths */
 887 char *getenv_utf8(const char *varname)
 888 {
 889         char *envvar;
 890         wchar_t *envvarw;
 891         wchar_t *varnamew;
 892
 893         envvar = getenv(varname);
 894
 895         /* since GLib 2.6 we need an utf8 version of the filename */
 896 #if GLIB_CHECK_VERSION(2,6,0)
 897         /* using the wide char version of getenv should work under all circumstances */
 898
 899         /* convert given varname to utf16, needed by _wgetenv */
 900         varnamew = g_utf8_to_utf16(varname, -1, NULL, NULL, NULL);
 901         if (varnamew == NULL) {
 902                 return envvar;
 903         }
 904
 905         /* use wide char version of getenv */
 906         envvarw = _wgetenv(varnamew);
 907         g_free(varnamew);
 908         if (envvarw == NULL) {
 909                 return envvar;
 910         }
 911
 912         /* convert value to utf8 */
 913         envvar = g_utf16_to_utf8(envvarw, -1, NULL, NULL, NULL);
 914         /* XXX - memleak */
 915 #endif
 916
 917         return envvar;
 918 }
 919 #endif
 920
 921 void
 922 set_profile_name(const gchar *profilename)
 923 {
 924         g_free (persconfprofile);
 925
 926         if (profilename && strlen(profilename) > 0 &&
 927             strcmp(profilename, DEFAULT_PROFILE) != 0) {
 928                 persconfprofile = g_strdup (profilename);
 929         } else {
 930                 /* Default Profile */
 931                 persconfprofile = NULL;
 932         }
 933 }
 934
 935 const char *
 936 get_profile_name(void)
 937 {
 938         if (persconfprofile) {
 939                 return persconfprofile;
 940         } else {
 941                 return DEFAULT_PROFILE;
 942         }
 943 }
 944
 945 gboolean
 946 is_default_profile(void)
 947 {
 948         return (!persconfprofile || strcmp(persconfprofile, DEFAULT_PROFILE) == 0) ? TRUE : FALSE;
 949 }
 950
 951 void
 952 profile_store_persconffiles(gboolean store)
 953 {
 954         if (store) {
 955                 profile_files = g_hash_table_new (g_str_hash, g_str_equal);
 956         }
 957         do_store_persconffiles = store;
 958 }
 959
 960 /*
 961  * Get the directory in which personal configuration files reside;
 962  * in UNIX-compatible systems, it's ".wireshark", under the user's home
 963  * directory, and on Windows systems, it's "Wireshark", under %APPDATA%
 964  * or, if %APPDATA% isn't set, it's "%USERPROFILE%\Application Data"
 965  * (which is what %APPDATA% normally is on Windows 2000).
 966  */
 967 static const char *
 968 get_persconffile_dir_no_profile(void)
 969 {
 970 #ifdef _WIN32
 971         char *appdatadir;
 972         char *userprofiledir;
 973         char *u3appdatapath;
 974 #else
 975         const char *homedir;
 976         struct passwd *pwd;
 977 #endif
 978
 979         /* Return the cached value, if available */
 980         if (persconffile_dir != NULL)
 981                 return persconffile_dir;
 982
 983 #ifdef _WIN32
 984         /*
 985          * See if we are running in a U3 environment.
 986          */
 987         u3appdatapath = getenv_utf8("U3_APP_DATA_PATH");
 988         if (u3appdatapath != NULL) {
 989                 /*
 990                  * We are; use the U3 application data path.
 991                  */
 992                 persconffile_dir = u3appdatapath;
 993         } else {
 994                 /*
 995                  * Use %APPDATA% or %USERPROFILE%, so that configuration
 996                  * files are stored in the user profile, rather than in
 997                  * the home directory.  The Windows convention is to store
 998                  * configuration information in the user profile, and doing
 999                  * so means you can use Wireshark even if the home directory
1000                  * is an inaccessible network drive.
1001                  */
1002                 appdatadir = getenv_utf8("APPDATA");
1003                 if (appdatadir != NULL) {
1004                         /*
1005                          * Concatenate %APPDATA% with "\Wireshark".
1006                          */
1007                         persconffile_dir = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s",
1008                                                            appdatadir, PF_DIR);
1009                 } else {
1010                         /*
1011                          * OK, %APPDATA% wasn't set, so use
1012                          * %USERPROFILE%\Application Data.
1013                          */
1014                         userprofiledir = getenv_utf8("USERPROFILE");
1015                         if (userprofiledir != NULL) {
1016                                 persconffile_dir = g_strdup_printf(
1017                                     "%s" G_DIR_SEPARATOR_S "Application Data" G_DIR_SEPARATOR_S "%s",
1018                                     userprofiledir, PF_DIR);
1019                         } else {
1020                                 /*
1021                                  * Give up and use "C:".
1022                                  */
1023                                 persconffile_dir = g_strdup_printf("C:" G_DIR_SEPARATOR_S "%s", PF_DIR);
1024                         }
1025                 }
1026         }
1027 #else
1028         /*
1029          * If $HOME is set, use that.
1030          */
1031         homedir = getenv("HOME");
1032         if (homedir == NULL) {
1033                 /*
1034                  * Get their home directory from the password file.
1035                  * If we can't even find a password file entry for them,
1036                  * use "/tmp".
1037                  */
1038                 pwd = getpwuid(getuid());
1039                 if (pwd != NULL) {
1040                         /*
1041                          * This is cached, so we don't need to worry
1042                          * about allocating multiple ones of them.
1043                          */
1044                         homedir = g_strdup(pwd->pw_dir);
1045                 } else
1046                         homedir = "/tmp";
1047         }
1048         persconffile_dir = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", homedir, PF_DIR);
1049 #endif
1050
1051         return persconffile_dir;
1052 }
1053
1054 const char *
1055 get_profiles_dir(void)
1056 {
1057         static char *profiles_dir = NULL;
1058
1059         g_free (profiles_dir);
1060         profiles_dir = g_strdup_printf ("%s%s%s", get_persconffile_dir_no_profile (),
1061                                         G_DIR_SEPARATOR_S, PROFILES_DIR);
1062
1063         return profiles_dir;
1064 }
1065
1066 static const char *
1067 get_persconffile_dir(const gchar *profilename)
1068 {
1069         static char *persconffile_profile_dir = NULL;
1070
1071         g_free (persconffile_profile_dir);
1072
1073         if (profilename && strlen(profilename) > 0 &&
1074             strcmp(profilename, DEFAULT_PROFILE) != 0) {
1075           persconffile_profile_dir = g_strdup_printf ("%s%s%s", get_profiles_dir (),
1076                                                       G_DIR_SEPARATOR_S, profilename);
1077         } else {
1078           persconffile_profile_dir = g_strdup (get_persconffile_dir_no_profile ());
1079         }
1080
1081         return persconffile_profile_dir;
1082 }
1083
1084 gboolean
1085 profile_exists(const gchar *profilename)
1086 {
1087         if (test_for_directory (get_persconffile_dir (profilename)) == EISDIR) {
1088                 return TRUE;
1089         }
1090
1091         return FALSE;
1092 }
1093
1094 static int
1095 delete_directory (const char *directory, char **pf_dir_path_return)
1096 {
1097         WS_DIR *dir;
1098         WS_DIRENT *file;
1099         gchar *filename;
1100         int ret = 0;
1101
1102         if ((dir = ws_dir_open(directory, 0, NULL)) != NULL) {
1103                 while ((file = ws_dir_read_name(dir)) != NULL) {
1104                         filename = g_strdup_printf ("%s%s%s", directory, G_DIR_SEPARATOR_S,
1105                                                     ws_dir_get_name(file));
1106                         if (test_for_directory(filename) != EISDIR) {
1107                                 ret = ws_remove(filename);
1108 #if 0
1109                         } else {
1110                                 /* The user has manually created a directory in the profile directory */
1111                                 /* I do not want to delete the directory recursively yet */
1112                                 ret = delete_directory (filename, pf_dir_path_return);
1113 #endif
1114                         }
1115                         if (ret != 0) {
1116                                 *pf_dir_path_return = filename;
1117                                 break;
1118                         }
1119                         g_free (filename);
1120                 }
1121                 ws_dir_close(dir);
1122         }
1123
1124         if (ret == 0 && (ret = ws_remove(directory)) != 0) {
1125                 *pf_dir_path_return = g_strdup (directory);
1126         }
1127
1128         return ret;
1129 }
1130
1131 int
1132 delete_persconffile_profile(const char *profilename, char **pf_dir_path_return)
1133 {
1134         const char *profile_dir = get_persconffile_dir(profilename);
1135         int ret = 0;
1136
1137         if (test_for_directory (profile_dir) == EISDIR) {
1138                 ret = delete_directory (profile_dir, pf_dir_path_return);
1139         }
1140
1141         return ret;
1142 }
1143
1144 int
1145 rename_persconffile_profile(const char *fromname, const char *toname,
1146                             char **pf_from_dir_path_return, char **pf_to_dir_path_return)
1147 {
1148         char *from_dir = g_strdup (get_persconffile_dir(fromname));
1149         char *to_dir = g_strdup (get_persconffile_dir(toname));
1150         int ret = 0;
1151
1152         ret = ws_rename (from_dir, to_dir);
1153         if (ret != 0) {
1154                 *pf_from_dir_path_return = g_strdup (from_dir);
1155                 *pf_to_dir_path_return = g_strdup (to_dir);
1156         }
1157
1158         g_free (from_dir);
1159         g_free (to_dir);
1160
1161         return ret;
1162 }
1163
1164 /*
1165  * Create the directory that holds personal configuration files, if
1166  * necessary.  If we attempted to create it, and failed, return -1 and
1167  * set "*pf_dir_path_return" to the pathname of the directory we failed
1168  * to create (it's g_mallocated, so our caller should free it); otherwise,
1169  * return 0.
1170  */
1171 int
1172 create_persconffile_profile(const char *profilename, char **pf_dir_path_return)
1173 {
1174         const char *pf_dir_path;
1175 #ifdef _WIN32
1176         char *pf_dir_path_copy, *pf_dir_parent_path;
1177         size_t pf_dir_parent_path_len;
1178 #endif
1179         struct stat s_buf;
1180         int ret;
1181
1182         if (profilename) {
1183                 /*
1184                  * Check if profiles directory exists.
1185                  * If not then create it.
1186                  */
1187                 pf_dir_path = get_profiles_dir ();
1188                 if (ws_stat(pf_dir_path, &s_buf) != 0 && errno == ENOENT) {
1189                         ret = ws_mkdir(pf_dir_path, 0755);
1190                         if (ret == -1) {
1191                                 *pf_dir_path_return = g_strdup(pf_dir_path);
1192                                 return ret;
1193                         }
1194                 }
1195         }
1196
1197         pf_dir_path = get_persconffile_dir(profilename);
1198         if (ws_stat(pf_dir_path, &s_buf) != 0 && errno == ENOENT) {
1199 #ifdef _WIN32
1200                 /*
1201                  * Does the parent directory of that directory
1202                  * exist?  %APPDATA% may not exist even though
1203                  * %USERPROFILE% does.
1204                  *
1205                  * We check for the existence of the directory
1206                  * by first checking whether the parent directory
1207                  * is just a drive letter and, if it's not, by
1208                  * doing a "stat()" on it.  If it's a drive letter,
1209                  * or if the "stat()" succeeds, we assume it exists.
1210                  */
1211                 pf_dir_path_copy = g_strdup(pf_dir_path);
1212                 pf_dir_parent_path = get_dirname(pf_dir_path_copy);
1213                 pf_dir_parent_path_len = strlen(pf_dir_parent_path);
1214                 if (pf_dir_parent_path_len > 0
1215                     && pf_dir_parent_path[pf_dir_parent_path_len - 1] != ':'
1216                     && ws_stat(pf_dir_parent_path, &s_buf) != 0) {
1217                         /*
1218                          * No, it doesn't exist - make it first.
1219                          */
1220                         ret = ws_mkdir(pf_dir_parent_path, 0755);
1221                         if (ret == -1) {
1222                                 *pf_dir_path_return = pf_dir_parent_path;
1223                                 return -1;
1224                         }
1225                 }
1226                 g_free(pf_dir_path_copy);
1227                 ret = ws_mkdir(pf_dir_path, 0755);
1228 #else
1229                 ret = ws_mkdir(pf_dir_path, 0755);
1230 #endif
1231         } else {
1232                 /*
1233                  * Something with that pathname exists; if it's not
1234                  * a directory, we'll get an error if we try to put
1235                  * something in it, so we don't fail here, we wait
1236                  * for that attempt fo fail.
1237                  */
1238                 ret = 0;
1239         }
1240         if (ret == -1)
1241                 *pf_dir_path_return = g_strdup(pf_dir_path);
1242         return ret;
1243 }
1244
1245 int
1246 create_persconffile_dir(char **pf_dir_path_return)
1247 {
1248   return create_persconffile_profile(persconfprofile, pf_dir_path_return);
1249 }
1250
1251 #if ! GLIB_CHECK_VERSION(2,14,0)
1252 static void
1253 hash_table_get_keys(gpointer key, gpointer value _U_, gpointer user_data)
1254 {
1255         GList **files = ((GList **)user_data);
1256         *files = g_list_append (*files, key);
1257 }
1258 #endif
1259
1260 int
1261 copy_persconffile_profile(const char *toname, const char *fromname, char **pf_filename_return,
1262                             char **pf_to_dir_path_return, char **pf_from_dir_path_return)
1263 {
1264         gchar *from_dir = g_strdup (get_persconffile_dir(fromname));
1265         gchar *to_dir = g_strdup (get_persconffile_dir(toname));
1266         gchar *filename, *from_file, *to_file;
1267         GList *files, *file;
1268
1269 #if GLIB_CHECK_VERSION(2,14,0)
1270         files = g_hash_table_get_keys(profile_files);
1271 #else
1272         files = NULL;
1273         g_hash_table_foreach(profile_files, hash_table_get_keys, &files);
1274 #endif
1275
1276         file = g_list_first(files);
1277         while (file) {
1278                 filename = (gchar *)file->data;
1279                 from_file = g_strdup_printf ("%s%s%s", from_dir, G_DIR_SEPARATOR_S, filename);
1280                 to_file =  g_strdup_printf ("%s%s%s", to_dir, G_DIR_SEPARATOR_S, filename);
1281
1282                 if (file_exists(from_file) && !copy_file_binary_mode(from_file, to_file)) {
1283                         *pf_filename_return = g_strdup(filename);
1284                         *pf_to_dir_path_return = to_dir;
1285                         *pf_from_dir_path_return = from_dir;
1286                         g_free (from_file);
1287                         g_free (to_file);
1288                         return -1;
1289                 }
1290
1291                 g_free (from_file);
1292                 g_free (to_file);
1293
1294                 file = g_list_next(file);
1295         }
1296
1297         g_list_free (files);
1298         g_free (from_dir);
1299         g_free (to_dir);
1300
1301         return 0;
1302 }
1303
1304 /*
1305  * Get the (default) directory in which personal data is stored.
1306  *
1307  * On Win32, this is the "My Documents" folder in the personal profile,
1308  * except that, if we're running from a U3 device, this is the
1309  * "$U3_DEVICE_DOCUMENT_PATH\My Captures" folder.
1310  * On UNIX this is simply the current directory.
1311  */
1312 /* XXX - should this and the get_home_dir() be merged? */
1313 extern const char *
1314 get_persdatafile_dir(void)
1315 {
1316 #ifdef _WIN32
1317         char *u3devicedocumentpath;
1318         TCHAR tszPath[MAX_PATH];
1319         char *szPath;
1320         BOOL bRet;
1321
1322         /* Return the cached value, if available */
1323         if (persdatafile_dir != NULL)
1324                 return persdatafile_dir;
1325
1326         /*
1327          * See if we are running in a U3 environment.
1328          */
1329         u3devicedocumentpath = getenv_utf8("U3_DEVICE_DOCUMENT_PATH");
1330
1331         if (u3devicedocumentpath != NULL) {
1332                 /* the "My Captures" sub-directory is created (if it doesn't
1333                    exist) by u3util.exe when the U3 Wireshark is first run */
1334
1335                 szPath = g_strdup_printf("%s%s", u3devicedocumentpath, U3_MY_CAPTURES);
1336
1337                 persdatafile_dir = szPath;
1338                 return szPath;
1339         } else {
1340                 /*
1341                  * Hint: SHGetFolderPath is not available on MSVC 6 - without
1342                  * Platform SDK
1343                  */
1344                 bRet = SHGetSpecialFolderPath(NULL, tszPath, CSIDL_PERSONAL,
1345                     FALSE);
1346                 if(bRet == TRUE) {
1347                         szPath = utf_16to8(tszPath);
1348                         persdatafile_dir = szPath;
1349                         return szPath;
1350                 } else {
1351                         return "";
1352                 }
1353         }
1354 #else
1355         return "";
1356 #endif
1357 }
1358
1359 #ifdef _WIN32
1360 /*
1361  * Returns the user's home directory on Win32.
1362  */
1363 static const char *
1364 get_home_dir(void)
1365 {
1366         static const char *home = NULL;
1367         char *homedrive, *homepath;
1368         char *homestring;
1369         char *lastsep;
1370
1371         /* Return the cached value, if available */
1372         if (home)
1373                 return home;
1374
1375         /*
1376          * XXX - should we use USERPROFILE anywhere in this process?
1377          * Is there a chance that it might be set but one or more of
1378          * HOMEDRIVE or HOMEPATH isn't set?
1379          */
1380         homedrive = getenv_utf8("HOMEDRIVE");
1381         if (homedrive != NULL) {
1382                 homepath = getenv_utf8("HOMEPATH");
1383                 if (homepath != NULL) {
1384                         /*
1385                          * This is cached, so we don't need to worry about
1386                          * allocating multiple ones of them.
1387                          */
1388                         homestring = g_strdup_printf("%s%s", homedrive, homepath);
1389
1390                         /*
1391                          * Trim off any trailing slash or backslash.
1392                          */
1393                         lastsep = find_last_pathname_separator(homestring);
1394                         if (lastsep != NULL && *(lastsep + 1) == '\0') {
1395                                 /*
1396                                  * Last separator is the last character
1397                                  * in the string.  Nuke it.
1398                                  */
1399                                 *lastsep = '\0';
1400                         }
1401                         home = homestring;
1402                 } else
1403                         home = homedrive;
1404         } else {
1405                 /*
1406                  * Give up and use C:.
1407                  */
1408                 home = "C:";
1409         }
1410
1411         return home;
1412 }
1413 #endif
1414
1415 /*
1416  * Construct the path name of a personal configuration file, given the
1417  * file name.
1418  *
1419  * On Win32, if "for_writing" is FALSE, we check whether the file exists
1420  * and, if not, construct a path name relative to the ".wireshark"
1421  * subdirectory of the user's home directory, and check whether that
1422  * exists; if it does, we return that, so that configuration files
1423  * from earlier versions can be read.
1424  *
1425  * The returned file name was g_malloc()'d so it must be g_free()d when the
1426  * caller is done with it.
1427  */
1428 char *
1429 get_persconffile_path(const char *filename, gboolean from_profile, gboolean for_writing
1430 #ifndef _WIN32
1431         _U_
1432 #endif
1433 )
1434 {
1435         char *path;
1436 #ifdef _WIN32
1437         struct stat s_buf;
1438         char *old_path;
1439 #endif
1440         if (do_store_persconffiles && from_profile && !g_hash_table_lookup (profile_files, filename)) {
1441                 /* Store filenames so we know which filenames belongs to a configuration profile */
1442                 g_hash_table_insert (profile_files, g_strdup(filename), g_strdup(filename));
1443         }
1444
1445         if (from_profile) {
1446           path = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s",
1447                                  get_persconffile_dir(persconfprofile), filename);
1448         } else {
1449           path = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s",
1450                                  get_persconffile_dir(NULL), filename);
1451         }
1452 #ifdef _WIN32
1453         if (!for_writing) {
1454                 if (ws_stat(path, &s_buf) != 0 && errno == ENOENT) {
1455                         /*
1456                          * OK, it's not in the personal configuration file
1457                          * directory; is it in the ".wireshark" subdirectory
1458                          * of their home directory?
1459                          */
1460                         old_path = g_strdup_printf(
1461                             "%s" G_DIR_SEPARATOR_S ".wireshark" G_DIR_SEPARATOR_S "%s",
1462                             get_home_dir(), filename);
1463                         if (ws_stat(old_path, &s_buf) == 0) {
1464                                 /*
1465                                  * OK, it exists; return it instead.
1466                                  */
1467                                 g_free(path);
1468                                 path = old_path;
1469                         }
1470                 }
1471         }
1472 #endif
1473
1474         return path;
1475 }
1476
1477 /*
1478  * process command line option belonging to the filesystem settings
1479  * (move this e.g. to main.c and have set_persconffile_dir() instead in this file?)
1480  */
1481 int
1482 filesystem_opt(int opt _U_, const char *optstr)
1483 {
1484         gchar *p, *colonp;
1485
1486         colonp = strchr(optstr, ':');
1487         if (colonp == NULL) {
1488                 return 1;
1489         }
1490
1491         p = colonp;
1492         *p++ = '\0';
1493
1494         /*
1495         * Skip over any white space (there probably won't be any, but
1496         * as we allow it in the preferences file, we might as well
1497         * allow it here).
1498         */
1499         while (isspace((guchar)*p))
1500                 p++;
1501         if (*p == '\0') {
1502                 /*
1503                  * Put the colon back, so if our caller uses, in an
1504                  * error message, the string they passed us, the message
1505                  * looks correct.
1506                  */
1507                 *colonp = ':';
1508                 return 1;
1509         }
1510
1511         /* directory should be existing */
1512         /* XXX - is this a requirement? */
1513         if(test_for_directory(p) != EISDIR) {
1514                 /*
1515                  * Put the colon back, so if our caller uses, in an
1516                  * error message, the string they passed us, the message
1517                  * looks correct.
1518                  */
1519                 *colonp = ':';
1520                 return 1;
1521         }
1522
1523         if (strcmp(optstr,"persconf") == 0) {
1524                 persconffile_dir = p;
1525         } else if (strcmp(optstr,"persdata") == 0) {
1526                 persdatafile_dir = p;
1527                 /* XXX - might need to add the temp file path */
1528         } else {
1529                 return 1;
1530         }
1531         *colonp = ':'; /* put the colon back */
1532         return 0;
1533 }
1534
1535 /*
1536  * Construct the path name of a global configuration file, given the
1537  * file name.
1538  *
1539  * The returned file name was g_malloc()'d so it must be g_free()d when the
1540  * caller is done with it.
1541  */
1542 char *
1543 get_datafile_path(const char *filename)
1544 {
1545
1546         return g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", get_datafile_dir(),
1547                 filename);
1548 }
1549
1550 /* Get the personal plugin dir */
1551 /* Return value is malloced so the caller should g_free() it. */
1552 char *
1553 get_plugins_pers_dir(void)
1554 {
1555     return get_persconffile_path(PLUGINS_DIR_NAME, FALSE, FALSE);
1556 }
1557
1558 /* Delete a file */
1559 gboolean
1560 deletefile(const char *path)
1561 {
1562         return ws_unlink(path) == 0;
1563 }
1564
1565 /*
1566  * Construct and return the path name of a file in the
1567  * appropriate temporary file directory.
1568  */
1569 char *get_tempfile_path(const char *filename)
1570 {
1571         return g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", g_get_tmp_dir(), filename);
1572 }
1573
1574 /*
1575  * Return an error message for UNIX-style errno indications on open or
1576  * create operations.
1577  */
1578 const char *
1579 file_open_error_message(int err, gboolean for_writing)
1580 {
1581         const char *errmsg;
1582         static char errmsg_errno[1024+1];
1583
1584         switch (err) {
1585
1586         case ENOENT:
1587                 if (for_writing)
1588                         errmsg = "The path to the file \"%s\" doesn't exist.";
1589                 else
1590                         errmsg = "The file \"%s\" doesn't exist.";
1591                 break;
1592
1593         case EACCES:
1594                 if (for_writing)
1595                         errmsg = "You don't have permission to create or write to the file \"%s\".";
1596                 else
1597                         errmsg = "You don't have permission to read the file \"%s\".";
1598                 break;
1599
1600         case EISDIR:
1601                 errmsg = "\"%s\" is a directory (folder), not a file.";
1602                 break;
1603
1604         case ENOSPC:
1605                 errmsg = "The file \"%s\" could not be created because there is no space left on the file system.";
1606                 break;
1607
1608 #ifdef EDQUOT
1609         case EDQUOT:
1610                 errmsg = "The file \"%s\" could not be created because you are too close to, or over, your disk quota.";
1611                 break;
1612 #endif
1613
1614         case EINVAL:
1615                 errmsg = "The file \"%s\" could not be created because an invalid filename was specified.";
1616                 break;
1617
1618         default:
1619                 g_snprintf(errmsg_errno, sizeof(errmsg_errno),
1620                                 "The file \"%%s\" could not be %s: %s.",
1621                                 for_writing ? "created" : "opened",
1622                                 strerror(err));
1623                 errmsg = errmsg_errno;
1624                 break;
1625         }
1626         return errmsg;
1627 }
1628
1629 /*
1630  * Return an error message for UNIX-style errno indications on write
1631  * operations.
1632  */
1633 const char *
1634 file_write_error_message(int err)
1635 {
1636         const char *errmsg;
1637         static char errmsg_errno[1024+1];
1638
1639         switch (err) {
1640
1641         case ENOSPC:
1642                 errmsg = "The file \"%s\" could not be saved because there is no space left on the file system.";
1643                 break;
1644
1645 #ifdef EDQUOT
1646         case EDQUOT:
1647                 errmsg = "The file \"%s\" could not be saved because you are too close to, or over, your disk quota.";
1648                 break;
1649 #endif
1650
1651         case WTAP_ERR_SHORT_WRITE:
1652                 errmsg = "A full write couldn't be done to the file \"%s\".";
1653                 break;
1654
1655         default:
1656                 g_snprintf(errmsg_errno, sizeof(errmsg_errno),
1657                     "An error occurred while writing to the file \"%%s\": %s.",
1658                     strerror(err));
1659                 errmsg = errmsg_errno;
1660                 break;
1661         }
1662         return errmsg;
1663 }
1664
1665
1666 gboolean
1667 file_exists(const char *fname)
1668 {
1669         struct stat   file_stat;
1670
1671 #ifdef _WIN32
1672         /*
1673          * This is a bit tricky on win32. The st_ino field is documented as:
1674          * "The inode, and therefore st_ino, has no meaning in the FAT, ..."
1675          * but it *is* set to zero if stat() returns without an error,
1676          * so this is working, but maybe not quite the way expected. ULFL
1677          */
1678         file_stat.st_ino = 1;   /* this will make things work if an error occured */
1679         ws_stat(fname, &file_stat);
1680         if (file_stat.st_ino == 0) {
1681                 return TRUE;
1682         } else {
1683                 return FALSE;
1684         }
1685 #else
1686         if (ws_stat(fname, &file_stat) != 0 && errno == ENOENT) {
1687                 return FALSE;
1688         } else {
1689                 return TRUE;
1690         }
1691 #endif
1692 }
1693
1694 /*
1695  * Check that the from file is not the same as to file
1696  * We do it here so we catch all cases ...
1697  * Unfortunately, the file requester gives us an absolute file
1698  * name and the read file name may be relative (if supplied on
1699  * the command line), so we can't just compare paths. From Joerg Mayer.
1700  */
1701 gboolean
1702 files_identical(const char *fname1, const char *fname2)
1703 {
1704         /* Two different implementations, because:
1705          *
1706          * - _fullpath is not available on UN*X, so we can't get full
1707          *   paths and compare them (which wouldn't work with hard links
1708          *   in any case);
1709          *
1710          * - st_ino isn't filled in with a meaningful value on Windows.
1711          */
1712 #ifdef _WIN32
1713         char full1[MAX_PATH], full2[MAX_PATH];
1714
1715         /*
1716          * Get the absolute full paths of the file and compare them.
1717          * That won't work if you have hard links, but those aren't
1718          * much used on Windows, even though NTFS supports them.
1719          *
1720          * XXX - will _fullpath work with UNC?
1721          */
1722         if( _fullpath( full1, fname1, MAX_PATH ) == NULL ) {
1723                 return FALSE;
1724         }
1725
1726         if( _fullpath( full2, fname2, MAX_PATH ) == NULL ) {
1727                 return FALSE;
1728         }
1729
1730         if(strcmp(full1, full2) == 0) {
1731                 return TRUE;
1732         } else {
1733                 return FALSE;
1734         }
1735 #else
1736         struct stat   filestat1, filestat2;
1737
1738         /*
1739          * Compare st_dev and st_ino.
1740          */
1741         if (ws_stat(fname1, &filestat1) == -1)
1742                 return FALSE;   /* can't get info about the first file */
1743         if (ws_stat(fname2, &filestat2) == -1)
1744                 return FALSE;   /* can't get info about the second file */
1745         return (filestat1.st_dev == filestat2.st_dev &&
1746                 filestat1.st_ino == filestat2.st_ino);
1747 #endif
1748 }
1749
1750 /*
1751  * Copy a file in binary mode, for those operating systems that care about
1752  * such things.  This should be OK for all files, even text files, as
1753  * we'll copy the raw bytes, and we don't look at the bytes as we copy
1754  * them.
1755  *
1756  * Returns TRUE on success, FALSE on failure. If a failure, it also
1757  * displays a simple dialog window with the error message.
1758  */
1759 gboolean
1760 copy_file_binary_mode(const char *from_filename, const char *to_filename)
1761 {
1762   int           from_fd, to_fd, nread, nwritten, err;
1763   guint8        pd[65536];
1764
1765   /* Copy the raw bytes of the file. */
1766   from_fd = ws_open(from_filename, O_RDONLY | O_BINARY, 0000 /* no creation so don't matter */);
1767   if (from_fd < 0) {
1768     report_open_failure(from_filename, errno, FALSE);
1769     goto done;
1770   }
1771
1772   /* Use open() instead of creat() so that we can pass the O_BINARY
1773      flag, which is relevant on Win32; it appears that "creat()"
1774      may open the file in text mode, not binary mode, but we want
1775      to copy the raw bytes of the file, so we need the output file
1776      to be open in binary mode. */
1777   to_fd = ws_open(to_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
1778   if (to_fd < 0) {
1779     report_open_failure(to_filename, errno, TRUE);
1780     ws_close(from_fd);
1781     goto done;
1782   }
1783
1784   while ((nread = ws_read(from_fd, pd, sizeof pd)) > 0) {
1785     nwritten = ws_write(to_fd, pd, nread);
1786     if (nwritten < nread) {
1787       if (nwritten < 0)
1788         err = errno;
1789       else
1790         err = WTAP_ERR_SHORT_WRITE;
1791       report_write_failure(to_filename, err);
1792       ws_close(from_fd);
1793       ws_close(to_fd);
1794       goto done;
1795     }
1796   }
1797   if (nread < 0) {
1798     err = errno;
1799     report_read_failure(from_filename, err);
1800     ws_close(from_fd);
1801     ws_close(to_fd);
1802     goto done;
1803   }
1804   ws_close(from_fd);
1805   if (ws_close(to_fd) < 0) {
1806     report_write_failure(to_filename, errno);
1807     goto done;
1808   }
1809
1810   return TRUE;
1811
1812 done:
1813   return FALSE;
1814 }
1815
1816 /*
1817  * Editor modelines
1818  *
1819  * Local Variables:
1820  * c-basic-offset: 4
1821  * tab-width: 4
1822  * indent-tabs-mode: t
1823  * End:
1824  *
1825  * ex: set shiftwidth=4 tabstop=4 noexpandtab
1826  * :indentSize=4:tabSize=4:noTabs=false:
1827  */