Util/camel.cs

   1 //
   2 // camel.cs: Parser for Evolution mbox summary files.
   3 //
   4 // Authors:
   5 //    Miguel de Icaza <miguel@ximian.com>
   6 //
   7 //    Imap support by Erik Bågfors <erik@bagfors.nu>
   8 //
   9
  10 using System.IO;
  11 using System;
  12 using System.Collections;
  13 using System.Globalization;
  14 using System.Text;
  15
  16 namespace Beagle.Util {
  17 namespace Camel {
  18
  19         public enum CamelFlags : uint {
  20                 Answered     = 1 << 0,
  21                 Deleted      = 1 << 1,
  22                 Draft        = 1 << 2,
  23                 Flagged      = 1 << 3,
  24                 Seen         = 1 << 4,
  25                 Attachments  = 1 << 5,
  26                 AnsweredAll  = 1 << 6,
  27                 Junk         = 1 << 7,
  28                 Secure       = 1 << 8
  29         }
  30
  31 public abstract class Summary : IEnumerable {
  32         public SummaryHeader header;
  33         internal string filename;
  34
  35         public static Summary LoadMBoxSummary (string file)
  36         {
  37                 Summary s = new MBoxSummary ();
  38                 s.Load (file);
  39
  40                 return s;
  41         }
  42
  43         public static Summary LoadImapSummary (string file)
  44         {
  45                 Summary s = new ImapSummary ();
  46                 s.Load (file);
  47
  48                 return s;
  49         }
  50
  51         public static Summary LoadImap4Summary (string file)
  52         {
  53                 Summary s = new Imap4Summary ();
  54                 s.Load (file);
  55
  56                 return s;
  57         }
  58
  59         private void Load (string file)
  60         {
  61                 this.filename = file;
  62                 FileStream f = File.OpenRead (file);
  63                 this.header = this.ReadHeader (f);
  64                 f.Close ();
  65         }
  66
  67         public IEnumerator GetEnumerator () {
  68                 return new SummaryEnumerator (this);
  69         }
  70
  71         protected abstract SummaryHeader ReadHeader (FileStream f);
  72         protected abstract MessageInfo ReadMessageInfo (FileStream f);
  73
  74         private class SummaryEnumerator : IEnumerator, IDisposable {
  75                 FileStream f = null;
  76                 SummaryHeader header;
  77                 Summary s;
  78                 int index;
  79                 MessageInfo info;
  80                 public SummaryEnumerator (Summary s) {
  81                         this.s = s;
  82                         index = -1;
  83                 }
  84
  85                 public void Dispose ()
  86                 {
  87                         if (f != null) {
  88                                 f.Close ();
  89                                 f = null;
  90                         }
  91                         GC.SuppressFinalize (this);
  92                 }
  93
  94                 ~SummaryEnumerator ()
  95                 {
  96                         if (f != null) {
  97                                 f.Close ();
  98                         }
  99                 }
 100
 101                 public bool MoveNext () {
 102                         ++index;
 103                         if (index == 0) {
 104                                 f = File.OpenRead (s.filename);
 105                                 header = s.ReadHeader (f);
 106                         }
 107
 108                         if (index >= header.count) {
 109                                 if (f != null) {
 110                                         f.Close ();
 111                                         f = null;
 112                                 }
 113                                 return false;
 114                         } else {
 115                                 info = null;
 116                                 while (info == null && index < header.count) {
 117                                         try {
 118                                                 info = s.ReadMessageInfo (f);
 119                                         } catch (Exception e) {
 120                                                 Logger.Log.Warn ("Skipping bogus message " +
 121                                                                  "[file={0}, index={1}, error={2}]",
 122                                                                  s.filename, index, e.ToString());
 123
 124                                                 info = null;
 125                                                 ++index;
 126                                         }
 127                                 }
 128
 129                                 return (info != null);
 130                         }
 131                 }
 132
 133                 public object Current {
 134                         get { return info; }
 135                 }
 136
 137                 public void Reset ()
 138                 {
 139                         f.Close ();
 140                         f = null;
 141                         index = -1;
 142                 }
 143         }
 144 }
 145
 146         public class MBoxSummary: Summary {
 147                 public MBoxSummary ()
 148                 {
 149                 }
 150
 151                 protected override SummaryHeader ReadHeader (FileStream f)
 152                 {
 153                         return new MBoxSummaryHeader (f);
 154                 }
 155
 156                 protected override MessageInfo ReadMessageInfo (FileStream f)
 157                 {
 158                         return new MBoxMessageInfo (f);
 159                 }
 160         }
 161
 162         public class ImapSummary: Summary {
 163                 public ImapSummary ()
 164                 {
 165                 }
 166
 167                 protected override SummaryHeader ReadHeader (FileStream f)
 168                 {
 169                         return new ImapSummaryHeader (f);
 170                 }
 171
 172                 protected override MessageInfo ReadMessageInfo (FileStream f)
 173                 {
 174                         return new ImapMessageInfo (f, true);
 175                 }
 176         }
 177
 178         public class Imap4Summary : Summary {
 179                 public Imap4Summary ()
 180                 {
 181                 }
 182
 183                 protected override SummaryHeader ReadHeader (FileStream f)
 184                 {
 185                         return new ImapSummaryHeader (f);
 186                 }
 187
 188                 protected override MessageInfo ReadMessageInfo (FileStream f)
 189                 {
 190                         return new ImapMessageInfo (f, false);
 191                 }
 192         }
 193
 194         public class MessageInfo {
 195                 public string uid, subject, from, to, cc, mlist;
 196                 public uint size, flags;
 197                 public DateTime sent, received;
 198
 199                 private void SkipContentInfo (FileStream f)
 200                 {
 201                         Decode.SkipToken (f); // type
 202                         Decode.SkipToken (f); // subtype
 203                         uint count = Decode.UInt (f); // count
 204                         for (int i = 0; i < count; ++i) {
 205                                 Decode.SkipToken (f); // name
 206                                 Decode.SkipToken (f); // value
 207                         }
 208                         Decode.SkipToken (f); // id
 209                         Decode.SkipToken (f); // description
 210                         Decode.SkipToken (f); // encoding
 211                         Decode.UInt (f); // size
 212
 213                         count = Decode.UInt (f); // child count
 214                         for (int i = 0; i < count; ++i) // recursively skip children
 215                                 SkipContentInfo (f);
 216                 }
 217
 218                 public MessageInfo (FileStream f)
 219                 {
 220                         uid      = Decode.String (f);
 221                         flags    = Decode.UInt (f);
 222                         size     = Decode.UInt (f);
 223                         sent     = Decode.Time (f);
 224                         received = Decode.Time (f);
 225                         subject  = Decode.String (f);
 226                         from     = Decode.String (f);
 227                         to       = Decode.String (f);
 228                         cc       = Decode.String (f);
 229                         mlist    = Decode.String (f);
 230
 231                         Decode.SkipFixedInt (f);
 232                         Decode.SkipFixedInt (f);
 233
 234                         uint count;
 235
 236                         // references
 237                         count = Decode.UInt (f);
 238                         if (count > 0) {
 239                                 for (int i = 0; i < count; i++) {
 240                                         Decode.SkipFixedInt (f);
 241                                         Decode.SkipFixedInt (f);
 242                                 }
 243                         }
 244
 245                         // user flags
 246                         count = Decode.UInt (f);
 247                         if (count > 0) {
 248                                 for (int i = 0; i < count; i++) {
 249                                         Decode.SkipString (f);
 250                                 }
 251                         }
 252
 253                         // user tags
 254                         count = Decode.UInt (f);
 255                         if (count > 0){
 256                                 for (int i = 0; i < count; i++){
 257                                         Decode.SkipString (f);
 258                                         Decode.SkipString (f);
 259                                 }
 260                         }
 261
 262                         // FIXME: How do we know if there is content info in there?
 263                         // SkipContentInfo (f);
 264                 }
 265
 266                 public override string ToString ()
 267                 {
 268                         return String.Format ("From: {0}\nTo: {1}\nSubject: {2}\nUID: {3}\n", from, to, subject, uid);
 269                 }
 270
 271                 public DateTime Date {
 272                         get { return received.Ticks != 0 ? received : sent; }
 273                 }
 274
 275                 private bool CheckFlag (CamelFlags test)
 276                 {
 277                         return (flags & (uint) test) == (uint) test;
 278                 }
 279
 280                 public bool IsAnswered {
 281                         get { return CheckFlag (CamelFlags.Answered); }
 282                 }
 283
 284                 public bool IsDeleted {
 285                         get { return CheckFlag (CamelFlags.Deleted); }
 286                 }
 287
 288                 public bool IsDraft {
 289                         get { return CheckFlag (CamelFlags.Draft); }
 290                 }
 291
 292                 public bool IsFlagged {
 293                         get { return CheckFlag (CamelFlags.Flagged); }
 294                 }
 295
 296                 public bool IsSeen {
 297                         get { return CheckFlag (CamelFlags.Seen); }
 298                 }
 299
 300                 public bool HasAttachments {
 301                         get { return CheckFlag (CamelFlags.Attachments); }
 302                 }
 303
 304                 public bool IsAnsweredAll {
 305                         get { return CheckFlag (CamelFlags.AnsweredAll); }
 306                 }
 307
 308                 public bool IsJunk {
 309                         get { return CheckFlag (CamelFlags.Junk); }
 310                 }
 311
 312                 public bool IsSecure {
 313                         get { return CheckFlag (CamelFlags.Secure); }
 314                 }
 315         }
 316
 317         public class MBoxMessageInfo : MessageInfo {
 318                 public uint from_pos;
 319
 320                 public MBoxMessageInfo (FileStream f) : base (f)
 321                 {
 322                         from_pos = Decode.Offset (f);
 323                 }
 324
 325                 public override string ToString ()
 326                 {
 327                         return String.Format ("From: {0}\nTo: {1}\nSubject: {2}\nPos: {3} Size: {4}\n", from, to, subject,
 328                                               from_pos, size);
 329                 }
 330         }
 331
 332
 333
 334         public class ImapMessageInfo : MessageInfo {
 335                 public uint server_flags;
 336
 337                 public ImapMessageInfo (FileStream f, bool content_info_load) : base (f)
 338                 {
 339                         server_flags = Decode.UInt (f);
 340
 341                         if (content_info_load)
 342                                 PerformContentInfoLoad (f);
 343                 }
 344
 345                 public override string ToString ()
 346                 {
 347                         return String.Format ("From: {0}\nTo: {1}\nSubject: {2}\nSize: {3}\n", from, to, subject, size);
 348                 }
 349
 350                 private bool PerformContentInfoLoad (FileStream f)
 351                 {
 352                     bool ci = ContentInfoLoad (f);
 353                     if (!ci)
 354                         return false;
 355
 356                     uint count = Decode.UInt (f);
 357                     if (count == -1 || count > 500) {
 358                         return false;
 359                     }
 360
 361                     for (int i = 0; i < count; i++) {
 362
 363                         bool part = PerformContentInfoLoad (f);
 364                         if (!part)
 365                             throw new Exception ();
 366                     }
 367                     return true;
 368                 }
 369
 370                 private bool ContentInfoLoad (FileStream f)
 371                 {
 372                     if (f.ReadByte () == 0)
 373                         return true;
 374
 375                     // type
 376                     Decode.SkipToken (f);
 377                     // subtype
 378                     Decode.SkipToken (f);
 379
 380                     uint count;
 381                     count = Decode.UInt (f);
 382                     if (count == -1 || count > 500)
 383                         return false;
 384                     for (int i = 0; i < count; i++) {
 385                         // Name
 386                         Decode.SkipToken (f);
 387                         // Value
 388                         Decode.SkipToken (f);
 389                     }
 390
 391                     // id
 392                     Decode.SkipToken (f);
 393
 394                     // description
 395                     Decode.SkipToken (f);
 396
 397                     // encoding
 398                     Decode.SkipToken (f);
 399
 400                     // size
 401                     Decode.UInt (f);
 402                     return true;
 403                 }
 404         }
 405
 406         public class SummaryHeader {
 407                 public int      version;
 408                 public int      flags;
 409                 public int      nextuid;
 410                 public DateTime time;
 411                 public int      count;
 412                 public int      unread;
 413                 public int      deleted;
 414                 public int      junk;
 415
 416                 public SummaryHeader (FileStream f)
 417                 {
 418                         bool legacy;
 419
 420                         version = Decode.FixedInt (f);
 421
 422                         if (version > 0xff && (version & 0xff) < 12)
 423                                 throw new Exception ("Summary header version too low");
 424
 425                         if (version < 0x100 && version >= 13)
 426                                 legacy = false;
 427                         else
 428                                 legacy = true;
 429
 430                         flags   = Decode.FixedInt (f);
 431                         nextuid = Decode.FixedInt (f);
 432                         time    = Decode.Time (f);
 433                         count   = Decode.FixedInt (f);
 434
 435                         if (!legacy) {
 436                                 unread  = Decode.FixedInt (f);
 437                                 deleted = Decode.FixedInt (f);
 438                                 junk    = Decode.FixedInt (f);
 439                         }
 440
 441                         //Console.WriteLine ("V={0} ({1}) time={2}, count={3} unread={4} deleted={5} junk={6}", version, version & 0xff, time, count, unread, deleted, junk);
 442                 }
 443         }
 444
 445         public class MBoxSummaryHeader : SummaryHeader {
 446                 public int local_version;
 447                 public int mbox_version;
 448                 public int folder_size;
 449
 450                 public MBoxSummaryHeader (FileStream f) : base (f)
 451                 {
 452                         local_version = Decode.FixedInt (f);
 453                         mbox_version = Decode.FixedInt (f);
 454                         folder_size = Decode.FixedInt (f);
 455
 456                         //Console.WriteLine ("local_version={0}  mbox_version={1}  folder_size={2}", local_version, mbox_version, folder_size);
 457                 }
 458         }
 459
 460         public class ImapSummaryHeader : SummaryHeader {
 461
 462                 public ImapSummaryHeader (FileStream f) : base (f)
 463                 {
 464                         // Check for legacy version
 465                         if (base.version != 0x30c) { // 780
 466                                 int version = Decode.FixedInt (f);
 467
 468                                 //Console.WriteLine ("imap version={0}", version);
 469
 470                                 if (version < 0)
 471                                         throw new Exception ("IMAP summary version too low");
 472
 473                                 // Right now we only support summary versions 1 through 3
 474                                 if (version > 3)
 475                                         throw new Exception (String.Format ("Reported summary version ({0}) is too new", version));
 476
 477                                 if (version == 2)
 478                                         Decode.FixedInt (f);
 479
 480                                 // validity
 481                                 Decode.SkipFixedInt (f);
 482                         } else {
 483                                 // validity
 484                                 Decode.UInt (f);
 485                         }
 486                 }
 487         }
 488
 489         public class Decode {
 490                 static Encoding e = Encoding.UTF8;
 491                 static long UnixBaseTicks;
 492
 493                 static Decode ()
 494                 {
 495                         UnixBaseTicks = new DateTime (1970, 1, 1, 0, 0, 0).Ticks;
 496                 }
 497
 498                 public static string Token (FileStream f)
 499                 {
 500                     int len = (int) UInt (f);
 501                     if (len < 32) {
 502                         if (len <= 0)
 503                             return "NULL";
 504
 505                         // Ok, this is a token from the list, we can ignore it
 506                         return "token_from_list";
 507                     } else if (len < 0 || len > 10240) {
 508                         throw new Exception ();
 509                     } else {
 510                         len -= 32;
 511                         byte [] buffer = new byte [len];
 512                         f.Read (buffer, 0, (int) len);
 513                         return new System.String (e.GetChars (buffer, 0, len));
 514                     }
 515                 }
 516
 517                 public static void SkipToken (FileStream f)
 518                 {
 519                         int len = (int) UInt (f);
 520                         len -= 32;
 521                         if (len > 0)
 522                                 f.Seek (len, SeekOrigin.Current);
 523                 }
 524
 525                 public static string String (FileStream f)
 526                 {
 527                         int len = (int) UInt (f);
 528                         len--;
 529
 530                         if (len < 0 || len > 65535)
 531                                 throw new Exception ();
 532                         byte [] buffer = new byte [len];
 533                         f.Read (buffer, 0, (int) len);
 534                         return new System.String (e.GetChars (buffer, 0, len));
 535                 }
 536
 537                 public static void SkipString (FileStream f)
 538                 {
 539                         int len = (int) UInt (f);
 540                         --len;
 541                         if (len > 0)
 542                                 f.Seek (len, SeekOrigin.Current);
 543                 }
 544
 545                 public static uint UInt (FileStream f)
 546                 {
 547                         uint value = 0;
 548                         int v;
 549
 550                         while (((v = f.ReadByte ()) & 0x80) == 0 && v != -1){
 551                                 value |= (byte) v;
 552                                 value <<= 7;
 553                         }
 554                         return value | ((byte)(v & 0x7f));
 555                 }
 556
 557                 public static int FixedInt (FileStream f)
 558                 {
 559                         byte [] b = new byte [4];
 560
 561                         f.Read (b, 0, 4);
 562
 563                         return (b [0] << 24) | (b [1] << 16) | (b [2] << 8) | b [3];
 564                 }
 565
 566                 public static void SkipFixedInt (FileStream f)
 567                 {
 568                         f.Seek (4, SeekOrigin.Current);
 569                 }
 570
 571                 public static DateTime Time (FileStream f)
 572                 {
 573                         long seconds = 0;
 574
 575                         // FIXME: Is it safe to assume that sizeof (time_t) == IntPtr.Size?  Probably not.
 576                         for (int i = IntPtr.Size - 1; i >= 0; i--) {
 577                                 int v = f.ReadByte ();
 578
 579                                 seconds |= v << (i * 8);
 580                         }
 581
 582                         if (seconds == 0)
 583                                 return new DateTime (0);
 584
 585                         return new DateTime (UnixBaseTicks).AddSeconds (seconds);
 586                 }
 587
 588                 public static uint Offset (FileStream f)
 589                 {
 590                         byte [] b = new byte [4];
 591
 592                         f.Read (b, 0, 4);
 593
 594                         return (uint)((b [0] << 24) | (b [1] << 16) | (b [2] << 8) | b [3]);
 595                 }
 596         }
 597
 598 #if false
 599         class Test {
 600                 void Main (string [] args)
 601                 {
 602                         string file;
 603
 604                         if (args.Length == 0)
 605                                 file = "./summary";
 606                         else
 607                                 file = args [0];
 608
 609                         Summary s = Summary.LoadMBoxSummary (file);
 610                         foreach (MessageInfo m in s) {
 611                                 Console.WriteLine(m);
 612                         }
 613
 614                 }
 615
 616         }
 617 #endif
 618 }
 619 }