Util/ChmFile.cs

   1 //
   2 // CHMFile.cs: Basic chmlib Wrapper, CHM file format reader.
   3 //
   4 //
   5 // Copyright (C) 2005,2006  Miguel Fernando Cabrera <mfcabrera@gmail.com>
   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                         public int                flags;
 104                         [MarshalAs (UnmanagedType.ByValTStr, SizeConst=512)]
 105                         public string path;
 106                         /*[MarshalAs (UnmanagedType.ByValArray, SizeConst=257)]
 107                           public char[] path;*/
 108
 109                 }
 110
 111
 112                 private  delegate int  ChmEnumerator (IntPtr chmFile,
 113                                                       chmUnitInfo info,
 114                                                       IntPtr context);
 115
 116
 117                 [ DllImportAttribute("libchm") ]
 118                 private static extern IntPtr  chm_open(string filename);
 119
 120                 [ DllImportAttribute("libchm") ]
 121                 private static extern ChmResolve chm_resolve_object(IntPtr raw,
 122                                                                     string  objPath,
 123                                                                     [Out] chmUnitInfo ui);
 124
 125                 [ DllImportAttribute("libchm") ]
 126                 private static extern UInt64 chm_retrieve_object(IntPtr raw,
 127                                                                  [In, Out] chmUnitInfo ui,
 128                                                                  IntPtr buf,
 129                                                                  UInt64 addr,
 130                                                                  UInt64 len);
 131
 132
 133
 134
 135                 [ DllImportAttribute("libchm") ]
 136                 private static extern int chm_enumerate(IntPtr raw,
 137                                                         ChmEnumerate what,
 138                                                         ChmEnumerator e,
 139                                                         IntPtr context);
 140
 141
 142
 143
 144                 private int GetHtmlFiles(IntPtr chmFile,
 145                                          chmUnitInfo info,
 146                                          IntPtr context)
 147                 {
 148                         if(info.path.EndsWith(".html"))
 149                                 htmlFiles.Add(info.path.Trim());
 150
 151                         return 1;
 152
 153                 }
 154
 155
 156
 157
 158                 private string  ChmGetString(IntPtr ptr,
 159                                              int offset,
 160                                              int len)
 161                 {
 162
 163                         int i = 0;
 164                         string str;
 165
 166                         char[]  cadena = new char[len];
 167
 168                         for(i =0; i < len ; i++){
 169
 170                                 cadena[i] = (char) Marshal.ReadByte(ptr,offset + i);
 171                                 if(cadena[i] == '\0')
 172                                         break;
 173
 174                         }
 175
 176                         str = new string (cadena,0,i);
 177
 178                         return str;
 179
 180
 181                 }
 182
 183                 private string ChmFileToString(chmUnitInfo ui)
 184                 {
 185
 186
 187                         const ulong tmpBufSize = 1025;
 188
 189                         StringBuilder strb = new StringBuilder();
 190
 191
 192                         ulong size = tmpBufSize -1;
 193                         ulong cur = 0;
 194
 195
 196                         IntPtr raw = Marshal.AllocCoTaskMem ((int)tmpBufSize);
 197
 198                         do {
 199                                 size = chm_retrieve_object(chmfile,ui,raw,cur,tmpBufSize-1);
 200                                 // If I dont create a copy of the string when i free 'raw' the builder data dissapear
 201                                 // the last  chunk readed dissapear (mono bug or mi endless stupidity)
 202                                 // I'll have to check it out
 203                                 strb.Append(Marshal.PtrToStringAuto(raw,(int)size));
 204                                 cur += size;
 205                         }
 206                         while(size == tmpBufSize-1);
 207
 208                         Marshal.FreeCoTaskMem (raw);
 209                         return strb.ToString();
 210
 211                 }
 212
 213
 214                 private void CleanUp()
 215                 {
 216                         Marshal.FreeCoTaskMem (chmfile);
 217                         this.loaded = false;
 218                 }
 219
 220                 public void Dispose()
 221                 {
 222                         CleanUp();
 223                         GC.SuppressFinalize (this);
 224
 225                 }
 226
 227                 ~ChmFile()
 228                 {
 229                         CleanUp();
 230
 231                 }
 232
 233                 public ChmFile()
 234                 {
 235
 236                         //this.tocStrings = new ArrayList();
 237                         this.htmlFiles = new ArrayList();
 238
 239
 240                 }
 241
 242                 public bool Load(string path)
 243                 {
 244
 245                         //chmUnitInfo ui = new chmUnitInfo() ;
 246
 247                         this.chmfile = chm_open(path);
 248
 249                         if(this.chmfile == IntPtr.Zero) {
 250                                 throw new System.Exception ("Invalid file Type, not a CHM file");
 251                         }
 252                         this.loaded = true;
 253
 254                         bool info = GetArchiveInfo();
 255
 256                         /*if(info && HasTopics)
 257                           BuildTopicsList();*/
 258
 259
 260                         chm_enumerate(this.chmfile,
 261                                       ChmEnumerate.All,
 262                                       new ChmEnumerator(GetHtmlFiles),
 263                                       IntPtr.Zero);
 264
 265
 266                         /*
 267                                 foreach(string str in htmlFiles)
 268                                 Console.WriteLine(str); */
 269
 270                         return info;
 271
 272                 }
 273
 274                 /**
 275
 276                 From the #SYSTEM File we are interested in the title (for now).
 277
 278                 */
 279
 280                 private bool SystemInfo()
 281                 {
 282                         ChmResolve res;
 283                         ulong  size;
 284                         bool gottitle = false;
 285
 286
 287
 288                         if(!loaded)
 289                                 return false;
 290
 291
 292                         IntPtr buf = Marshal.AllocCoTaskMem (bufSize);
 293
 294                         chmUnitInfo ui = new chmUnitInfo() ;
 295
 296
 297                         res = chm_resolve_object (this.chmfile,"/#SYSTEM", ui);
 298
 299
 300                         if(res == ChmResolve.Failure)
 301                                 return false;
 302
 303                         size  =  chm_retrieve_object (this.chmfile, ui,buf, 4, (ulong)bufSize);
 304
 305                         int index = 0;
 306                         ushort value = 0;
 307                         long tol = (long)size - 2;
 308
 309                         while(index < tol) {
 310
 311
 312                                 value =  (ushort)Marshal.ReadInt16 (buf, index);
 313
 314                                 if(value == 3) {
 315
 316
 317                                         index += 2;
 318                                         ushort len = (ushort)Marshal.ReadInt16 (buf, (int)index);
 319
 320                                         if(this.title == "")
 321                                                 this.title = ChmGetString (buf,index+2, (int)len);
 322                                         gottitle = true;
 323                                         break;
 324
 325
 326                                 }
 327                                 else
 328                                         index += 2;
 329
 330
 331                                 value = (ushort) Marshal.ReadInt16(buf,(int)index);
 332
 333                                 index += (int)value + 2;
 334
 335                         }
 336
 337                         Marshal.FreeCoTaskMem (buf);
 338                         return gottitle;
 339
 340                 }
 341
 342                 /*
 343                   TODO:
 344                   We should trow something like a FileNotFoundException
 345                 */
 346                 public TextReader GetFile(string path)
 347                 {
 348
 349                         chmUnitInfo ui = new chmUnitInfo();
 350
 351                         if(chm_resolve_object (chmfile,path,ui)  == ChmResolve.Failure) {
 352                                 //Console.WriteLine("Fails to Open: {0}",path);
 353                                 return new StringReader("");
 354
 355
 356                         }
 357
 358                         return (new StringReader(ChmFileToString(ui)));
 359
 360                 }
 361
 362
 363                 public TextReader  GetTopicsFile()
 364                 {
 365
 366                         if(HasTopics) {
 367
 368                                 return GetFile(topicsFile);
 369
 370                         }
 371
 372                         /*Oh Lina, why don't you love me? :P*/
 373                         return new StringReader("");
 374
 375
 376                 }
 377
 378                 public TextReader GetDefaultFile()
 379                 {
 380
 381
 382
 383                         return GetFile(defaultFile);
 384
 385
 386                 }
 387
 388
 389
 390
 391                 private bool WindowsInfo()
 392                 {
 393
 394                         int  entries;
 395                         int entrySize;
 396                         IntPtr windowsData;
 397                         long size = 0;
 398                         uint block;
 399
 400                         const int headerLen = 0x8;
 401
 402
 403                         IntPtr buf = Marshal.AllocCoTaskMem (bufSize);
 404                         chmUnitInfo ui = new chmUnitInfo ();
 405
 406
 407                         if(chm_resolve_object (chmfile,"/#WINDOWS",ui) == ChmResolve.Failure)
 408                                 return false;
 409
 410                         if(chm_retrieve_object (chmfile,ui,buf,0,headerLen) == 0)
 411                                 return false;
 412
 413                         entries = Marshal.ReadInt32 (buf);
 414                         entrySize = Marshal.ReadInt32 (buf,0x4);
 415
 416                         //Console.WriteLine ("entries -> {0}\nsize = {1}",entries,entrySize);
 417
 418                         windowsData  = Marshal.AllocCoTaskMem(entries * entrySize);
 419
 420
 421                         size = (long)chm_retrieve_object (chmfile,
 422                                                           ui,
 423                                                           windowsData,
 424                                                           headerLen,
 425                                                           (ulong)(entries * entrySize));
 426                         if(size == 0)
 427                                 return false;
 428
 429                         size = 0;
 430
 431
 432                         if(chm_resolve_object (chmfile,"/#STRINGS",ui) == ChmResolve.Failure)
 433                                 return false;
 434
 435
 436                 /*
 437                   From Pabs' CHM Spec:
 438                   "(STRINGS)This file is a list of ANSI/UTF-8 NT strings.
 439                   The first is just a NIL character so that offsets to this file can specify
 440                   zero & get a valid string.
 441                   The strings are sliced up into blocks that are 4096 bytes in length."
 442                 */
 443
 444
 445
 446                         for(int i = 0; i < entries; i++) {
 447
 448                                 int offset = i * entrySize;
 449
 450
 451                                 uint offTitle  = (uint)Marshal.ReadInt32(windowsData,
 452                                                                          offset + 0x14);
 453
 454                                 uint offTocFile = (uint)Marshal.ReadInt32(windowsData,
 455                                                                           offset + 0x60);
 456                                 uint offDefaultFile = (uint)Marshal.ReadInt32(windowsData,
 457                                                                               offset + 0x68);
 458
 459
 460                                 //Console.WriteLine("offTocFile = {0}",offTocFile);
 461
 462
 463                                 block = offTitle / 4096;
 464
 465
 466                                 if(size == 0)
 467                                         size = (long)chm_retrieve_object(chmfile,
 468                                                                          ui,
 469                                                                          buf,
 470                                                                          block * 4096,
 471                                                                          (ulong)bufSize);
 472
 473
 474                                 if(size > 0 && offTitle > 0)
 475                                         this.title = ChmGetString(buf,(int)offTitle,4096);
 476
 477
 478                                 if(block != offTocFile / 4096) {
 479                                         block = offTocFile / 4096;
 480                                         size = (long)chm_retrieve_object(chmfile,
 481                                                                          ui,
 482                                                                          buf,
 483                                                                          block * 4096,
 484                                                                          (ulong)bufSize);
 485
 486                                 }
 487
 488
 489                                 if(size > 0 && offTocFile > 0){
 490                                         topicsFile = "/" + ChmGetString(buf,
 491                                                                         (int)offTocFile % 4096 ,
 492                                                                         4096);
 493                                         hasTopics = true;
 494                                 }
 495
 496
 497                                 if(block != offDefaultFile / 4096) {
 498                                         block = offDefaultFile / 4096;
 499                                         size = (long)chm_retrieve_object(chmfile,
 500                                                                          ui,
 501                                                                          buf,
 502                                                                          block * 4096,
 503                                                                          (ulong)bufSize);
 504
 505                                 }
 506
 507
 508                                 if(size > 0 && offDefaultFile > 0)
 509                                         defaultFile = ("/" + ChmGetString(buf,
 510                                                                           (int)offDefaultFile % 4096 ,
 511                                                                           4096) );
 512
 513
 514
 515                         }
 516
 517                         Marshal.FreeCoTaskMem (buf);
 518                         Marshal.FreeCoTaskMem (windowsData);
 519                         return true;
 520
 521                 }
 522
 523
 524
 525                 private  bool GetArchiveInfo()
 526                 {
 527                         /*
 528                           We only get the chm title (if any) from the #SYSTEM file
 529                           and the Toc strings for now.
 530                           I'm sure Razvan will feel some kind of Deja Vu.
 531                         */
 532                         bool rest = false;
 533                         bool resw = false;
 534
 535
 536                         if(this.loaded) {
 537
 538                                 resw = WindowsInfo();
 539                                 rest = SystemInfo();
 540
 541                         }
 542                         return (rest || resw);
 543
 544                 }
 545
 546                 public void ParseContents(ChmHtmlParseFunc Parse)
 547                 {
 548
 549
 550                         if(this.loaded)
 551                                 foreach(string fileName in htmlFiles) {
 552                                         chmUnitInfo ui = new chmUnitInfo();
 553
 554                                         chm_resolve_object(this.chmfile,
 555                                                            fileName,
 556                                                            ui) ;
 557
 558
 559                                         //Console.WriteLine("Parsing....{0}",ui.path);
 560                                         ///Logger.Log.Debug("CHMFile: Parsing {0}....",ui.path);
 561                                         Parse( new StringReader(ChmFileToString(ui).Trim()) );
 562
 563
 564                                 }
 565
 566
 567
 568                 }
 569
 570
 571
 572         }
 573
 574
 575
 576
 577
 578 #if true
 579 }
 580 #endif