← Back to branch summary

~ubuntu-branches/ubuntu/quantal/telepathy-logger/quantal

« back to all changes in this revision

Viewing changes to telepathy-logger/log-store-xml.c

  • Committer: Bazaar Package Importer
  • Author(s): Emilio Pozuelo Monfort
  • Date: 2011-05-13 12:35:32 UTC
  • mfrom: (14.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20110513123532-9rbt6z6gs50o3as4
Tags: 0.2.9-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
telepathy-logger/log-store-xml.c
38
38
#include <telepathy-glib/dbus.h>
39
39
#include <telepathy-glib/defs.h>
40
40
#include <telepathy-glib/util.h>
41
 
#include <telepathy-logger/call-event.h>
42
 
#include <telepathy-logger/call-event-internal.h>
43
 
#include <telepathy-logger/event-internal.h>
44
 
#include <telepathy-logger/text-event.h>
45
 
#include <telepathy-logger/text-event-internal.h>
46
 
#include <telepathy-logger/log-manager.h>
47
 
#include <telepathy-logger/log-store-internal.h>
48
 
#include <telepathy-logger/log-manager-internal.h>
 
41
 
 
42
#include "telepathy-logger/call-event.h"
 
43
#include "telepathy-logger/call-event-internal.h"
 
44
#include "telepathy-logger/entity-internal.h"
 
45
#include "telepathy-logger/event-internal.h"
 
46
#include "telepathy-logger/text-event.h"
 
47
#include "telepathy-logger/text-event-internal.h"
 
48
#include "telepathy-logger/log-manager.h"
 
49
#include "telepathy-logger/log-store-internal.h"
 
50
#include "telepathy-logger/log-manager-internal.h"
 
51
#include "telepathy-logger/util-internal.h"
49
52
 
50
53
#define DEBUG_FLAG TPL_DEBUG_LOG_STORE
51
 
#include <telepathy-logger/entity-internal.h>
52
 
#include <telepathy-logger/debug-internal.h>
53
 
#include <telepathy-logger/util-internal.h>
 
54
#include "telepathy-logger/debug-internal.h"
54
55
 
55
56
#define LOG_DIR_CREATE_MODE       (S_IRUSR | S_IWUSR | S_IXUSR)
56
57
#define LOG_FILE_CREATE_MODE      (S_IRUSR | S_IWUSR)
57
58
#define LOG_DIR_CHATROOMS         "chatrooms"
58
59
#define LOG_FILENAME_SUFFIX       ".log"
 
60
#define LOG_FILENAME_CALL_TAG     ".call"
 
61
#define LOG_FILENAME_CALL_SUFFIX LOG_FILENAME_CALL_TAG LOG_FILENAME_SUFFIX
 
62
#define LOG_DATE_PATTERN          "[0-9]{8,}"
 
63
#define LOG_FILENAME_PATTERN      "^" LOG_DATE_PATTERN "\\" LOG_FILENAME_SUFFIX "$"
 
64
#define LOG_FILENAME_CALL_PATTERN "^" LOG_DATE_PATTERN "\\" LOG_FILENAME_CALL_TAG "\\" LOG_FILENAME_SUFFIX "$"
 
65
 
59
66
#define LOG_TIME_FORMAT_FULL      "%Y%m%dT%H:%M:%S"
60
67
#define LOG_TIME_FORMAT           "%Y%m%d"
61
68
#define LOG_HEADER \
66
73
#define LOG_FOOTER \
67
74
    "</log>\n"
68
75
 
 
76
#ifdef ENABLE_CALL
69
77
#define ALL_SUPPORTED_TYPES (TPL_EVENT_MASK_TEXT | TPL_EVENT_MASK_CALL)
 
78
#else
 
79
#define ALL_SUPPORTED_TYPES TPL_EVENT_MASK_TEXT
 
80
#endif /* ENABLE_CALL */
 
81
 
70
82
#define CONTAINS_ALL_SUPPORTED_TYPES(type_mask) \
71
83
  (((type_mask) & ALL_SUPPORTED_TYPES) == ALL_SUPPORTED_TYPES)
72
84
 
264
276
 
265
277
  param_spec = g_param_spec_boolean ("testmode",
266
278
      "TestMode",
267
 
      "Wheter the logstore is in testmode, for testsuite use only",
 
279
      "Whether the logstore is in testmode, for testsuite use only",
268
280
      FALSE, G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS);
269
281
  g_object_class_install_property (object_class, PROP_TESTMODE, param_spec);
270
282
 
313
325
 
314
326
  escaped_account = log_store_account_to_dirname (account);
315
327
 
316
 
  if (target)
 
328
  if (target != NULL)
317
329
    {
318
330
      /* FIXME This may be source of bug (does that case still exist ?)
319
331
       * avoid that 1-1 conversation generated from a chatroom, having id similar
339
351
  return basedir;
340
352
}
341
353
 
 
354
static const gchar *
 
355
log_store_xml_get_file_suffix (GType type)
 
356
{
 
357
  if (type == TPL_TYPE_TEXT_EVENT)
 
358
    return LOG_FILENAME_SUFFIX;
 
359
  else if (type == TPL_TYPE_CALL_EVENT)
 
360
    return LOG_FILENAME_CALL_SUFFIX;
 
361
  else
 
362
    g_return_val_if_reached (NULL);
 
363
}
342
364
 
343
365
static gchar *
344
 
log_store_xml_get_timestamp_filename (void)
 
366
log_store_xml_get_timestamp_filename (GType type)
345
367
{
346
368
  gchar *time_str;
347
369
  gchar *filename;
349
371
 
350
372
  now = g_date_time_new_now_local ();
351
373
  time_str = g_date_time_format (now, LOG_TIME_FORMAT);
352
 
  filename = g_strconcat (time_str, LOG_FILENAME_SUFFIX, NULL);
 
374
  filename = g_strconcat (time_str, log_store_xml_get_file_suffix (type),
 
375
      NULL);
353
376
 
354
377
  g_date_time_unref (now);
355
378
  g_free (time_str);
373
396
}
374
397
 
375
398
 
 
399
 
376
400
static gchar *
377
401
log_store_xml_get_filename (TplLogStoreXml *self,
378
402
    TpAccount *account,
379
 
    TplEntity *target)
 
403
    TplEntity *target,
 
404
    GType type)
380
405
{
381
406
  gchar *id_dir;
382
407
  gchar *timestamp;
383
408
  gchar *filename;
384
409
 
385
410
  id_dir = log_store_xml_get_dir (self, account, target);
386
 
  timestamp = log_store_xml_get_timestamp_filename ();
 
411
  timestamp = log_store_xml_get_timestamp_filename (type);
387
412
  filename = g_build_filename (id_dir, timestamp, NULL);
388
413
 
389
414
  g_free (id_dir);
401
426
    TpAccount *account,
402
427
    TplEntity *target,
403
428
    const gchar *event,
 
429
    GType type,
404
430
    GError **error)
405
431
{
406
432
  FILE *file;
413
439
  g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE);
414
440
  g_return_val_if_fail (TPL_IS_ENTITY (target), FALSE);
415
441
 
416
 
  filename = log_store_xml_get_filename (self, account, target);
 
442
  filename = log_store_xml_get_filename (self, account, target, type);
417
443
  basedir = g_path_get_dirname (filename);
418
444
 
419
445
  if (!g_file_test (basedir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
473
499
  gchar *timestamp = NULL;
474
500
  gchar *contact_name = NULL;
475
501
  gchar *contact_id = NULL;
476
 
  gchar *event = NULL;
 
502
  gchar *log_str = NULL;
477
503
  TpChannelTextMessageType msg_type;
478
504
 
479
505
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
509
535
  avatar_token = g_markup_escape_text (tpl_entity_get_avatar_token (sender),
510
536
      -1);
511
537
 
512
 
  event = g_strdup_printf ("<message time='%s' id='%s' name='%s' "
 
538
  log_str = g_strdup_printf ("<message time='%s' id='%s' name='%s' "
513
539
      "token='%s' isuser='%s' type='%s'>"
514
540
      "%s</message>\n" LOG_FOOTER, timestamp,
515
541
      contact_id, contact_name,
523
549
      contact_id, timestamp);
524
550
 
525
551
  ret = _log_store_xml_write_to_store (self, account,
526
 
      _tpl_event_get_target (TPL_EVENT (message)), event, error);
 
552
      _tpl_event_get_target (TPL_EVENT (message)), log_str, TPL_TYPE_TEXT_EVENT,
 
553
      error);
527
554
 
528
555
out:
529
556
  g_free (contact_id);
530
557
  g_free (contact_name);
531
558
  g_free (timestamp);
532
559
  g_free (body);
533
 
  g_free (event);
 
560
  g_free (log_str);
534
561
  g_free (avatar_token);
535
562
 
536
563
  if (bus_daemon != NULL)
615
642
      tpl_entity_get_identifier (target),
616
643
      timestamp);
617
644
 
618
 
  ret = _log_store_xml_write_to_store (self, account, target, log_str, error);
 
645
  ret = _log_store_xml_write_to_store (self, account, target, log_str,
 
646
      TPL_TYPE_CALL_EVENT, error);
619
647
 
620
648
out:
621
649
  g_free (sender_id);
657
685
  return TRUE;
658
686
}
659
687
 
 
688
static gboolean
 
689
log_store_xml_exists_in_directory (const gchar *dirname,
 
690
    GRegex *regex,
 
691
    gint type_mask,
 
692
    gboolean recursive)
 
693
{
 
694
  gboolean exists;
 
695
  const gchar *basename;
 
696
  GDir *dir;
 
697
 
 
698
  DEBUG ("Looking in directory '%s' %s",
 
699
      dirname, recursive ? "resursively" : "");
 
700
 
 
701
  dir = g_dir_open (dirname, 0, NULL);
 
702
  exists = (dir != NULL);
 
703
 
 
704
  if (CONTAINS_ALL_SUPPORTED_TYPES (type_mask) || !exists)
 
705
    goto out;
 
706
 
 
707
  exists = FALSE;
 
708
  while ((basename = g_dir_read_name (dir)) != NULL)
 
709
    {
 
710
      gchar *filename;
 
711
 
 
712
      filename = g_build_filename (dirname, basename, NULL);
 
713
 
 
714
      DEBUG ("Matching with filename '%s'", basename);
 
715
 
 
716
      if (recursive && g_file_test (filename, G_FILE_TEST_IS_DIR))
 
717
        exists = log_store_xml_exists_in_directory (filename, regex, type_mask,
 
718
            !tp_strdiff (basename, LOG_DIR_CHATROOMS));
 
719
      else if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
 
720
        exists = g_regex_match (regex, basename, 0, 0);
 
721
 
 
722
      g_free (filename);
 
723
 
 
724
      if (exists)
 
725
        break;
 
726
    }
 
727
 
 
728
out:
 
729
  if (dir != NULL)
 
730
    g_dir_close (dir);
 
731
 
 
732
  return exists;
 
733
}
 
734
 
 
735
 
 
736
static GRegex *
 
737
log_store_xml_create_filename_regex (gint type_mask)
 
738
{
 
739
  GString *pattern;
 
740
  GRegex *regex = NULL;
 
741
  GError *error = NULL;
 
742
 
 
743
  pattern = g_string_new ("");
 
744
 
 
745
  if (type_mask & TPL_EVENT_MASK_TEXT)
 
746
    g_string_append (pattern, LOG_FILENAME_PATTERN);
 
747
 
 
748
  if (type_mask & TPL_EVENT_MASK_CALL)
 
749
    g_string_append_printf (pattern,
 
750
        "%s" LOG_FILENAME_CALL_PATTERN,
 
751
        pattern->len == 0 ? "" : "|");
 
752
 
 
753
  if (pattern->len == 0)
 
754
    goto out;
 
755
 
 
756
  DEBUG ("Pattern is '%s'", pattern->str);
 
757
 
 
758
  regex = g_regex_new (pattern->str, G_REGEX_OPTIMIZE, 0, &error);
 
759
 
 
760
  if (regex == NULL)
 
761
    {
 
762
      DEBUG ("Failed to create regex: %s", error->message);
 
763
      g_error_free (error);
 
764
    }
 
765
 
 
766
out:
 
767
  g_string_free (pattern, TRUE);
 
768
 
 
769
  return regex;
 
770
}
 
771
 
660
772
 
661
773
static gboolean
662
774
log_store_xml_exists (TplLogStore *store,
665
777
    gint type_mask)
666
778
{
667
779
  TplLogStoreXml *self = (TplLogStoreXml *) store;
668
 
  gchar *dir;
669
 
  gboolean exists;
 
780
  gchar *dirname;
 
781
  GRegex *regex;
 
782
  gboolean exists = FALSE;
670
783
 
671
784
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), FALSE);
672
785
  g_return_val_if_fail (TP_IS_ACCOUNT (account), FALSE);
673
 
  g_return_val_if_fail (TPL_IS_ENTITY (target), FALSE);
674
 
 
675
 
  /* FIXME This method is exposed synchronously in the log manager API and
676
 
   * thus we need a constant time reply. The implementation is not 100%
677
 
   * correct here, but provide this constant time. See fd.o but #35549. */
678
 
 
679
 
  dir = log_store_xml_get_dir (self, account, target);
680
 
  exists = g_file_test (dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR);
681
 
  g_free (dir);
 
786
  g_return_val_if_fail (target == NULL || TPL_IS_ENTITY (target), FALSE);
 
787
 
 
788
  dirname = log_store_xml_get_dir (self, account, target);
 
789
  regex = log_store_xml_create_filename_regex (type_mask);
 
790
 
 
791
  if (regex != NULL)
 
792
    exists = log_store_xml_exists_in_directory (dirname, regex, type_mask,
 
793
        target == NULL);
 
794
 
 
795
  g_free (dirname);
 
796
 
 
797
  if (regex != NULL)
 
798
    g_regex_unref (regex);
682
799
 
683
800
  return exists;
684
801
}
752
869
  GDir *dir = NULL;
753
870
  GString *pattern = NULL;
754
871
  GRegex *regex = NULL;
755
 
  GError *error = NULL;
756
872
  const gchar *basename;
757
873
 
758
874
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), NULL);
768
884
    }
769
885
 
770
886
  DEBUG ("Collating a list of dates in:'%s'", directory);
771
 
 
772
 
  pattern = g_string_new ("");
773
 
 
774
 
  if (type_mask & TPL_EVENT_MASK_TEXT)
775
 
    g_string_append (pattern, "<message ");
776
 
 
777
 
  if (type_mask & TPL_EVENT_MASK_CALL)
778
 
    g_string_append_printf (pattern,
779
 
        "%s<call ",
780
 
        pattern->len == 0 ? "" : "|");
781
 
 
782
 
  if (pattern->len == 0)
 
887
  regex = log_store_xml_create_filename_regex (type_mask);
 
888
 
 
889
  if (regex == NULL)
783
890
    goto out;
784
891
 
785
 
  regex = g_regex_new (pattern->str, G_REGEX_OPTIMIZE, 0, &error);
786
 
  if (regex == NULL)
787
 
    {
788
 
      DEBUG ("Failed to create regex: %s", error->message);
789
 
      g_error_free (error);
790
 
      goto out;
791
 
    }
792
 
 
793
892
  while ((basename = g_dir_read_name (dir)) != NULL)
794
893
    {
795
 
      gchar *filename;
796
 
 
797
 
      if (!g_str_has_suffix (basename, LOG_FILENAME_SUFFIX))
798
 
        continue;
799
 
 
800
 
      filename = g_build_filename (directory, basename, NULL);
801
 
 
802
 
      if (CONTAINS_ALL_SUPPORTED_TYPES (type_mask)
803
 
          || log_store_xml_match_in_file (filename, regex))
804
 
        {
805
 
          const gchar *p;
806
 
          gchar *str;
807
 
          GDate *date;
808
 
 
809
 
          p = strstr (basename, LOG_FILENAME_SUFFIX);
810
 
          str = g_strndup (basename, p - basename);
811
 
 
812
 
          if (str == NULL)
813
 
            continue;
814
 
 
815
 
          date = create_date_from_string (str);
816
 
          if (date != NULL)
817
 
            dates = g_list_insert_sorted (dates, date,
818
 
                (GCompareFunc) g_date_compare);
819
 
 
820
 
          g_free (str);
821
 
        }
822
 
 
823
 
      g_free (filename);
 
894
      const gchar *p;
 
895
      gchar *str;
 
896
      GDate *date;
 
897
 
 
898
      if (!g_regex_match (regex, basename, 0, NULL))
 
899
        continue;
 
900
 
 
901
      p = strstr (basename, LOG_FILENAME_CALL_SUFFIX);
 
902
 
 
903
      if (p == NULL)
 
904
        p = strstr (basename, LOG_FILENAME_SUFFIX);
 
905
 
 
906
      str = g_strndup (basename, p - basename);
 
907
 
 
908
      if (str == NULL)
 
909
        continue;
 
910
 
 
911
      date = create_date_from_string (str);
 
912
 
 
913
      if (date != NULL)
 
914
        dates = g_list_insert_sorted (dates, date,
 
915
            (GCompareFunc) g_date_compare);
 
916
 
 
917
      g_free (str);
824
918
    }
825
919
 
826
920
out:
845
939
log_store_xml_get_filename_for_date (TplLogStoreXml *self,
846
940
    TpAccount *account,
847
941
    TplEntity *target,
848
 
    const GDate *date)
 
942
    const GDate *date,
 
943
    GType type)
849
944
{
850
945
  gchar *basedir;
851
946
  gchar *timestamp;
860
955
  g_date_strftime (str, 9, "%Y%m%d", date);
861
956
 
862
957
  basedir = log_store_xml_get_dir (self, account, target);
863
 
  timestamp = g_strconcat (str, LOG_FILENAME_SUFFIX, NULL);
 
958
  timestamp = g_strconcat (str, log_store_xml_get_file_suffix (type), NULL);
864
959
  filename = g_build_filename (basedir, timestamp, NULL);
865
960
 
866
961
  g_free (basedir);
1119
1214
}
1120
1215
 
1121
1216
/* returns a Glist of TplEvent instances */
1122
 
static GList *
 
1217
static void
1123
1218
log_store_xml_get_events_for_file (TplLogStoreXml *self,
1124
1219
    TpAccount *account,
1125
1220
    const gchar *filename,
1126
 
    gint type_mask)
 
1221
    GType type,
 
1222
    GQueue *events)
1127
1223
{
1128
 
  GQueue events = { 0 };
1129
1224
  xmlParserCtxtPtr ctxt;
1130
1225
  xmlDocPtr doc;
1131
1226
  xmlNodePtr log_node;
1136
1231
  gchar *target_id;
1137
1232
  gchar *self_id;
1138
1233
  GError *error = NULL;
 
1234
  guint num_events = 0;
 
1235
  GList *index;
1139
1236
 
1140
 
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), NULL);
1141
 
  g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
1142
 
  g_return_val_if_fail (!TPL_STR_EMPTY (filename), NULL);
 
1237
  g_return_if_fail (TPL_IS_LOG_STORE_XML (self));
 
1238
  g_return_if_fail (TP_IS_ACCOUNT (account));
 
1239
  g_return_if_fail (!TPL_STR_EMPTY (filename));
1143
1240
 
1144
1241
  DEBUG ("Attempting to parse filename:'%s'...", filename);
1145
1242
 
1146
1243
  if (!g_file_test (filename, G_FILE_TEST_EXISTS))
1147
1244
    {
1148
1245
      DEBUG ("Filename:'%s' does not exist", filename);
1149
 
      return NULL;
 
1246
      return;
1150
1247
    }
1151
1248
 
1152
1249
  if (!tp_account_parse_object_path (
1156
1253
      DEBUG ("Cannot get self identifier from account: %s",
1157
1254
          error->message);
1158
1255
      g_error_free (error);
1159
 
      return NULL;
 
1256
      return;
1160
1257
    }
1161
1258
 
1162
1259
  /* Create parser. */
1169
1266
      g_warning ("Failed to parse file:'%s'", filename);
1170
1267
      xmlFreeParserCtxt (ctxt);
1171
1268
      g_free (self_id);
1172
 
      return NULL;
 
1269
      return;
1173
1270
    }
1174
1271
 
1175
1272
  /* The root node, presets. */
1179
1276
      xmlFreeDoc (doc);
1180
1277
      xmlFreeParserCtxt (ctxt);
1181
1278
      g_free (self_id);
1182
 
      return NULL;
 
1279
      return;
1183
1280
    }
1184
1281
 
1185
1282
  /* Guess the target based on directory name */
1196
1293
  g_free (tmp);
1197
1294
 
1198
1295
  /* Now get the events. */
 
1296
  index = events->head;
1199
1297
  for (node = log_node->children; node; node = node->next)
1200
1298
    {
1201
1299
      TplEvent *event = NULL;
1202
1300
 
1203
 
      if (type_mask & TPL_EVENT_MASK_TEXT
 
1301
      if (type == TPL_TYPE_TEXT_EVENT
1204
1302
          && strcmp ((const gchar *) node->name, "message") == 0)
1205
1303
        event = parse_text_node (self, node, is_room, target_id, self_id,
1206
1304
            account);
1207
 
      else if (type_mask & TPL_EVENT_MASK_CALL
 
1305
      else if (type == TPL_TYPE_CALL_EVENT
1208
1306
          && strcmp ((const char*) node->name, "call") == 0)
1209
1307
        event = parse_call_node (self, node, is_room, target_id, self_id,
1210
1308
            account);
1211
1309
 
1212
1310
      if (event != NULL)
1213
 
        g_queue_push_tail (&events, event);
 
1311
        {
 
1312
          while (index != NULL &&
 
1313
              tpl_event_get_timestamp (event) <
 
1314
              tpl_event_get_timestamp (TPL_EVENT (index->data)))
 
1315
            index = g_list_next (index);
 
1316
 
 
1317
          if (index != NULL)
 
1318
            {
 
1319
              g_queue_insert_after (events, index, event);
 
1320
              index = g_list_next (index);
 
1321
            }
 
1322
          else
 
1323
            {
 
1324
              g_queue_push_tail (events, event);
 
1325
              index = events->head;
 
1326
            }
 
1327
 
 
1328
          num_events++;
 
1329
        }
1214
1330
    }
1215
1331
 
1216
 
  DEBUG ("Parsed %d events", events.length);
 
1332
  DEBUG ("Parsed %u events", num_events);
1217
1333
 
1218
1334
  g_free (target_id);
1219
1335
  xmlFreeDoc (doc);
1220
1336
  xmlFreeParserCtxt (ctxt);
1221
 
 
1222
 
  return events.head;
1223
1337
}
1224
1338
 
1225
1339
 
1227
1341
 * Used to make possible the full search vs. specific subtrees search */
1228
1342
static GList *
1229
1343
log_store_xml_get_all_files (TplLogStoreXml *self,
1230
 
    const gchar *dir)
 
1344
    const gchar *dir,
 
1345
    gint type_mask)
1231
1346
{
1232
1347
  GDir *gdir;
1233
1348
  GList *files = NULL;
1234
1349
  const gchar *name;
1235
1350
  const gchar *basedir;
 
1351
  GRegex *regex;
1236
1352
 
1237
1353
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), NULL);
1238
1354
  /* dir can be NULL, do not check */
1243
1359
  if (!gdir)
1244
1360
    return NULL;
1245
1361
 
 
1362
  regex = log_store_xml_create_filename_regex (type_mask);
 
1363
 
 
1364
  if (regex == NULL)
 
1365
    goto out;
 
1366
 
1246
1367
  while ((name = g_dir_read_name (gdir)) != NULL)
1247
1368
    {
1248
1369
      gchar *filename;
1249
1370
 
1250
1371
      filename = g_build_filename (basedir, name, NULL);
1251
 
      if (g_str_has_suffix (filename, LOG_FILENAME_SUFFIX))
1252
 
        {
1253
 
          files = g_list_prepend (files, filename);
1254
 
          continue;
1255
 
        }
1256
1372
 
1257
 
      if (g_file_test (filename, G_FILE_TEST_IS_DIR))
 
1373
      if (g_regex_match (regex, name, 0, NULL))
 
1374
        files = g_list_prepend (files, filename);
 
1375
      else if (g_file_test (filename, G_FILE_TEST_IS_DIR))
1258
1376
        {
1259
1377
          /* Recursively get all log files */
1260
1378
          files = g_list_concat (files,
1261
 
              log_store_xml_get_all_files (self,
1262
 
                filename));
 
1379
              log_store_xml_get_all_files (self, filename, type_mask));
 
1380
          g_free (filename);
1263
1381
        }
1264
 
 
1265
 
      g_free (filename);
1266
1382
    }
1267
1383
 
 
1384
out:
1268
1385
  g_dir_close (gdir);
1269
1386
 
 
1387
  if (regex != NULL)
 
1388
    g_regex_unref (regex);
 
1389
 
1270
1390
  return files;
1271
1391
}
1272
1392
 
1369
1489
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), NULL);
1370
1490
  g_return_val_if_fail (!TPL_STR_EMPTY (text), NULL);
1371
1491
 
1372
 
  files = log_store_xml_get_all_files (self, NULL);
 
1492
  files = log_store_xml_get_all_files (self, NULL, type_mask);
1373
1493
  DEBUG ("Found %d log files in total", g_list_length (files));
1374
1494
 
1375
1495
  return _log_store_xml_search_in_files (self, text, files, type_mask);
1435
1555
{
1436
1556
  TplLogStoreXml *self = (TplLogStoreXml *) store;
1437
1557
  gchar *filename;
1438
 
  GList *events;
 
1558
  GQueue events = G_QUEUE_INIT;
1439
1559
 
1440
1560
  g_return_val_if_fail (TPL_IS_LOG_STORE_XML (self), NULL);
1441
1561
  g_return_val_if_fail (TP_IS_ACCOUNT (account), NULL);
1442
1562
  g_return_val_if_fail (TPL_IS_ENTITY (target), NULL);
1443
1563
  g_return_val_if_fail (date != NULL, NULL);
1444
1564
 
1445
 
  filename = log_store_xml_get_filename_for_date (self, account, target,
1446
 
      date);
1447
 
  events = log_store_xml_get_events_for_file (self, account, filename, type_mask);
1448
 
  g_free (filename);
1449
 
 
1450
 
  return events;
 
1565
  if (type_mask & TPL_EVENT_MASK_TEXT)
 
1566
    {
 
1567
      filename = log_store_xml_get_filename_for_date (self, account, target,
 
1568
          date, TPL_TYPE_TEXT_EVENT);
 
1569
      log_store_xml_get_events_for_file (self, account, filename,
 
1570
          TPL_TYPE_TEXT_EVENT, &events);
 
1571
      g_free (filename);
 
1572
    }
 
1573
 
 
1574
  if (type_mask & TPL_EVENT_MASK_CALL)
 
1575
    {
 
1576
      filename = log_store_xml_get_filename_for_date (self, account, target,
 
1577
          date, TPL_TYPE_CALL_EVENT);
 
1578
      log_store_xml_get_events_for_file (self, account, filename,
 
1579
          TPL_TYPE_CALL_EVENT, &events);
 
1580
      g_free (filename);
 
1581
    }
 
1582
 
 
1583
  return events.head;
1451
1584
}
1452
1585
 
1453
1586