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 SentDate {
 272                         get { return sent; }
 273                 }
 274
 275                 public DateTime ReceivedDate {
 276                         get { return received; }
 277                 }
 278
 279                 private bool CheckFlag (CamelFlags test)
 280                 {
 281                         return (flags & (uint) test) == (uint) test;
 282                 }
 283
 284                 public bool IsAnswered {
 285                         get { return CheckFlag (CamelFlags.Answered); }
 286                 }
 287
 288                 public bool IsDeleted {
 289                         get { return CheckFlag (CamelFlags.Deleted); }
 290                 }
 291
 292                 public bool IsDraft {
 293                         get { return CheckFlag (CamelFlags.Draft); }
 294                 }
 295
 296                 public bool IsFlagged {
 297                         get { return CheckFlag (CamelFlags.Flagged); }
 298                 }
 299
 300                 public bool IsSeen {
 301                         get { return CheckFlag (CamelFlags.Seen); }
 302                 }
 303
 304                 public bool HasAttachments {
 305                         get { return CheckFlag (CamelFlags.Attachments); }
 306                 }
 307
 308                 public bool IsAnsweredAll {
 309                         get { return CheckFlag (CamelFlags.AnsweredAll); }
 310                 }
 311
 312                 public bool IsJunk {
 313                         get { return CheckFlag (CamelFlags.Junk); }
 314                 }
 315
 316                 public bool IsSecure {
 317                         get { return CheckFlag (CamelFlags.Secure); }
 318                 }
 319         }
 320
 321         public class MBoxMessageInfo : MessageInfo {
 322                 public uint from_pos;
 323
 324                 public MBoxMessageInfo (FileStream f) : base (f)
 325                 {
 326                         from_pos = Decode.Offset (f);
 327                 }
 328
 329                 public override string ToString ()
 330                 {
 331                         return String.Format ("From: {0}\nTo: {1}\nSubject: {2}\nPos: {3} Size: {4}\n", from, to, subject,
 332                                               from_pos, size);
 333                 }
 334         }
 335
 336
 337
 338         public class ImapMessageInfo : MessageInfo {
 339                 public uint server_flags;
 340
 341                 public ImapMessageInfo (FileStream f, bool content_info_load) : base (f)
 342                 {
 343                         server_flags = Decode.UInt (f);
 344
 345                         if (content_info_load)
 346                                 PerformContentInfoLoad (f);
 347                 }
 348
 349                 public override string ToString ()
 350                 {
 351                         return String.Format ("From: {0}\nTo: {1}\nSubject: {2}\nSize: {3}\n", from, to, subject, size);
 352                 }
 353
 354                 private bool PerformContentInfoLoad (FileStream f)
 355                 {
 356                     bool ci = ContentInfoLoad (f);
 357                     if (!ci)
 358                         return false;
 359
 360                     uint count = Decode.UInt (f);
 361                     if (count > 500) {
 362                         return false;
 363                     }
 364
 365                     for (int i = 0; i < count; i++) {
 366
 367                         bool part = PerformContentInfoLoad (f);
 368                         if (!part)
 369                             throw new Exception ();
 370                     }
 371                     return true;
 372                 }
 373
 374                 private bool ContentInfoLoad (FileStream f)
 375                 {
 376                     if (f.ReadByte () == 0)
 377                         return true;
 378
 379                     // type
 380                     Decode.SkipToken (f);
 381                     // subtype
 382                     Decode.SkipToken (f);
 383
 384                     uint count;
 385                     count = Decode.UInt (f);
 386                     if (count > 500)
 387                         return false;
 388
 389                     for (int i = 0; i < count; i++) {
 390                         // Name
 391                         Decode.SkipToken (f);
 392                         // Value
 393                         Decode.SkipToken (f);
 394                     }
 395
 396                     // id
 397                     Decode.SkipToken (f);
 398
 399                     // description
 400                     Decode.SkipToken (f);
 401
 402                     // encoding
 403                     Decode.SkipToken (f);
 404
 405                     // size
 406                     Decode.UInt (f);
 407                     return true;
 408                 }
 409         }
 410
 411         public class SummaryHeader {
 412                 public int      version;
 413                 public int      flags;
 414                 public int      nextuid;
 415                 public DateTime time;
 416                 public int      count;
 417                 public int      unread;
 418                 public int      deleted;
 419                 public int      junk;
 420
 421                 public SummaryHeader (FileStream f)
 422                 {
 423                         bool legacy;
 424
 425                         version = Decode.FixedInt (f);
 426
 427                         if (version > 0xff && (version & 0xff) < 12)
 428                                 throw new Exception ("Summary header version too low");
 429
 430                         if (version < 0x100 && version >= 13)
 431                                 legacy = false;
 432                         else
 433                                 legacy = true;
 434
 435                         flags   = Decode.FixedInt (f);
 436                         nextuid = Decode.FixedInt (f);
 437                         time    = Decode.Time (f);
 438                         count   = Decode.FixedInt (f);
 439
 440                         if (!legacy) {
 441                                 unread  = Decode.FixedInt (f);
 442                                 deleted = Decode.FixedInt (f);
 443                                 junk    = Decode.FixedInt (f);
 444                         }
 445
 446                         //Console.WriteLine ("V={0} ({1}) time={2}, count={3} unread={4} deleted={5} junk={6}", version, version & 0xff, time, count, unread, deleted, junk);
 447                 }
 448         }
 449
 450         public class MBoxSummaryHeader : SummaryHeader {
 451                 public int local_version;
 452                 public int mbox_version;
 453                 public int folder_size;
 454
 455                 public MBoxSummaryHeader (FileStream f) : base (f)
 456                 {
 457                         local_version = Decode.FixedInt (f);
 458                         mbox_version = Decode.FixedInt (f);
 459                         folder_size = Decode.FixedInt (f);
 460
 461                         //Console.WriteLine ("local_version={0}  mbox_version={1}  folder_size={2}", local_version, mbox_version, folder_size);
 462                 }
 463         }
 464
 465         public class ImapSummaryHeader : SummaryHeader {
 466
 467                 public ImapSummaryHeader (FileStream f) : base (f)
 468                 {
 469                         // Check for legacy version
 470                         if (base.version != 0x30c) { // 780
 471                                 int version = Decode.FixedInt (f);
 472
 473                                 //Console.WriteLine ("imap version={0}", version);
 474
 475                                 if (version < 0)
 476                                         throw new Exception ("IMAP summary version too low");
 477
 478                                 // Right now we only support summary versions 1 through 3
 479                                 if (version > 3)
 480                                         throw new Exception (String.Format ("Reported summary version ({0}) is too new", version));
 481
 482                                 if (version == 2)
 483                                         Decode.FixedInt (f);
 484
 485                                 // validity
 486                                 Decode.SkipFixedInt (f);
 487                         } else {
 488                                 // validity
 489                                 Decode.UInt (f);
 490                         }
 491                 }
 492         }
 493
 494         public class Decode {
 495                 static Encoding e = Encoding.UTF8;
 496                 static long UnixBaseTicks;
 497
 498                 static Decode ()
 499                 {
 500                         UnixBaseTicks = new DateTime (1970, 1, 1, 0, 0, 0).Ticks;
 501                 }
 502
 503                 public static string Token (FileStream f)
 504                 {
 505                     int len = (int) UInt (f);
 506                     if (len < 32) {
 507                         if (len <= 0)
 508                             return "NULL";
 509
 510                         // Ok, this is a token from the list, we can ignore it
 511                         return "token_from_list";
 512                     } else if (len < 0 || len > 10240) {
 513                         throw new Exception ();
 514                     } else {
 515                         len -= 32;
 516                         byte [] buffer = new byte [len];
 517                         f.Read (buffer, 0, (int) len);
 518                         return new System.String (e.GetChars (buffer, 0, len));
 519                     }
 520                 }
 521
 522                 public static void SkipToken (FileStream f)
 523                 {
 524                         int len = (int) UInt (f);
 525                         len -= 32;
 526                         if (len > 0)
 527                                 f.Seek (len, SeekOrigin.Current);
 528                 }
 529
 530                 public static string String (FileStream f)
 531                 {
 532                         int len = (int) UInt (f);
 533                         len--;
 534
 535                         if (len < 0 || len > 65535)
 536                                 throw new Exception ();
 537                         byte [] buffer = new byte [len];
 538                         f.Read (buffer, 0, (int) len);
 539                         return new System.String (e.GetChars (buffer, 0, len));
 540                 }
 541
 542                 public static void SkipString (FileStream f)
 543                 {
 544                         int len = (int) UInt (f);
 545                         --len;
 546                         if (len > 0)
 547                                 f.Seek (len, SeekOrigin.Current);
 548                 }
 549
 550                 public static uint UInt (FileStream f)
 551                 {
 552                         uint value = 0;
 553                         int v;
 554
 555                         while (((v = f.ReadByte ()) & 0x80) == 0 && v != -1){
 556                                 value |= (byte) v;
 557                                 value <<= 7;
 558                         }
 559                         return value | ((byte)(v & 0x7f));
 560                 }
 561
 562                 public static int FixedInt (FileStream f)
 563                 {
 564                         byte [] b = new byte [4];
 565
 566                         f.Read (b, 0, 4);
 567
 568                         return (b [0] << 24) | (b [1] << 16) | (b [2] << 8) | b [3];
 569                 }
 570
 571                 public static void SkipFixedInt (FileStream f)
 572                 {
 573                         f.Seek (4, SeekOrigin.Current);
 574                 }
 575
 576                 public static DateTime Time (FileStream f)
 577                 {
 578                         long seconds = 0;
 579
 580                         // FIXME: Is it safe to assume that sizeof (time_t) == IntPtr.Size?  Probably not.
 581                         for (int i = IntPtr.Size - 1; i >= 0; i--) {
 582                                 int v = f.ReadByte ();
 583
 584                                 seconds |= v << (i * 8);
 585                         }
 586
 587                         if (seconds == 0)
 588                                 return new DateTime (0);
 589
 590                         return new DateTime (UnixBaseTicks).AddSeconds (seconds);
 591                 }
 592
 593                 public static uint Offset (FileStream f)
 594                 {
 595                         byte [] b = new byte [4];
 596
 597                         f.Read (b, 0, 4);
 598
 599                         return (uint)((b [0] << 24) | (b [1] << 16) | (b [2] << 8) | b [3]);
 600                 }
 601         }
 602
 603 #if false
 604         class Test {
 605                 void Main (string [] args)
 606                 {
 607                         string file;
 608
 609                         if (args.Length == 0)
 610                                 file = "./summary";
 611                         else
 612                                 file = args [0];
 613
 614                         Summary s = Summary.LoadMBoxSummary (file);
 615                         foreach (MessageInfo m in s) {
 616                                 Console.WriteLine(m);
 617                         }
 618
 619                 }
 620
 621         }
 622 #endif
 623 }
 624 }