Util/ChmFile.cs

   1 //
   2 // CHMFile.cs: Basic chmlib Wrapper, CHM file format reader.
   3 //
   4 // Author:
   5 //   Miguel Fernando Cabrera <mfcabrer@unalmed.edu.co>
   6 //
   7 // Based on Razvan Cojocaru's X-CHM::CHMFile.
   8 // Uses Jed Wing's CHMLib.
   9 // For more information about CHM file format
  10 // check out Pabs' CHM spec at http://bonedaddy.net/pabs3/hhm
  11 //
  12
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining a copy
  15 // of this software and associated documentation files (the "Software"), to deal
  16 // in the Software without restriction, including without limitation the rights
  17 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  18 // copies of the Software, and to permit persons to whom the Software is
  19 // furnished to do so, subject to the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be included in all
  22 // copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  27 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  29 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30 // SOFTWARE.
  31 //
  32
  33 using System;
  34 using System.Runtime.InteropServices;
  35 using System.Collections;
  36 using System.IO;
  37 using System.Text;
  38
  39
  40 #if true
  41 namespace Beagle.Util {
  42 #endif
  43
  44
  45
  46
  47 /*just to make it 'right'*/
  48         enum ChmResolve {
  49                 Sucess,
  50                 Failure
  51         }
  52
  53
  54         enum ChmEnumerate {
  55                 Normal = 1,
  56                 Meta = 1 << 1,
  57                 Special = 1 << 2,
  58                 Files = 1 << 3,
  59                 Dirs = 1 << 4,
  60                 All = (1 << 5) -1
  61
  62         }
  63
  64
  65         public delegate void ChmHtmlParseFunc(TextReader stream);
  66
  67         public class ChmFile : IDisposable {
  68
  69
  70                 private string title = "";
  71                 //private ArrayList tocStrings;
  72                 private ArrayList htmlFiles;
  73                 private string topicsFile;
  74                 private bool hasTopics = false;
  75                 private IntPtr chmfile = IntPtr.Zero;
  76
  77                 private bool loaded = false;
  78                 private const int  bufSize = 4096;
  79                 private string defaultFile = "";
  80
  81                 public string Title {
  82                         get { return title; }
  83
  84                 }
  85
  86                 public bool HasTopics {
  87                         get { return hasTopics; }
  88
  89                 }
  90
  91
  92
  93
  94
  95                 /* ChmLib Glue */
  96
  97                 [ StructLayout (LayoutKind.Sequential) ]
  98                 private  class  chmUnitInfo {
  99
 100                         public UInt64             start;
 101                         public UInt64             length;
 102                         public int                space;
 103                         [MarshalAs (UnmanagedType.ByValTStr, SizeConst=257)]
 104                         public string path;
 105                         /*[MarshalAs (UnmanagedType.ByValArray, SizeConst=257)]
 106                           public char[] path;*/
 107
 108                 }
 109
 110
 111                 private  delegate int  ChmEnumerator (IntPtr chmFile,
 112                                                       chmUnitInfo info,
 113                                                       IntPtr context);
 114
 115
 116                 [ DllImportAttribute("libchm") ]
 117                 private static extern IntPtr  chm_open(string filename);
 118
 119                 [ DllImportAttribute("libchm") ]
 120                 private static extern ChmResolve chm_resolve_object(IntPtr raw,
 121                                                                     string  objPath,
 122                                                                     [Out] chmUnitInfo ui);
 123
 124                 [ DllImportAttribute("libchm") ]
 125                 private static extern UInt64 chm_retrieve_object(IntPtr raw,
 126                                                                  [In, Out] chmUnitInfo ui,
 127                                                                  IntPtr buf,
 128                                                                  UInt64 addr,
 129                                                                  UInt64 len);
 130
 131
 132
 133
 134                 [ DllImportAttribute("libchm") ]
 135                 private static extern int chm_enumerate(IntPtr raw,
 136                                                         ChmEnumerate what,
 137                                                         ChmEnumerator e,
 138                                                         IntPtr context);
 139
 140
 141
 142
 143                 private int GetHtmlFiles(IntPtr chmFile,
 144                                          chmUnitInfo info,
 145                                          IntPtr context)
 146                 {
 147                         if(info.path.EndsWith(".html"))
 148                                 htmlFiles.Add(info.path.Trim());
 149
 150                         return 1;
 151
 152                 }
 153
 154
 155
 156
 157                 private string  ChmGetString(IntPtr ptr,
 158                                              int offset,
 159                                              int len)
 160                 {
 161
 162                         int i = 0;
 163                         string str;
 164
 165                         char[]  cadena = new char[len];
 166
 167                         for(i =0; i < len ; i++){
 168
 169                                 cadena[i] = (char) Marshal.ReadByte(ptr,offset + i);
 170                                 if(cadena[i] == '\0')
 171                                         break;
 172
 173                         }
 174
 175                         str = new string (cadena,0,i);
 176
 177                         return str;
 178
 179
 180                 }
 181
 182                 private string ChmFileToString(chmUnitInfo ui)
 183                 {
 184
 185
 186                         const ulong tmpBufSize = 1025;
 187
 188                         StringBuilder strb = new StringBuilder();
 189
 190
 191                         ulong size = tmpBufSize -1;
 192                         ulong cur = 0;
 193
 194
 195                         IntPtr raw = Marshal.AllocCoTaskMem ((int)tmpBufSize);
 196
 197                         do {
 198                                 size = chm_retrieve_object(chmfile,ui,raw,cur,tmpBufSize-1);
 199                                 // If I dont create a copy of the string when i free 'raw' the builder data dissapear
 200                                 // the last  chunk readed dissapear (mono bug or mi endless stupidity)
 201                                 // I'll have to check it out
 202                                 strb.Append(Marshal.PtrToStringAuto(raw,(int)size));
 203                                 cur += size;
 204                         }
 205                         while(size == tmpBufSize-1);
 206
 207                         Marshal.FreeCoTaskMem (raw);
 208                         return strb.ToString();
 209
 210                 }
 211
 212
 213                 private void CleanUp()
 214                 {
 215                         Marshal.FreeCoTaskMem (chmfile);
 216                         this.loaded = false;
 217                 }
 218
 219                 public void Dispose()
 220                 {
 221                         CleanUp();
 222                         GC.SuppressFinalize (this);
 223
 224                 }
 225
 226                 ~ChmFile()
 227                 {
 228                         CleanUp();
 229
 230                 }
 231
 232                 public ChmFile()
 233                 {
 234
 235                 //this.tocStrings = new ArrayList();
 236                         this.htmlFiles = new ArrayList();
 237
 238
 239                 }
 240
 241                 public bool Load(string path)
 242                 {
 243
 244                         //chmUnitInfo ui = new chmUnitInfo() ;
 245
 246                         this.chmfile = chm_open(path);
 247
 248                         if(this.chmfile == IntPtr.Zero) {
 249                                 throw new System.Exception ("Invalid file Type, not a CHM file");
 250                         }
 251                         this.loaded = true;
 252
 253                         bool info = GetArchiveInfo();
 254
 255                         /*if(info && HasTopics)
 256                           BuildTopicsList();*/
 257
 258
 259                         chm_enumerate(this.chmfile,
 260                                       ChmEnumerate.All,
 261                                       new ChmEnumerator(GetHtmlFiles),
 262                                       IntPtr.Zero);
 263
 264
 265                         /*
 266                                 foreach(string str in htmlFiles)
 267                                 Console.WriteLine(str); */
 268
 269                         return info;
 270
 271                 }
 272
 273                 /**
 274
 275                 From the #SYSTEM File we are interested in the title (for now).
 276
 277                 */
 278
 279                 private bool SystemInfo()
 280                 {
 281                         ChmResolve res;
 282                         ulong  size;
 283                         bool gottitle = false;
 284
 285
 286
 287                         if(!loaded)
 288                                 return false;
 289
 290
 291                         IntPtr buf = Marshal.AllocCoTaskMem (bufSize);
 292
 293                         chmUnitInfo ui = new chmUnitInfo() ;
 294
 295
 296                         res = chm_resolve_object (this.chmfile,"/#SYSTEM", ui);
 297
 298
 299                         if(res == ChmResolve.Failure)
 300                         return false;
 301
 302                         size  =  chm_retrieve_object (this.chmfile, ui,buf,4,(ulong)bufSize);
 303
 304                         int index = 0;
 305                         ushort value = 0;
 306                         long tol = (long)size-2;
 307
 308                         while(index < tol) {
 309
 310
 311                                 value =  (ushort)Marshal.ReadInt16(buf,index);
 312
 313                                 if(value == 3) {
 314
 315                                         //Console.WriteLine ("We got it");
 316                                 index += 2;
 317                                 ushort len = (ushort)Marshal.ReadInt16 (buf,(int)index);
 318
 319                                 if(this.title == "")
 320                                         this.title = ChmGetString (buf,index+2,(int)len);
 321                                 gottitle = true;
 322                                 break;
 323
 324
 325                                 }
 326                                 else
 327                                         index += 2;
 328
 329                                 value = (ushort) Marshal.ReadInt16(buf,(int)index);
 330
 331                                 index += (int)value +2;
 332
 333                         }
 334
 335                         Marshal.FreeCoTaskMem (buf);
 336                         return gottitle;
 337
 338                 }
 339
 340                 /*
 341                   TODO:
 342                   We should trow something like a FileNotFoundException
 343                 */
 344                 public TextReader GetFile(string path)
 345                 {
 346
 347                         chmUnitInfo ui = new chmUnitInfo();
 348
 349                         if(chm_resolve_object (chmfile,path,ui)  == ChmResolve.Failure) {
 350                                 //Console.WriteLine("Fails to Open: {0}",path);
 351                                 return new StringReader("");
 352
 353
 354                         }
 355
 356                         return (new StringReader(ChmFileToString(ui)));
 357
 358                 }
 359
 360
 361                 public TextReader  GetTopicsFile()
 362                 {
 363
 364                         if(HasTopics) {
 365
 366                                 return GetFile(topicsFile);
 367
 368                         }
 369
 370                         /*Oh Lina, why don't you love me? :P*/
 371                         return new StringReader("");
 372
 373
 374                 }
 375
 376                 public TextReader GetDefaultFile()
 377                 {
 378
 379
 380
 381                         return GetFile(defaultFile);
 382
 383
 384                 }
 385
 386
 387
 388
 389                 private bool WindowsInfo()
 390                 {
 391
 392                         int  entries;
 393                         int entrySize;
 394                         IntPtr windowsData;
 395                         long size = 0;
 396                         uint block;
 397
 398                         const int headerLen = 0x8;
 399
 400
 401                         IntPtr buf = Marshal.AllocCoTaskMem (bufSize);
 402                         chmUnitInfo ui = new chmUnitInfo ();
 403
 404
 405                         if(chm_resolve_object (chmfile,"/#WINDOWS",ui) == ChmResolve.Failure)
 406                                 return false;
 407
 408                         if(chm_retrieve_object (chmfile,ui,buf,0,headerLen) == 0)
 409                                 return false;
 410
 411                         entries = Marshal.ReadInt32 (buf);
 412                         entrySize = Marshal.ReadInt32 (buf,0x4);
 413
 414                         //Console.WriteLine ("entries -> {0}\nsize = {1}",entries,entrySize);
 415
 416                         windowsData  = Marshal.AllocCoTaskMem(entries*entrySize);
 417
 418
 419                         size = (long)chm_retrieve_object (chmfile,
 420                                                           ui,
 421                                                           windowsData,
 422                                                           headerLen,
 423                                                           (ulong)( entries * entrySize ) );
 424                         if(size == 0)
 425                                 return false;
 426
 427                         size = 0;
 428
 429
 430                         if(chm_resolve_object (chmfile,"/#STRINGS",ui) == ChmResolve.Failure )
 431                                 return false;
 432
 433
 434                 /*
 435                   From Pabs' CHM Spec:
 436                   "(STRINGS)This file is a list of ANSI/UTF-8 NT strings.
 437                   The first is just a NIL character so that offsets to this file can specify
 438                   zero & get a valid string.
 439                   The strings are sliced up into blocks that are 4096 bytes in length."
 440                 */
 441
 442
 443
 444                         for(int i = 0; i < entries; i++) {
 445
 446                                 int offset = i * entrySize;
 447
 448
 449                                 uint offTitle  = (uint)Marshal.ReadInt32(windowsData,
 450                                                                  offset + 0x14);
 451
 452                                 uint offTocFile = (uint)Marshal.ReadInt32(windowsData,
 453                                                                           offset + 0x60 );
 454                                 uint offDefaultFile = (uint)Marshal.ReadInt32(windowsData,
 455                                                                               offset + 0x68 );
 456
 457
 458                                 //Console.WriteLine("offTocFile = {0}",offTocFile);
 459
 460
 461                                 block = offTitle / 4096;
 462
 463
 464                                 if(size == 0)
 465                                         size = (long)chm_retrieve_object(chmfile,
 466                                                                          ui,
 467                                                                          buf,
 468                                                                          block * 4096,
 469                                                                          (ulong)bufSize);
 470
 471
 472                                 if(size > 0 && offTitle > 0)
 473                                         this.title = ChmGetString(buf,(int)offTitle,4096);
 474
 475
 476                                 if(block != offTocFile / 4096) {
 477                                         block = offTocFile / 4096;
 478                                         size = (long)chm_retrieve_object(chmfile,
 479                                                                          ui,
 480                                                                          buf,
 481                                                                          block * 4096,
 482                                                                          (ulong)bufSize);
 483
 484                                 }
 485
 486
 487                                 if(size > 0 && offTocFile > 0){
 488                                         topicsFile = "/" + ChmGetString(buf,
 489                                                                         (int)offTocFile % 4096 ,
 490                                                                         4096);
 491                                         hasTopics = true;
 492                                 }
 493
 494
 495                                 if(block != offDefaultFile / 4096) {
 496                                         block = offDefaultFile / 4096;
 497                                         size = (long)chm_retrieve_object(chmfile,
 498                                                                          ui,
 499                                                                          buf,
 500                                                                          block * 4096,
 501                                                                          (ulong)bufSize);
 502
 503                                 }
 504
 505
 506                                 if(size > 0 && offDefaultFile > 0)
 507                                         defaultFile = ("/" + ChmGetString(buf,
 508                                                                           (int)offDefaultFile % 4096 ,
 509                                                                           4096) );
 510
 511
 512
 513                         }
 514
 515                         Marshal.FreeCoTaskMem (buf);
 516                         Marshal.FreeCoTaskMem (windowsData);
 517                         return true;
 518
 519                 }
 520
 521
 522
 523                 private  bool GetArchiveInfo()
 524                 {
 525                         /*
 526                           We only get the chm title (if any) from the #SYSTEM file
 527                           and the Toc strings for now.
 528                           I'm sure Razvan will feel some kind of Deja Vu.
 529                         */
 530                         bool rest = false;
 531                         bool resw = false;
 532
 533
 534                         if(this.loaded) {
 535
 536                                 resw = WindowsInfo();
 537                                 rest = SystemInfo();
 538
 539                         }
 540                         return (rest || resw);
 541
 542                 }
 543
 544                 public void ParseContents(ChmHtmlParseFunc Parse)
 545                 {
 546
 547
 548                         if(this.loaded)
 549                                 foreach(string fileName in htmlFiles) {
 550                                         chmUnitInfo ui = new chmUnitInfo();
 551
 552                                         chm_resolve_object(this.chmfile,
 553                                                            fileName,
 554                                                            ui) ;
 555
 556
 557                                         //Console.WriteLine("Parsing....{0}",ui.path);
 558                                         ///Logger.Log.Debug("CHMFile: Parsing {0}....",ui.path);
 559                                         Parse( new StringReader(ChmFileToString(ui).Trim()) );
 560
 561
 562                                 }
 563
 564
 565
 566                 }
 567
 568 #if false
 569                 public static void ParseTest(TextReader text)
 570                 {
 571                         Console.WriteLine("in ParseText");
 572                         Console.WriteLine(text.ReadLine());
 573
 574                 }
 575
 576 #endif
 577
 578
 579 #if false
 580         static void Main()
 581         {
 582
 583                 ChmFile reader = new ChmFile();
 584
 585                 bool res = reader.Load("olib.chm");
 586                 //reader.GetArchiveInfo();
 587                 Console.WriteLine("The response {0}",res);
 588                 //reader.Dispose();
 589                 Console.WriteLine("El titulo es " + reader.Title);
 590
 591                 TextReader r = reader.GetTopicsFile();
 592
 593                 /*while((line = r.ReadLine()) != null)
 594                   Console.WriteLine(line);*/
 595
 596                 Console.WriteLine("Waza???");
 597
 598                 //Console.WriteLine(r.ReadToEnd());
 599
 600                 ParseTest t = new ParseTest(r);
 601
 602                 r.Close();
 603
 604                 //reader.ParseContents(new ChmHtmlParseFunc(CHMFile.ParseTest));
 605
 606                 /*
 607                 reader.Load("/home/ceruno/Documentacion/Biblioteca/WebDev/JavaScript/Java Script Pocket Reference 2nd Edition.chm");
 608
 609                 //reader.GetArchiveInfo();
 610
 611                 Console.WriteLine("El titulo es " + reader.Title);*/
 612
 613
 614
 615         }
 616
 617 #endif
 618
 619
 620 }
 621
 622
 623
 624
 625
 626 #if true
 627 }
 628 #endif