fileset.c

   1 /* fileset.c
   2  * Routines for handling file sets
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 1998 Gerald Combs
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include <config.h>
  12
  13 #ifdef HAVE_SYS_WAIT_H
  14 # include <sys/wait.h>
  15 #endif
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19
  20 #include <glib.h>
  21
  22 #include <wsutil/file_util.h>
  23 #include <wsutil/filesystem.h>
  24 #include <wsutil/ws_assert.h>
  25
  26 #include <wiretap/wtap.h>
  27
  28 #include <epan/strutil.h>
  29
  30 #include "fileset.h"
  31
  32 typedef struct _fileset {
  33     GList   *entries;
  34     char    *dirname;
  35 } fileset;
  36
  37 /*
  38  * This is the fileset's global data.
  39  *
  40  * XXX This should probably be per-main-window instead of global.
  41  */
  42 static fileset set;
  43
  44 /*
  45  * Given a stat structure, get the creation time of the file if available,
  46  * or 0 if not.
  47  */
  48 #ifdef _WIN32
  49   /* Microsoft's documentation says this is the creation time */
  50   #define ST_CREATE_TIME(statb) ((statb).st_ctime)
  51 #else /* _WIN32 */
  52   /* UN*X - do we have a creation time? */
  53   #if defined(HAVE_STRUCT_STAT_ST_BIRTHTIME)
  54     #define ST_CREATE_TIME(statb) ((statb).st_birthtime)
  55   #elif defined(HAVE_STRUCT_STAT___ST_BIRTHTIME)
  56     #define ST_CREATE_TIME(statb) ((statb).__st_birthtime)
  57   #else /* nothing */
  58     #define ST_CREATE_TIME(statb) (0)
  59   #endif /* creation time on UN*X */
  60 #endif /* _WIN32 */
  61
  62 /* is this a probable file of a file set (does the naming pattern match)? */
  63 fileset_match_t
  64 fileset_filename_match_pattern(const char *fname, char **prefix, char **suffix, char **time)
  65 {
  66     char        *sfx;
  67     char        *filename;
  68     fileset_match_t ret = FILESET_NO_MATCH;
  69     static char *pattern = "(?P<prefix>.*)_\\d{5}_(?P<time>\\d{14})$";
  70     static char *pattern2 = "(?P<prefix>.*)_(?P<time>\\d{14})_\\d{5}$";
  71     static GRegex *regex = NULL;
  72     static GRegex *regex2 = NULL;
  73
  74     if (regex == NULL) {
  75         GError *gerr = NULL;
  76         regex = g_regex_new(pattern,
  77                         (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_ANCHORED),
  78                         G_REGEX_MATCH_ANCHORED, &gerr);
  79         if (gerr) {
  80                 ws_warning("failed to compile regex: %s", gerr->message);
  81                 g_error_free(gerr);
  82                 regex = NULL;
  83                 return ret;
  84         }
  85     }
  86
  87     if (regex2 == NULL) {
  88         GError *gerr = NULL;
  89         regex2 = g_regex_new(pattern2,
  90                         (GRegexCompileFlags)(G_REGEX_OPTIMIZE | G_REGEX_ANCHORED),
  91                         G_REGEX_MATCH_ANCHORED, &gerr);
  92         if (gerr) {
  93                 ws_warning("failed to compile regex: %s", gerr->message);
  94                 g_error_free(gerr);
  95                 regex2 = NULL;
  96                 return ret;
  97         }
  98     }
  99
 100     /* d:\dir1\test_00001_20050418010750.cap */
 101     filename = g_path_get_basename(fname);
 102
 103     /* test_00001_20050418010750.cap */
 104     sfx = strrchr(filename, '.');
 105     if (sfx != NULL) {
 106         *sfx = '\0';
 107         GSList *compression_type_extensions = wtap_get_all_compression_type_extensions_list();
 108         char *ext = g_ascii_strdown(sfx + 1, -1);
 109         for (GSList *compression_extension = compression_type_extensions;
 110                 compression_extension != NULL;
 111                 compression_extension = g_slist_next(compression_extension)) {
 112             if (g_strcmp0(ext, (const char*)compression_extension->data) == 0) {
 113                 sfx = strrchr(filename, '.');
 114                 if (sfx != NULL) {
 115                     *sfx = '\0';
 116                 }
 117                 break;
 118             }
 119         }
 120         g_free(ext);
 121         g_slist_free(compression_type_extensions);
 122     } else { /* suffix is optional */
 123         sfx = filename + strlen(filename);
 124     }
 125
 126     /* test_00001_20050418010750 */
 127
 128     GMatchInfo *match_info;
 129     g_regex_match(regex, filename, 0, &match_info);
 130     if (g_match_info_matches(match_info)) {
 131         if (prefix) {
 132             *prefix = g_match_info_fetch_named(match_info, "prefix");
 133         }
 134         if (time) {
 135             *time = g_match_info_fetch_named(match_info, "time");
 136         }
 137         if (suffix) {
 138             *suffix = g_strdup(sfx);
 139         }
 140         ret = FILESET_NUM_TIME;
 141     }
 142     g_match_info_free(match_info);
 143
 144     if (ret == FILESET_NO_MATCH) {
 145         g_regex_match(regex2, filename, 0, &match_info);
 146         if (g_match_info_matches(match_info)) {
 147             if (prefix) {
 148                 *prefix = g_match_info_fetch_named(match_info, "prefix");
 149             }
 150             if (time) {
 151                 *time = g_match_info_fetch_named(match_info, "time");
 152             }
 153             if (suffix) {
 154                 *suffix = g_strdup(sfx);
 155             }
 156             ret = FILESET_TIME_NUM;
 157         }
 158         g_match_info_free(match_info);
 159     }
 160
 161     g_free(filename);
 162
 163     return ret;
 164 }
 165
 166
 167 /* test if both files could be in the same file set */
 168 /* (fname2 must already be in correct shape) */
 169 static bool
 170 fileset_is_file_in_set(const char *fname1, const char *fname2)
 171 {
 172     char        *pfx1;
 173     char        *pfx2;
 174     char        *sfx1;
 175     char        *sfx2;
 176     fileset_match_t match1;
 177     fileset_match_t match2;
 178     bool        ret = false;
 179
 180     match1 = fileset_filename_match_pattern(fname1, &pfx1, &sfx1, NULL);
 181     if (match1 == FILESET_NO_MATCH) {
 182         return false;
 183     }
 184
 185     match2 = fileset_filename_match_pattern(fname2, &pfx2, &sfx2, NULL);
 186     /* just to be sure ... */
 187     ws_assert(match2 != FILESET_NO_MATCH);
 188     if (match1 == match2 && g_strcmp0(pfx1, pfx2) == 0 && g_strcmp0(sfx1, sfx2) == 0) {
 189         ret = true;
 190     }
 191
 192     g_free(pfx1);
 193     g_free(pfx2);
 194     g_free(sfx1);
 195     g_free(sfx2);
 196
 197     return ret;
 198 }
 199
 200 /* GCompareFunc helper for g_list_find_custom() */
 201 static int
 202 fileset_find_by_path(const void *a, const void *b)
 203 {
 204     const fileset_entry *entry;
 205     const char *path;
 206
 207     entry = (const fileset_entry *) a;
 208     path  = (const char *) b;
 209
 210     return g_strcmp0(entry->fullname, path);
 211 }
 212
 213 /* update the time and size of this file in the list */
 214 void
 215 fileset_update_file(const char *path)
 216 {
 217     int fh, result;
 218     ws_statb64 buf;
 219     fileset_entry *entry = NULL;
 220     GList *entry_list;
 221
 222     fh = ws_open( path, O_RDONLY, 0000 /* no creation so don't matter */);
 223     if(fh !=  -1) {
 224
 225         /* Get statistics */
 226         result = ws_fstat64( fh, &buf );
 227
 228         /* Show statistics if they are valid */
 229         if( result == 0 ) {
 230             entry_list = g_list_find_custom(set.entries, path,
 231                                             fileset_find_by_path);
 232
 233             if (entry_list) {
 234                 entry = (fileset_entry *) entry_list->data;
 235                 entry->ctime    = ST_CREATE_TIME(buf);
 236                 entry->mtime    = buf.st_mtime;
 237                 entry->size     = buf.st_size;
 238             }
 239         }
 240
 241         ws_close(fh);
 242     }
 243 }
 244
 245 /* we know this file is part of the set, so add it */
 246 static fileset_entry *
 247 fileset_add_file(const char *dirname, const char *fname, bool current)
 248 {
 249     int fh, result;
 250     ws_statb64 buf;
 251     char *path;
 252     fileset_entry *entry = NULL;
 253
 254
 255     path = ws_strdup_printf("%s%s", dirname, fname);
 256
 257     fh = ws_open( path, O_RDONLY, 0000 /* no creation so don't matter */);
 258     if(fh !=  -1) {
 259
 260         /* Get statistics */
 261         result = ws_fstat64( fh, &buf );
 262
 263         /* Show statistics if they are valid */
 264         if( result == 0 ) {
 265             entry = g_new(fileset_entry, 1);
 266
 267             entry->fullname = g_strdup(path);
 268             entry->name     = g_strdup(fname);
 269             entry->ctime    = ST_CREATE_TIME(buf);
 270             entry->mtime    = buf.st_mtime;
 271             entry->size     = buf.st_size;
 272             entry->current  = current;
 273
 274             set.entries = g_list_append(set.entries, entry);
 275         }
 276
 277         ws_close(fh);
 278     }
 279
 280     g_free(path);
 281
 282     return entry;
 283 }
 284
 285
 286 /* compare two list entries by creation date/time (through filename) */
 287 static int
 288 fileset_sort_compare(const void *a, const void *b)
 289 {
 290     const fileset_entry *entry_a = (const fileset_entry *)a;
 291     const fileset_entry *entry_b = (const fileset_entry *)b;
 292
 293     return strcmp(entry_a->name, entry_b->name);
 294 }
 295
 296
 297 /* add all file set entries to the dialog */
 298 void fileset_update_dlg(void *window)
 299 {
 300     GList         *le;
 301
 302     /* Add all entries to the dialog. */
 303     fileset_dlg_begin_add_file(window);
 304     le = g_list_first(set.entries);
 305     while(le) {
 306         fileset_dlg_add_file((fileset_entry *)le->data, window);
 307         le = g_list_next(le);
 308     }
 309     fileset_dlg_end_add_file(window);
 310 }
 311
 312
 313 /* walk through the directory of the loaded file and add every file matching the current file */
 314 void
 315 fileset_add_dir(const char *fname, void *window)
 316 {
 317     WS_DIR        *dir;             /* scanned directory */
 318     WS_DIRENT     *file;            /* current file */
 319     const char    *name;
 320     GString       *dirname;
 321     char          *fname_dup;
 322
 323
 324     /* get (convert) directory name, but don't touch the given string */
 325     fname_dup = g_strdup(fname);
 326     dirname = g_string_new(get_dirname(fname_dup));
 327     g_free(fname_dup);
 328
 329     set.dirname = g_strdup(dirname->str);
 330
 331     dirname = g_string_append_c(dirname, G_DIR_SEPARATOR);
 332
 333     /* is the current file probably a part of any fileset? */
 334     if(fileset_filename_match_pattern(fname, NULL, NULL, NULL)) {
 335         /* yes, go through the files in the directory and check if the file in question is part of the current file set */
 336         if ((dir = ws_dir_open(dirname->str, 0, NULL)) != NULL) {
 337             while ((file = ws_dir_read_name(dir)) != NULL) {
 338                 name = ws_dir_get_name(file);
 339                 if(fileset_is_file_in_set(name, get_basename(fname))) {
 340                     fileset_add_file(dirname->str, name, strcmp(name, get_basename(fname))== 0 /* current */);
 341                 }
 342             } /* while */
 343
 344             ws_dir_close(dir);
 345         } /* if */
 346     } else {
 347         /* no, this is a "standalone file", just add this one */
 348         fileset_add_file(dirname->str, get_basename(fname), true /* current */);
 349         /* don't add the file to the dialog here, this will be done in fileset_update_dlg() below */
 350     }
 351
 352     g_string_free(dirname, TRUE /* free_segment */);
 353
 354     /* sort entries by creation time */
 355     set.entries = g_list_sort(set.entries, fileset_sort_compare);
 356
 357     fileset_update_dlg(window);
 358 }
 359
 360
 361 /* get current directory name */
 362 const char *
 363 fileset_get_dirname(void)
 364 {
 365     return set.dirname;
 366 }
 367
 368
 369 /* get the current list entry, or NULL */
 370 static GList *
 371 fileset_get_current(void)
 372 {
 373     GList         *le;
 374     fileset_entry *entry;
 375
 376
 377     /* add all entries to the dialog */
 378     le = g_list_first(set.entries);
 379     while(le) {
 380         entry = (fileset_entry *)le->data;
 381         if(entry->current) {
 382             return le;
 383         }
 384         le = g_list_next(le);
 385     }
 386
 387     return NULL;
 388 }
 389
 390
 391 /* get the file set entry after the current one, or NULL */
 392 fileset_entry *
 393 fileset_get_next(void)
 394 {
 395     GList         *le;
 396
 397
 398     le = fileset_get_current();
 399     if(le == NULL) {
 400         return NULL;
 401     }
 402
 403     le = g_list_next(le);
 404     if(le == NULL) {
 405         return NULL;
 406     }
 407
 408     return (fileset_entry *)le->data;
 409 }
 410
 411
 412 /* get the file set entry before the current one, or NULL */
 413 fileset_entry *
 414 fileset_get_previous(void)
 415 {
 416     GList         *le;
 417
 418
 419     le = fileset_get_current();
 420     if(le == NULL) {
 421         return NULL;
 422     }
 423
 424     le = g_list_previous(le);
 425     if(le == NULL) {
 426         return NULL;
 427     }
 428
 429     return (fileset_entry *)le->data;
 430 }
 431
 432
 433 /* delete a single entry */
 434 static void fileset_entry_delete(void *data, void *user_data _U_)
 435 {
 436     fileset_entry *entry = (fileset_entry *)data;
 437
 438     g_free( (void *) entry->fullname);
 439     entry->fullname = NULL;
 440     g_free( (void *) entry->name);
 441     entry->name = NULL;
 442     g_free(entry);
 443 }
 444
 445
 446 /* delete the whole file set */
 447 void fileset_delete(void)
 448 {
 449     /* free the entry list */
 450     if(set.entries) {
 451         g_list_foreach(set.entries, fileset_entry_delete, NULL);
 452         g_list_free(set.entries);
 453         set.entries = NULL;
 454     }
 455
 456     /* free the rest */
 457     if(set.dirname) {
 458         g_free( (void *) set.dirname);
 459         set.dirname = NULL;
 460     }
 461 }
 462
 463 /*
 464  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 465  *
 466  * Local variables:
 467  * c-basic-offset: 4
 468  * tab-width: 8
 469  * indent-tabs-mode: nil
 470  * End:
 471  *
 472  * vi: set shiftwidth=4 tabstop=8 expandtab:
 473  * :indentSize=4:tabSize=8:noTabs=true:
 474  */