Util/ImLog.cs

   1 //
   2 // ImLog.cs
   3 //
   4 // Copyright (C) 2004 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to deal
  10 // in the Software without restriction, including without limitation the rights
  11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 // copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in all
  16 // copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24 // SOFTWARE.
  25 //
  26
  27 using System;
  28 using System.Collections;
  29 using System.IO;
  30 using System.Globalization;
  31 using System.Text;
  32 using System.Text.RegularExpressions;
  33 using System.Xml;
  34 using Mono.Unix.Native;
  35
  36 namespace Beagle.Util {
  37
  38         public enum ImClient {
  39                 Gaim,
  40                 Kopete,
  41         }
  42
  43         public abstract class ImLog {
  44
  45                 public delegate void Sink (ImLog imLog);
  46
  47                 public string Client;
  48                 public FileInfo File;
  49                 public TextReader TextReader;
  50                 public string Protocol;
  51
  52                 public DateTime StartTime;
  53                 public DateTime EndTime;
  54
  55                 public string SpeakingTo;
  56                 public string Identity;
  57
  58                 private Hashtable speakerHash = new Hashtable ();
  59
  60                 public class Utterance {
  61                         private long timestamp;
  62
  63                         public DateTime Timestamp {
  64                                 get { return NativeConvert.ToDateTime (timestamp); }
  65                                 set { timestamp = NativeConvert.FromDateTime (value); }
  66                         }
  67
  68                         public String Who;
  69                         public String Text;
  70                 }
  71                 private ArrayList utterances = new ArrayList ();
  72
  73                 //////////////////////////
  74
  75                 protected ImLog (string client, FileInfo file, TextReader reader)
  76                 {
  77                         Client = client;
  78                         TextReader = reader;
  79                         File = file;
  80                 }
  81
  82                 public ICollection Speakers {
  83                         get { return speakerHash.Keys; }
  84                 }
  85
  86                 public IList Utterances {
  87                         get { return utterances; }
  88                 }
  89
  90                 protected void AddUtterance (DateTime timestamp, string who, string text)
  91                 {
  92                         Utterance utt = new Utterance ();
  93                         utt.Timestamp = timestamp;
  94                         utt.Who = who;
  95                         utt.Text = text.Trim ();
  96
  97                         if (StartTime.Ticks == 0 || StartTime > timestamp)
  98                                 StartTime = timestamp;
  99
 100                         if (EndTime.Ticks == 0 || EndTime < timestamp)
 101                                 EndTime = timestamp;
 102
 103                         speakerHash [who] = true;
 104
 105                         utterances.Add (utt);
 106                 }
 107
 108                 protected void AppendToPreviousUtterance (string text)
 109                 {
 110                         if (utterances.Count > 0) {
 111                                 Utterance utt = (Utterance) utterances [utterances.Count - 1];
 112                                 utt.Text += "\n" + text;
 113                         }
 114                 }
 115
 116                 protected void ClearUtterances ()
 117                 {
 118                         utterances.Clear ();
 119                 }
 120
 121                 protected abstract void Load ();
 122         }
 123
 124         ///////////////////////////////////////////////////////////////////////////////
 125
 126         //
 127         // Gaim Logs
 128         //
 129
 130         public class GaimLog : ImLog {
 131
 132                 public const string MimeType = "beagle/x-gaim-log";
 133
 134                 ///////////////////////////////////////
 135
 136                 public GaimLog (FileInfo file, TextReader reader) : base ("gaim", file, reader)
 137                 {
 138                         string filename = file.Name;
 139
 140                         // Parse what we can from the file path
 141                         try {
 142                                 string str;
 143
 144                                 // Character at position 17 will be either a dot, indicating the beginning
 145                                 // of the extension for old gaim logs, or a plus or minus indicating a
 146                                 // timezone offset for new gaim logs.
 147                                 if (filename [17] == '+' || filename [17] == '-') {
 148                                         // New gaim 2.0.0 format, including timezone.
 149                                         //
 150                                         // Ugly hack time: DateTime's format specifiers only know how to
 151                                         // deal with timezones in the format "+HH:mm" and not "+HHmm",
 152                                         // which is how UNIX traditionally encodes them.  I have no idea
 153                                         // why; it would make RFC 822/1123 parsing a hell of a lot easier.
 154                                         // Anyway, in this case, we're going to insert a colon in there so
 155                                         // that DateTime.ParseExact can understand it.
 156                                         //
 157                                         // 2006-02-21-160424-0500EST.html
 158                                         //                     ^
 159                                         //                     offset 20
 160
 161                                         str = filename.Substring (0, 20) + ':' + filename.Substring (20, 2);
 162                                         StartTime = DateTime.ParseExact (str, "yyyy-MM-dd.HHmmsszzz", null);
 163                                 } else if (filename [17] == '.') {
 164                                         // Older gaim format.
 165                                         //
 166                                         // 2006-02-21-160424.html
 167
 168                                         str = Path.GetFileNameWithoutExtension (filename);
 169                                         StartTime = DateTime.ParseExact (str, "yyyy-MM-dd.HHmmss", null);
 170                                 } else {
 171                                         throw new FormatException ();
 172                                 }
 173                         } catch {
 174                                 Logger.Log.Warn ("Could not parse date/time from filename '{0}'", file.Name);
 175                                 StartTime = DateTime.Now;
 176                         }
 177
 178                         // Gaim likes to represent many characters in hex-escaped %xx form
 179                         SpeakingTo = StringFu.HexUnescape (file.Directory.Name);
 180                         Identity = StringFu.HexUnescape (file.Directory.Parent.Name);
 181
 182                         Protocol = file.Directory.Parent.Parent.Name;
 183
 184                         Load ();
 185                 }
 186
 187                 // Return true if a new utterance is now available,
 188                 // and false if the previous utterance was changed.
 189                 private void ProcessLine (string line)
 190                 {
 191                         if (line.Length == 0)
 192                                 return;
 193
 194                         if (line [0] != '(') {
 195                                 AppendToPreviousUtterance (line);
 196                                 return;
 197                         }
 198                         int j = line.IndexOf (')');
 199                         if (j == -1) {
 200                                 AppendToPreviousUtterance (line);
 201                                 return;
 202                         }
 203
 204                         // Gaim 2.0
 205                         // The new version of Gaim adds AM or PM right after the time
 206                         // 1.x: (19:07:07)
 207                         // 2.0: (19:07:07 AM)
 208
 209                         string when = line.Substring (1, j-1);
 210                         DateTime timestamp;
 211
 212                         try {
 213                                 DateTime time = DateTime.Parse (when);
 214
 215                                 timestamp = new DateTime (StartTime.Year, StartTime.Month, StartTime.Day,
 216                                                 time.Hour, time.Minute, time.Second);
 217
 218                                 // Try to deal with time wrapping around.
 219                                 if (timestamp < EndTime)
 220                                         timestamp.AddDays (1);
 221                         } catch {
 222                                 // If something goes wrong, this line probably
 223                                 // spills over from the previous one.
 224                                 AppendToPreviousUtterance (line);
 225                                 return;
 226                         }
 227
 228                         line = line.Substring (j+2);
 229
 230                         // Extract the alias
 231                         string alias, text;
 232                         int i;
 233
 234                         if (line.StartsWith ("***")) {
 235                                 i = line.IndexOf (' ');
 236
 237                                 alias = line.Substring (3, i - 3);
 238                                 text = line.Substring (i + 1);
 239                         } else {
 240                                 // FIXME: This will break if there is a ':' in the nickname
 241                                 i = line.IndexOf (':');
 242                                 if (i == -1 || line.Length < i + 2)
 243                                         return;
 244
 245                                 alias = line.Substring (0, i);
 246                                 text = line.Substring (i + 2);
 247                         }
 248
 249                         AddUtterance (timestamp, alias, text);
 250
 251                         return;
 252                 }
 253
 254                 protected override void Load ()
 255                 {
 256                         string line;
 257
 258                         ClearUtterances ();
 259                         StringBuilder builder;
 260                         builder = new StringBuilder ();
 261
 262                         line = TextReader.ReadLine (); // throw away first line
 263                         if (line == null)
 264                                 return;
 265
 266                         // Could the second line ever start w/ < in a non-html log?
 267                         // I hope not!
 268                         bool isHtml = line.Length > 0 && line [0] == '<';
 269
 270                         while ((line = TextReader.ReadLine ()) != null) {
 271                                 if (isHtml)
 272                                         line = StringFu.StripTags (line, builder);
 273
 274                                 try {
 275                                         ProcessLine (line);
 276                                 } catch (Exception e) {
 277                                         Logger.Log.Warn ("Could not parse line in '{0}'", File.FullName);
 278                                         Logger.Log.Warn (e);
 279                                 }
 280                         }
 281                 }
 282         }
 283
 284         ///////////////////////////////////////////////////////////////////////////////
 285
 286         //
 287         // Kopete Logs
 288         //
 289         public class KopeteLog : ImLog {
 290
 291                 public const string MimeType = "beagle/x-kopete-log";
 292
 293                 public KopeteLog (FileInfo file, TextReader reader) : base ("kopete", file, reader)
 294                 {
 295                         // FIXME: Artificially split logs into conversations depending on the
 296                         // amount of time elapsed betweet messages?
 297
 298                         // Figure out the protocol from the parent.parent or parent foldername
 299                         if (file.Directory.Parent.Name.EndsWith ("Protocol"))
 300                                 Protocol = file.Directory.Parent.Name.Substring (0, file.Directory.Parent.Name.Length - 8).ToLower ();
 301                         else if (file.Directory.Name.EndsWith ("Protocol"))
 302                                 Protocol = file.Directory.Name.Substring (0, file.Directory.Name.Length - 8).ToLower ();
 303                         else
 304                                 Protocol = file.Directory.Name;
 305                         Identity = file.Directory.Name;
 306
 307                         // FIXME: This is not safe for all kinds of file/screennames
 308                         string filename = Path.GetFileNameWithoutExtension (file.Name);
 309                         if (filename.LastIndexOf ('.') > 0)
 310                                 SpeakingTo = filename.Substring (0, filename.LastIndexOf ('.'));
 311                         else if (filename.LastIndexOf ('_') > 0)
 312                                 SpeakingTo = filename.Substring (0, filename.LastIndexOf ('_'));
 313                         else
 314                                 SpeakingTo = filename;
 315                         Logger.Log.Debug ("Speakingto for " + file.Name + " is " + SpeakingTo + ", protocol is " + Protocol);
 316                         Load ();
 317                 }
 318
 319                 private const string date_format = "yyyy M d H:m:s";
 320
 321                 protected override void Load ()
 322                 {
 323                         ClearUtterances ();
 324
 325                         XmlReader reader;
 326                         DateTime base_date = DateTime.MinValue;
 327
 328                         try {
 329                                 reader = new XmlTextReader (File.Open(
 330                                                                              FileMode.Open,
 331                                                                              FileAccess.Read,
 332                                                                              FileShare.Read));
 333                         } catch (Exception e) {
 334                                 Console.WriteLine ("Could not open '{0}'", File.FullName);
 335                                 Console.WriteLine (e);
 336                                 return;
 337                         }
 338
 339                         while (reader.Read ()) {
 340                                 if (reader.NodeType != XmlNodeType.Element)
 341                                         continue;
 342
 343                                 switch (reader.Name) {
 344                                 case "date":
 345                                         base_date = new DateTime (Convert.ToInt32 (reader.GetAttribute ("year")),
 346                                                                   Convert.ToInt32 (reader.GetAttribute ("month")),
 347                                                                   1);
 348                                         break;
 349
 350                                 case "msg":
 351                                         // Parse the timestamp of the message
 352                                         string timestamp = String.Format ("{0} {1} {2}",
 353                                                                           base_date.Year,
 354                                                                           base_date.Month,
 355                                                                           reader.GetAttribute ("time"));
 356                                         int time_separator_count = 0;
 357                                         foreach (int the_char in timestamp)
 358                                                 if (the_char == ':')
 359                                                         time_separator_count++;
 360                                         if (time_separator_count < 2)
 361                                                 timestamp = timestamp + ":00";
 362
 363                                         DateTime msg_date = DateTime.MinValue;
 364
 365                                         try {
 366                                                 msg_date = DateTime.ParseExact (timestamp,
 367                                                                                 date_format,
 368                                                                                 null);
 369                                         } catch {
 370                                                 Logger.Log.Error ("Couldn't parse Kopete timestamp: {0}", timestamp);
 371                                                 break;
 372                                         }
 373
 374                                         string who = reader.GetAttribute ("nick");
 375                                         if (who == null || who == "")
 376                                                 who = reader.GetAttribute ("from");
 377                                         if (who == null || who == "")
 378                                                 break;
 379
 380                                         // Advance to the text node for the actual message
 381                                         reader.Read ();
 382
 383                                         AddUtterance (msg_date, who, reader.Value);
 384                                         break;
 385                                 }
 386                         }
 387
 388                         reader.Close ();
 389                 }
 390
 391         }
 392 }
 393