rdf/datasource/nsFileSystemDataSource.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /*
   7   Implementation for a file system RDF data store.
   8  */
   9
  10 #include "nsFileSystemDataSource.h"
  11
  12 #include <ctype.h> // for toupper()
  13 #include <stdio.h>
  14 #include "nsArrayEnumerator.h"
  15 #include "nsCOMArray.h"
  16 #include "nsISupportsArray.h"
  17 #include "nsIRDFDataSource.h"
  18 #include "nsIRDFObserver.h"
  19 #include "nsIServiceManager.h"
  20 #include "nsXPIDLString.h"
  21 #include "nsRDFCID.h"
  22 #include "rdfutil.h"
  23 #include "rdf.h"
  24 #include "nsEnumeratorUtils.h"
  25 #include "nsIURL.h"
  26 #include "nsIFileURL.h"
  27 #include "nsNetUtil.h"
  28 #include "nsIChannel.h"
  29 #include "nsIFile.h"
  30 #include "nsEscape.h"
  31 #include "nsCRTGlue.h"
  32 #include "nsAutoPtr.h"
  33
  34 #ifdef XP_WIN
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "nsILineInputStream.h"
  38 #include "nsDirectoryServiceDefs.h"
  39 #endif
  40
  41 #define NS_MOZICON_SCHEME           "moz-icon:"
  42
  43 static const char kFileProtocol[]         = "file://";
  44
  45 bool
  46 FileSystemDataSource::isFileURI(nsIRDFResource *r)
  47 {
  48     bool        isFileURIFlag = false;
  49     const char  *uri = nullptr;
  50
  51     r->GetValueConst(&uri);
  52     if ((uri) && (!strncmp(uri, kFileProtocol, sizeof(kFileProtocol) - 1)))
  53     {
  54         // XXX HACK HACK HACK
  55         if (!strchr(uri, '#'))
  56         {
  57             isFileURIFlag = true;
  58         }
  59     }
  60     return(isFileURIFlag);
  61 }
  62
  63
  64
  65 bool
  66 FileSystemDataSource::isDirURI(nsIRDFResource* source)
  67 {
  68     nsresult    rv;
  69     const char  *uri = nullptr;
  70
  71     rv = source->GetValueConst(&uri);
  72     if (NS_FAILED(rv)) return(false);
  73
  74     nsCOMPtr<nsIFile> aDir;
  75
  76     rv = NS_GetFileFromURLSpec(nsDependentCString(uri), getter_AddRefs(aDir));
  77     if (NS_FAILED(rv)) return(false);
  78
  79     bool isDirFlag = false;
  80
  81     rv = aDir->IsDirectory(&isDirFlag);
  82     if (NS_FAILED(rv)) return(false);
  83
  84     return(isDirFlag);
  85 }
  86
  87
  88 nsresult
  89 FileSystemDataSource::Init()
  90 {
  91     nsresult rv;
  92
  93     mRDFService = do_GetService("@mozilla.org/rdf/rdf-service;1");
  94     NS_ENSURE_TRUE(mRDFService, NS_ERROR_FAILURE);
  95
  96     rv =  mRDFService->GetResource(NS_LITERAL_CSTRING("NC:FilesRoot"),
  97                                    getter_AddRefs(mNC_FileSystemRoot));
  98     nsresult tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "child"),
  99                                    getter_AddRefs(mNC_Child));
 100     if (NS_FAILED(tmp)) {
 101       rv = tmp;
 102     }
 103     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "Name"),
 104                                    getter_AddRefs(mNC_Name));
 105     if (NS_FAILED(tmp)) {
 106       rv = tmp;
 107     }
 108     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "URL"),
 109                                    getter_AddRefs(mNC_URL));
 110     if (NS_FAILED(tmp)) {
 111       rv = tmp;
 112     }
 113     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "Icon"),
 114                                    getter_AddRefs(mNC_Icon));
 115     if (NS_FAILED(tmp)) {
 116       rv = tmp;
 117     }
 118     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "Content-Length"),
 119                                    getter_AddRefs(mNC_Length));
 120     if (NS_FAILED(tmp)) {
 121       rv = tmp;
 122     }
 123     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "IsDirectory"),
 124                                    getter_AddRefs(mNC_IsDirectory));
 125     if (NS_FAILED(tmp)) {
 126       rv = tmp;
 127     }
 128     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(WEB_NAMESPACE_URI "LastModifiedDate"),
 129                                    getter_AddRefs(mWEB_LastMod));
 130     if (NS_FAILED(tmp)) {
 131       rv = tmp;
 132     }
 133     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "FileSystemObject"),
 134                                    getter_AddRefs(mNC_FileSystemObject));
 135     if (NS_FAILED(tmp)) {
 136       rv = tmp;
 137     }
 138     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI  "pulse"),
 139                                    getter_AddRefs(mNC_pulse));
 140     if (NS_FAILED(tmp)) {
 141       rv = tmp;
 142     }
 143     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "instanceOf"),
 144                                    getter_AddRefs(mRDF_InstanceOf));
 145     if (NS_FAILED(tmp)) {
 146       rv = tmp;
 147     }
 148     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "type"),
 149                                    getter_AddRefs(mRDF_type));
 150
 151     static const char16_t kTrue[] = {'t','r','u','e','\0'};
 152     static const char16_t kFalse[] = {'f','a','l','s','e','\0'};
 153
 154     tmp = mRDFService->GetLiteral(kTrue, getter_AddRefs(mLiteralTrue));
 155     if (NS_FAILED(tmp)) {
 156       rv = tmp;
 157     }
 158     tmp = mRDFService->GetLiteral(kFalse, getter_AddRefs(mLiteralFalse));
 159     if (NS_FAILED(tmp)) {
 160       rv = tmp;
 161     }
 162     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
 163
 164 #ifdef USE_NC_EXTENSION
 165     rv = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "extension"),
 166                                   getter_AddRefs(mNC_extension));
 167     NS_ENSURE_SUCCESS(rv, rv);
 168 #endif
 169
 170 #ifdef XP_WIN
 171     rv =  mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IEFavorite"),
 172                                   getter_AddRefs(mNC_IEFavoriteObject));
 173     tmp = mRDFService->GetResource(NS_LITERAL_CSTRING(NC_NAMESPACE_URI "IEFavoriteFolder"),
 174                                    getter_AddRefs(mNC_IEFavoriteFolder));
 175     if (NS_FAILED(tmp)) {
 176       rv = tmp;
 177     }
 178     NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
 179
 180     nsCOMPtr<nsIFile> file;
 181     NS_GetSpecialDirectory(NS_WIN_FAVORITES_DIR, getter_AddRefs(file));
 182     if (file)
 183     {
 184         nsCOMPtr<nsIURI> furi;
 185         NS_NewFileURI(getter_AddRefs(furi), file);
 186         NS_ENSURE_TRUE(furi, NS_ERROR_FAILURE);
 187
 188         file->GetNativePath(ieFavoritesDir);
 189     }
 190 #endif
 191
 192     return NS_OK;
 193 }
 194
 195 //static
 196 nsresult
 197 FileSystemDataSource::Create(nsISupports* aOuter, const nsIID& aIID, void **aResult)
 198 {
 199     NS_ENSURE_NO_AGGREGATION(aOuter);
 200
 201     nsRefPtr<FileSystemDataSource> self = new FileSystemDataSource();
 202     if (!self)
 203         return NS_ERROR_OUT_OF_MEMORY;
 204
 205     nsresult rv = self->Init();
 206     NS_ENSURE_SUCCESS(rv, rv);
 207
 208     return self->QueryInterface(aIID, aResult);
 209 }
 210
 211 NS_IMPL_ISUPPORTS(FileSystemDataSource, nsIRDFDataSource)
 212
 213 NS_IMETHODIMP
 214 FileSystemDataSource::GetURI(char **uri)
 215 {
 216     NS_PRECONDITION(uri != nullptr, "null ptr");
 217     if (! uri)
 218         return NS_ERROR_NULL_POINTER;
 219
 220     if ((*uri = NS_strdup("rdf:files")) == nullptr)
 221         return NS_ERROR_OUT_OF_MEMORY;
 222
 223     return NS_OK;
 224 }
 225
 226
 227
 228 NS_IMETHODIMP
 229 FileSystemDataSource::GetSource(nsIRDFResource* property,
 230                                 nsIRDFNode* target,
 231                                 bool tv,
 232                                 nsIRDFResource** source /* out */)
 233 {
 234     NS_PRECONDITION(property != nullptr, "null ptr");
 235     if (! property)
 236         return NS_ERROR_NULL_POINTER;
 237
 238     NS_PRECONDITION(target != nullptr, "null ptr");
 239     if (! target)
 240         return NS_ERROR_NULL_POINTER;
 241
 242     NS_PRECONDITION(source != nullptr, "null ptr");
 243     if (! source)
 244         return NS_ERROR_NULL_POINTER;
 245
 246     *source = nullptr;
 247     return NS_RDF_NO_VALUE;
 248 }
 249
 250
 251
 252 NS_IMETHODIMP
 253 FileSystemDataSource::GetSources(nsIRDFResource *property,
 254                                  nsIRDFNode *target,
 255                                  bool tv,
 256                                  nsISimpleEnumerator **sources /* out */)
 257 {
 258 //  NS_NOTYETIMPLEMENTED("write me");
 259     return NS_ERROR_NOT_IMPLEMENTED;
 260 }
 261
 262
 263
 264 NS_IMETHODIMP
 265 FileSystemDataSource::GetTarget(nsIRDFResource *source,
 266                                 nsIRDFResource *property,
 267                                 bool tv,
 268                                 nsIRDFNode **target /* out */)
 269 {
 270     NS_PRECONDITION(source != nullptr, "null ptr");
 271     if (! source)
 272         return NS_ERROR_NULL_POINTER;
 273
 274     NS_PRECONDITION(property != nullptr, "null ptr");
 275     if (! property)
 276         return NS_ERROR_NULL_POINTER;
 277
 278     NS_PRECONDITION(target != nullptr, "null ptr");
 279     if (! target)
 280         return NS_ERROR_NULL_POINTER;
 281
 282     *target = nullptr;
 283
 284     nsresult        rv = NS_RDF_NO_VALUE;
 285
 286     // we only have positive assertions in the file system data source.
 287     if (! tv)
 288         return NS_RDF_NO_VALUE;
 289
 290     if (source == mNC_FileSystemRoot)
 291     {
 292         if (property == mNC_pulse)
 293         {
 294             nsIRDFLiteral   *pulseLiteral;
 295             mRDFService->GetLiteral(MOZ_UTF16("12"), &pulseLiteral);
 296             *target = pulseLiteral;
 297             return NS_OK;
 298         }
 299     }
 300     else if (isFileURI(source))
 301     {
 302         if (property == mNC_Name)
 303         {
 304             nsCOMPtr<nsIRDFLiteral> name;
 305             rv = GetName(source, getter_AddRefs(name));
 306             if (NS_FAILED(rv)) return(rv);
 307             if (!name)  rv = NS_RDF_NO_VALUE;
 308             if (rv == NS_RDF_NO_VALUE)  return(rv);
 309             return name->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 310         }
 311         else if (property == mNC_URL)
 312         {
 313             nsCOMPtr<nsIRDFLiteral> url;
 314             rv = GetURL(source, nullptr, getter_AddRefs(url));
 315             if (NS_FAILED(rv)) return(rv);
 316             if (!url)   rv = NS_RDF_NO_VALUE;
 317             if (rv == NS_RDF_NO_VALUE)  return(rv);
 318
 319             return url->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 320         }
 321         else if (property == mNC_Icon)
 322         {
 323             nsCOMPtr<nsIRDFLiteral> url;
 324             bool isFavorite = false;
 325             rv = GetURL(source, &isFavorite, getter_AddRefs(url));
 326             if (NS_FAILED(rv)) return(rv);
 327             if (isFavorite || !url) rv = NS_RDF_NO_VALUE;
 328             if (rv == NS_RDF_NO_VALUE)  return(rv);
 329
 330             const char16_t *uni = nullptr;
 331             url->GetValueConst(&uni);
 332             if (!uni)   return(NS_RDF_NO_VALUE);
 333             nsAutoString    urlStr;
 334             urlStr.Assign(NS_LITERAL_STRING(NS_MOZICON_SCHEME).get());
 335             urlStr.Append(uni);
 336
 337             rv = mRDFService->GetLiteral(urlStr.get(), getter_AddRefs(url));
 338             if (NS_FAILED(rv) || !url)    return(NS_RDF_NO_VALUE);
 339             return url->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 340         }
 341         else if (property == mNC_Length)
 342         {
 343             nsCOMPtr<nsIRDFInt> fileSize;
 344             rv = GetFileSize(source, getter_AddRefs(fileSize));
 345             if (NS_FAILED(rv)) return(rv);
 346             if (!fileSize)  rv = NS_RDF_NO_VALUE;
 347             if (rv == NS_RDF_NO_VALUE)  return(rv);
 348
 349             return fileSize->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 350         }
 351         else  if (property == mNC_IsDirectory)
 352         {
 353             *target = (isDirURI(source)) ? mLiteralTrue : mLiteralFalse;
 354             NS_ADDREF(*target);
 355             return NS_OK;
 356         }
 357         else if (property == mWEB_LastMod)
 358         {
 359             nsCOMPtr<nsIRDFDate> lastMod;
 360             rv = GetLastMod(source, getter_AddRefs(lastMod));
 361             if (NS_FAILED(rv)) return(rv);
 362             if (!lastMod)   rv = NS_RDF_NO_VALUE;
 363             if (rv == NS_RDF_NO_VALUE)  return(rv);
 364
 365             return lastMod->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 366         }
 367         else if (property == mRDF_type)
 368         {
 369             nsCString type;
 370             rv = mNC_FileSystemObject->GetValueUTF8(type);
 371             if (NS_FAILED(rv)) return(rv);
 372
 373 #ifdef  XP_WIN
 374             // under Windows, if its an IE favorite, return that type
 375             if (!ieFavoritesDir.IsEmpty())
 376             {
 377                 nsCString uri;
 378                 rv = source->GetValueUTF8(uri);
 379                 if (NS_FAILED(rv)) return(rv);
 380
 381                 NS_ConvertUTF8toUTF16 theURI(uri);
 382
 383                 if (theURI.Find(ieFavoritesDir) == 0)
 384                 {
 385                     if (theURI[theURI.Length() - 1] == '/')
 386                     {
 387                         rv = mNC_IEFavoriteFolder->GetValueUTF8(type);
 388                     }
 389                     else
 390                     {
 391                         rv = mNC_IEFavoriteObject->GetValueUTF8(type);
 392                     }
 393                     if (NS_FAILED(rv)) return(rv);
 394                 }
 395             }
 396 #endif
 397
 398             NS_ConvertUTF8toUTF16 url(type);
 399             nsCOMPtr<nsIRDFLiteral> literal;
 400             mRDFService->GetLiteral(url.get(), getter_AddRefs(literal));
 401             rv = literal->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 402             return(rv);
 403         }
 404         else if (property == mNC_pulse)
 405         {
 406             nsCOMPtr<nsIRDFLiteral> pulseLiteral;
 407             mRDFService->GetLiteral(MOZ_UTF16("12"), getter_AddRefs(pulseLiteral));
 408             rv = pulseLiteral->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 409             return(rv);
 410         }
 411         else if (property == mNC_Child)
 412         {
 413             // Oh this is evil. Somebody kill me now.
 414             nsCOMPtr<nsISimpleEnumerator> children;
 415             rv = GetFolderList(source, false, true, getter_AddRefs(children));
 416             if (NS_FAILED(rv) || (rv == NS_RDF_NO_VALUE)) return(rv);
 417
 418             bool hasMore;
 419             rv = children->HasMoreElements(&hasMore);
 420             if (NS_FAILED(rv)) return(rv);
 421
 422             if (hasMore)
 423             {
 424                 nsCOMPtr<nsISupports> isupports;
 425                 rv = children->GetNext(getter_AddRefs(isupports));
 426                 if (NS_FAILED(rv)) return(rv);
 427
 428                 return isupports->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 429             }
 430         }
 431 #ifdef USE_NC_EXTENSION
 432         else if (property == mNC_extension)
 433         {
 434             nsCOMPtr<nsIRDFLiteral> extension;
 435             rv = GetExtension(source, getter_AddRefs(extension));
 436             if (!extension)    rv = NS_RDF_NO_VALUE;
 437             if (rv == NS_RDF_NO_VALUE) return(rv);
 438             return extension->QueryInterface(NS_GET_IID(nsIRDFNode), (void**) target);
 439         }
 440 #endif
 441     }
 442
 443     return(NS_RDF_NO_VALUE);
 444 }
 445
 446
 447
 448 NS_IMETHODIMP
 449 FileSystemDataSource::GetTargets(nsIRDFResource *source,
 450                 nsIRDFResource *property,
 451                 bool tv,
 452                 nsISimpleEnumerator **targets /* out */)
 453 {
 454     NS_PRECONDITION(source != nullptr, "null ptr");
 455     if (! source)
 456         return NS_ERROR_NULL_POINTER;
 457
 458     NS_PRECONDITION(property != nullptr, "null ptr");
 459     if (! property)
 460         return NS_ERROR_NULL_POINTER;
 461
 462     NS_PRECONDITION(targets != nullptr, "null ptr");
 463     if (! targets)
 464         return NS_ERROR_NULL_POINTER;
 465
 466     *targets = nullptr;
 467
 468     // we only have positive assertions in the file system data source.
 469     if (! tv)
 470         return NS_RDF_NO_VALUE;
 471
 472     nsresult rv;
 473
 474     if (source == mNC_FileSystemRoot)
 475     {
 476         if (property == mNC_Child)
 477         {
 478             return GetVolumeList(targets);
 479         }
 480         else if (property == mNC_pulse)
 481         {
 482             nsCOMPtr<nsIRDFLiteral> pulseLiteral;
 483             mRDFService->GetLiteral(MOZ_UTF16("12"),
 484                                     getter_AddRefs(pulseLiteral));
 485             return NS_NewSingletonEnumerator(targets, pulseLiteral);
 486         }
 487     }
 488     else if (isFileURI(source))
 489     {
 490         if (property == mNC_Child)
 491         {
 492             return GetFolderList(source, false, false, targets);
 493         }
 494         else if (property == mNC_Name)
 495         {
 496             nsCOMPtr<nsIRDFLiteral> name;
 497             rv = GetName(source, getter_AddRefs(name));
 498             if (NS_FAILED(rv)) return rv;
 499
 500             return NS_NewSingletonEnumerator(targets, name);
 501         }
 502         else if (property == mNC_URL)
 503         {
 504             nsCOMPtr<nsIRDFLiteral> url;
 505             rv = GetURL(source, nullptr, getter_AddRefs(url));
 506             if (NS_FAILED(rv)) return rv;
 507
 508             return NS_NewSingletonEnumerator(targets, url);
 509         }
 510         else if (property == mRDF_type)
 511         {
 512             nsCString uri;
 513             rv = mNC_FileSystemObject->GetValueUTF8(uri);
 514             if (NS_FAILED(rv)) return rv;
 515
 516             NS_ConvertUTF8toUTF16 url(uri);
 517
 518             nsCOMPtr<nsIRDFLiteral> literal;
 519             rv = mRDFService->GetLiteral(url.get(), getter_AddRefs(literal));
 520             if (NS_FAILED(rv)) return rv;
 521
 522             return NS_NewSingletonEnumerator(targets, literal);
 523         }
 524         else if (property == mNC_pulse)
 525         {
 526             nsCOMPtr<nsIRDFLiteral> pulseLiteral;
 527             rv = mRDFService->GetLiteral(MOZ_UTF16("12"),
 528                 getter_AddRefs(pulseLiteral));
 529             if (NS_FAILED(rv)) return rv;
 530
 531             return NS_NewSingletonEnumerator(targets, pulseLiteral);
 532         }
 533     }
 534
 535     return NS_NewEmptyEnumerator(targets);
 536 }
 537
 538
 539
 540 NS_IMETHODIMP
 541 FileSystemDataSource::Assert(nsIRDFResource *source,
 542                        nsIRDFResource *property,
 543                        nsIRDFNode *target,
 544                        bool tv)
 545 {
 546     return NS_RDF_ASSERTION_REJECTED;
 547 }
 548
 549
 550
 551 NS_IMETHODIMP
 552 FileSystemDataSource::Unassert(nsIRDFResource *source,
 553                          nsIRDFResource *property,
 554                          nsIRDFNode *target)
 555 {
 556     return NS_RDF_ASSERTION_REJECTED;
 557 }
 558
 559
 560
 561 NS_IMETHODIMP
 562 FileSystemDataSource::Change(nsIRDFResource* aSource,
 563                              nsIRDFResource* aProperty,
 564                              nsIRDFNode* aOldTarget,
 565                              nsIRDFNode* aNewTarget)
 566 {
 567     return NS_RDF_ASSERTION_REJECTED;
 568 }
 569
 570
 571
 572 NS_IMETHODIMP
 573 FileSystemDataSource::Move(nsIRDFResource* aOldSource,
 574                            nsIRDFResource* aNewSource,
 575                            nsIRDFResource* aProperty,
 576                            nsIRDFNode* aTarget)
 577 {
 578     return NS_RDF_ASSERTION_REJECTED;
 579 }
 580
 581
 582
 583 NS_IMETHODIMP
 584 FileSystemDataSource::HasAssertion(nsIRDFResource *source,
 585                              nsIRDFResource *property,
 586                              nsIRDFNode *target,
 587                              bool tv,
 588                              bool *hasAssertion /* out */)
 589 {
 590     NS_PRECONDITION(source != nullptr, "null ptr");
 591     if (! source)
 592         return NS_ERROR_NULL_POINTER;
 593
 594     NS_PRECONDITION(property != nullptr, "null ptr");
 595     if (! property)
 596         return NS_ERROR_NULL_POINTER;
 597
 598     NS_PRECONDITION(target != nullptr, "null ptr");
 599     if (! target)
 600         return NS_ERROR_NULL_POINTER;
 601
 602     NS_PRECONDITION(hasAssertion != nullptr, "null ptr");
 603     if (! hasAssertion)
 604         return NS_ERROR_NULL_POINTER;
 605
 606     // we only have positive assertions in the file system data source.
 607     *hasAssertion = false;
 608
 609     if (! tv) {
 610         return NS_OK;
 611     }
 612
 613     if ((source == mNC_FileSystemRoot) || isFileURI(source))
 614     {
 615         if (property == mRDF_type)
 616         {
 617             nsCOMPtr<nsIRDFResource> resource( do_QueryInterface(target) );
 618             if (resource.get() == mRDF_type)
 619             {
 620                 *hasAssertion = true;
 621             }
 622         }
 623 #ifdef USE_NC_EXTENSION
 624         else if (property == mNC_extension)
 625         {
 626             // Cheat just a little here by making dirs always match
 627             if (isDirURI(source))
 628             {
 629                 *hasAssertion = true;
 630             }
 631             else
 632             {
 633                 nsCOMPtr<nsIRDFLiteral> extension;
 634                 GetExtension(source, getter_AddRefs(extension));
 635                 if (extension.get() == target)
 636                 {
 637                     *hasAssertion = true;
 638                 }
 639             }
 640         }
 641 #endif
 642         else if (property == mNC_IsDirectory)
 643         {
 644             bool isDir = isDirURI(source);
 645             bool isEqual = false;
 646             target->EqualsNode(mLiteralTrue, &isEqual);
 647             if (isEqual)
 648             {
 649                 *hasAssertion = isDir;
 650             }
 651             else
 652             {
 653                 target->EqualsNode(mLiteralFalse, &isEqual);
 654                 if (isEqual)
 655                     *hasAssertion = !isDir;
 656             }
 657         }
 658     }
 659
 660     return NS_OK;
 661 }
 662
 663
 664
 665 NS_IMETHODIMP
 666 FileSystemDataSource::HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *result)
 667 {
 668     return NS_ERROR_NOT_IMPLEMENTED;
 669 }
 670
 671
 672
 673 NS_IMETHODIMP
 674 FileSystemDataSource::HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *result)
 675 {
 676     *result = false;
 677
 678     if (aSource == mNC_FileSystemRoot)
 679     {
 680         *result = (aArc == mNC_Child || aArc == mNC_pulse);
 681     }
 682     else if (isFileURI(aSource))
 683     {
 684         if (aArc == mNC_pulse)
 685         {
 686             *result = true;
 687         }
 688         else if (isDirURI(aSource))
 689         {
 690 #ifdef  XP_WIN
 691             *result = isValidFolder(aSource);
 692 #else
 693             *result = true;
 694 #endif
 695         }
 696         else if (aArc == mNC_pulse || aArc == mNC_Name || aArc == mNC_Icon ||
 697                  aArc == mNC_URL || aArc == mNC_Length || aArc == mWEB_LastMod ||
 698                  aArc == mNC_FileSystemObject || aArc == mRDF_InstanceOf ||
 699                  aArc == mRDF_type)
 700         {
 701             *result = true;
 702         }
 703     }
 704     return NS_OK;
 705 }
 706
 707
 708
 709 NS_IMETHODIMP
 710 FileSystemDataSource::ArcLabelsIn(nsIRDFNode *node,
 711                             nsISimpleEnumerator ** labels /* out */)
 712 {
 713 //  NS_NOTYETIMPLEMENTED("write me");
 714     return NS_ERROR_NOT_IMPLEMENTED;
 715 }
 716
 717
 718
 719 NS_IMETHODIMP
 720 FileSystemDataSource::ArcLabelsOut(nsIRDFResource *source,
 721                    nsISimpleEnumerator **labels /* out */)
 722 {
 723     NS_PRECONDITION(source != nullptr, "null ptr");
 724     if (! source)
 725     return NS_ERROR_NULL_POINTER;
 726
 727     NS_PRECONDITION(labels != nullptr, "null ptr");
 728     if (! labels)
 729     return NS_ERROR_NULL_POINTER;
 730
 731     if (source == mNC_FileSystemRoot)
 732     {
 733         nsCOMArray<nsIRDFResource> resources;
 734         resources.SetCapacity(2);
 735
 736         resources.AppendObject(mNC_Child);
 737         resources.AppendObject(mNC_pulse);
 738
 739         return NS_NewArrayEnumerator(labels, resources);
 740     }
 741     else if (isFileURI(source))
 742     {
 743         nsCOMArray<nsIRDFResource> resources;
 744         resources.SetCapacity(2);
 745
 746         if (isDirURI(source))
 747         {
 748 #ifdef  XP_WIN
 749             if (isValidFolder(source))
 750             {
 751                 resources.AppendObject(mNC_Child);
 752             }
 753 #else
 754             resources.AppendObject(mNC_Child);
 755 #endif
 756             resources.AppendObject(mNC_pulse);
 757         }
 758
 759         return NS_NewArrayEnumerator(labels, resources);
 760     }
 761
 762     return NS_NewEmptyEnumerator(labels);
 763 }
 764
 765
 766
 767 NS_IMETHODIMP
 768 FileSystemDataSource::GetAllResources(nsISimpleEnumerator** aCursor)
 769 {
 770     NS_NOTYETIMPLEMENTED("sorry!");
 771     return NS_ERROR_NOT_IMPLEMENTED;
 772 }
 773
 774
 775
 776 NS_IMETHODIMP
 777 FileSystemDataSource::AddObserver(nsIRDFObserver *n)
 778 {
 779     return NS_ERROR_NOT_IMPLEMENTED;
 780 }
 781
 782
 783
 784 NS_IMETHODIMP
 785 FileSystemDataSource::RemoveObserver(nsIRDFObserver *n)
 786 {
 787     return NS_ERROR_NOT_IMPLEMENTED;
 788 }
 789
 790
 791
 792 NS_IMETHODIMP
 793 FileSystemDataSource::GetAllCmds(nsIRDFResource* source,
 794                                      nsISimpleEnumerator/*<nsIRDFResource>*/** commands)
 795 {
 796     return(NS_NewEmptyEnumerator(commands));
 797 }
 798
 799
 800
 801 NS_IMETHODIMP
 802 FileSystemDataSource::IsCommandEnabled(nsISupportsArray/*<nsIRDFResource>*/* aSources,
 803                                        nsIRDFResource*   aCommand,
 804                                        nsISupportsArray/*<nsIRDFResource>*/* aArguments,
 805                                        bool* aResult)
 806 {
 807     return(NS_ERROR_NOT_IMPLEMENTED);
 808 }
 809
 810
 811
 812 NS_IMETHODIMP
 813 FileSystemDataSource::DoCommand(nsISupportsArray/*<nsIRDFResource>*/* aSources,
 814                                 nsIRDFResource*   aCommand,
 815                                 nsISupportsArray/*<nsIRDFResource>*/* aArguments)
 816 {
 817     return(NS_ERROR_NOT_IMPLEMENTED);
 818 }
 819
 820
 821
 822 NS_IMETHODIMP
 823 FileSystemDataSource::BeginUpdateBatch()
 824 {
 825     return NS_OK;
 826 }
 827
 828
 829
 830 NS_IMETHODIMP
 831 FileSystemDataSource::EndUpdateBatch()
 832 {
 833     return NS_OK;
 834 }
 835
 836
 837
 838 nsresult
 839 FileSystemDataSource::GetVolumeList(nsISimpleEnumerator** aResult)
 840 {
 841     nsCOMArray<nsIRDFResource> volumes;
 842     nsCOMPtr<nsIRDFResource> vol;
 843
 844 #ifdef XP_WIN
 845
 846     int32_t         driveType;
 847     wchar_t         drive[32];
 848     int32_t         volNum;
 849
 850     for (volNum = 0; volNum < 26; volNum++)
 851     {
 852         swprintf( drive, L"%c:\\", volNum + (char16_t)'A');
 853
 854         driveType = GetDriveTypeW(drive);
 855         if (driveType != DRIVE_UNKNOWN && driveType != DRIVE_NO_ROOT_DIR)
 856         {
 857           nsAutoCString url;
 858           url.AppendPrintf("file:///%c|/", volNum + 'A');
 859           nsresult rv = mRDFService->GetResource(url, getter_AddRefs(vol));
 860           if (NS_FAILED(rv))
 861             return rv;
 862
 863           volumes.AppendObject(vol);
 864         }
 865     }
 866 #endif
 867
 868 #ifdef XP_UNIX
 869     mRDFService->GetResource(NS_LITERAL_CSTRING("file:///"), getter_AddRefs(vol));
 870     volumes.AppendObject(vol);
 871 #endif
 872
 873     return NS_NewArrayEnumerator(aResult, volumes);
 874 }
 875
 876
 877
 878 #ifdef  XP_WIN
 879 bool
 880 FileSystemDataSource::isValidFolder(nsIRDFResource *source)
 881 {
 882     bool    isValid = true;
 883     if (ieFavoritesDir.IsEmpty())    return(isValid);
 884
 885     nsresult        rv;
 886     nsCString       uri;
 887     rv = source->GetValueUTF8(uri);
 888     if (NS_FAILED(rv)) return(isValid);
 889
 890     NS_ConvertUTF8toUTF16 theURI(uri);
 891     if (theURI.Find(ieFavoritesDir) == 0)
 892     {
 893         isValid = false;
 894
 895         nsCOMPtr<nsISimpleEnumerator>   folderEnum;
 896         if (NS_SUCCEEDED(rv = GetFolderList(source, true, false, getter_AddRefs(folderEnum))))
 897         {
 898             bool        hasAny = false, hasMore;
 899             while (NS_SUCCEEDED(folderEnum->HasMoreElements(&hasMore)) &&
 900                    hasMore)
 901             {
 902                 hasAny = true;
 903
 904                 nsCOMPtr<nsISupports>       isupports;
 905                 if (NS_FAILED(rv = folderEnum->GetNext(getter_AddRefs(isupports))))
 906                     break;
 907                 nsCOMPtr<nsIRDFResource>    res = do_QueryInterface(isupports);
 908                 if (!res)   break;
 909
 910                 nsCOMPtr<nsIRDFLiteral>     nameLiteral;
 911                 if (NS_FAILED(rv = GetName(res, getter_AddRefs(nameLiteral))))
 912                     break;
 913
 914                 const char16_t         *uniName;
 915                 if (NS_FAILED(rv = nameLiteral->GetValueConst(&uniName)))
 916                     break;
 917                 nsAutoString            name(uniName);
 918
 919                 // An empty folder, or a folder that contains just "desktop.ini",
 920                 // is considered to be a IE Favorite; otherwise, its a folder
 921                 if (!name.LowerCaseEqualsLiteral("desktop.ini"))
 922                 {
 923                     isValid = true;
 924                     break;
 925                 }
 926             }
 927             if (!hasAny) isValid = true;
 928         }
 929     }
 930     return(isValid);
 931 }
 932 #endif
 933
 934
 935
 936 nsresult
 937 FileSystemDataSource::GetFolderList(nsIRDFResource *source, bool allowHidden,
 938                 bool onlyFirst, nsISimpleEnumerator** aResult)
 939 {
 940     if (!isDirURI(source))
 941         return(NS_RDF_NO_VALUE);
 942
 943     nsresult                    rv;
 944
 945     const char      *parentURI = nullptr;
 946     rv = source->GetValueConst(&parentURI);
 947     if (NS_FAILED(rv))
 948         return(rv);
 949     if (!parentURI)
 950         return(NS_ERROR_UNEXPECTED);
 951
 952     nsCOMPtr<nsIURI>    aIURI;
 953     if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(parentURI))))
 954         return(rv);
 955
 956     nsCOMPtr<nsIFileURL>    fileURL = do_QueryInterface(aIURI);
 957     if (!fileURL)
 958         return NS_OK;
 959
 960     nsCOMPtr<nsIFile>   aDir;
 961     if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aDir))))
 962         return(rv);
 963
 964     // ensure that we DO NOT resolve aliases
 965     aDir->SetFollowLinks(false);
 966
 967     nsCOMPtr<nsISimpleEnumerator>   dirContents;
 968     if (NS_FAILED(rv = aDir->GetDirectoryEntries(getter_AddRefs(dirContents))))
 969         return(rv);
 970     if (!dirContents)
 971         return(NS_ERROR_UNEXPECTED);
 972
 973     nsCOMArray<nsIRDFResource> resources;
 974     bool            hasMore;
 975     while(NS_SUCCEEDED(rv = dirContents->HasMoreElements(&hasMore)) &&
 976           hasMore)
 977     {
 978         nsCOMPtr<nsISupports>   isupports;
 979         if (NS_FAILED(rv = dirContents->GetNext(getter_AddRefs(isupports))))
 980             break;
 981
 982         nsCOMPtr<nsIFile>   aFile = do_QueryInterface(isupports);
 983         if (!aFile)
 984             break;
 985
 986         if (!allowHidden)
 987         {
 988             bool            hiddenFlag = false;
 989             if (NS_FAILED(rv = aFile->IsHidden(&hiddenFlag)))
 990                 break;
 991             if (hiddenFlag)
 992                 continue;
 993         }
 994
 995         nsAutoString leafStr;
 996         if (NS_FAILED(rv = aFile->GetLeafName(leafStr)))
 997             break;
 998         if (leafStr.IsEmpty())
 999             continue;
1000
1001         nsAutoCString           fullURI;
1002         fullURI.Assign(parentURI);
1003         if (fullURI.Last() != '/')
1004         {
1005             fullURI.Append('/');
1006         }
1007
1008         char    *escLeafStr = nsEscape(NS_ConvertUTF16toUTF8(leafStr).get(), url_Path);
1009         leafStr.Truncate();
1010
1011         if (!escLeafStr)
1012             continue;
1013
1014         nsAutoCString           leaf(escLeafStr);
1015         NS_Free(escLeafStr);
1016         escLeafStr = nullptr;
1017
1018         // using nsEscape() [above] doesn't escape slashes, so do that by hand
1019         int32_t         aOffset;
1020         while ((aOffset = leaf.FindChar('/')) >= 0)
1021         {
1022             leaf.Cut((uint32_t)aOffset, 1);
1023             leaf.Insert("%2F", (uint32_t)aOffset);
1024         }
1025
1026         // append the encoded name
1027         fullURI.Append(leaf);
1028
1029         bool            dirFlag = false;
1030         rv = aFile->IsDirectory(&dirFlag);
1031         if (NS_SUCCEEDED(rv) && dirFlag)
1032         {
1033             fullURI.Append('/');
1034         }
1035
1036         nsCOMPtr<nsIRDFResource>    fileRes;
1037         mRDFService->GetResource(fullURI, getter_AddRefs(fileRes));
1038
1039         resources.AppendObject(fileRes);
1040
1041         if (onlyFirst)
1042             break;
1043     }
1044
1045     return NS_NewArrayEnumerator(aResult, resources);
1046 }
1047
1048 nsresult
1049 FileSystemDataSource::GetLastMod(nsIRDFResource *source, nsIRDFDate **aResult)
1050 {
1051     *aResult = nullptr;
1052
1053     nsresult        rv;
1054     const char      *uri = nullptr;
1055
1056     rv = source->GetValueConst(&uri);
1057     if (NS_FAILED(rv)) return(rv);
1058     if (!uri)
1059         return(NS_ERROR_UNEXPECTED);
1060
1061     nsCOMPtr<nsIURI>    aIURI;
1062     if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
1063         return(rv);
1064
1065     nsCOMPtr<nsIFileURL>    fileURL = do_QueryInterface(aIURI);
1066     if (!fileURL)
1067         return NS_OK;
1068
1069     nsCOMPtr<nsIFile>   aFile;
1070     if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
1071         return(rv);
1072     if (!aFile)
1073         return(NS_ERROR_UNEXPECTED);
1074
1075     // ensure that we DO NOT resolve aliases
1076     aFile->SetFollowLinks(false);
1077
1078     PRTime lastModDate;
1079     if (NS_FAILED(rv = aFile->GetLastModifiedTime(&lastModDate)))
1080         return(rv);
1081
1082     // convert from milliseconds to seconds
1083     mRDFService->GetDateLiteral(lastModDate * PR_MSEC_PER_SEC, aResult);
1084
1085     return(NS_OK);
1086 }
1087
1088
1089
1090 nsresult
1091 FileSystemDataSource::GetFileSize(nsIRDFResource *source, nsIRDFInt **aResult)
1092 {
1093     *aResult = nullptr;
1094
1095     nsresult        rv;
1096     const char      *uri = nullptr;
1097
1098     rv = source->GetValueConst(&uri);
1099     if (NS_FAILED(rv))
1100         return(rv);
1101     if (!uri)
1102         return(NS_ERROR_UNEXPECTED);
1103
1104     nsCOMPtr<nsIURI>    aIURI;
1105     if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
1106         return(rv);
1107
1108     nsCOMPtr<nsIFileURL>    fileURL = do_QueryInterface(aIURI);
1109     if (!fileURL)
1110         return NS_OK;
1111
1112     nsCOMPtr<nsIFile>   aFile;
1113     if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
1114         return(rv);
1115     if (!aFile)
1116         return(NS_ERROR_UNEXPECTED);
1117
1118     // ensure that we DO NOT resolve aliases
1119     aFile->SetFollowLinks(false);
1120
1121     // don't do anything with directories
1122     bool    isDir = false;
1123     if (NS_FAILED(rv = aFile->IsDirectory(&isDir)))
1124         return(rv);
1125     if (isDir)
1126         return(NS_RDF_NO_VALUE);
1127
1128     int64_t     aFileSize64;
1129     if (NS_FAILED(rv = aFile->GetFileSize(&aFileSize64)))
1130         return(rv);
1131
1132     // convert 64bits to 32bits
1133     int32_t aFileSize32 = int32_t(aFileSize64);
1134     mRDFService->GetIntLiteral(aFileSize32, aResult);
1135
1136     return(NS_OK);
1137 }
1138
1139
1140
1141 nsresult
1142 FileSystemDataSource::GetName(nsIRDFResource *source, nsIRDFLiteral **aResult)
1143 {
1144     nsresult        rv;
1145     const char      *uri = nullptr;
1146
1147     rv = source->GetValueConst(&uri);
1148     if (NS_FAILED(rv))
1149         return(rv);
1150     if (!uri)
1151         return(NS_ERROR_UNEXPECTED);
1152
1153     nsCOMPtr<nsIURI>    aIURI;
1154     if (NS_FAILED(rv = NS_NewURI(getter_AddRefs(aIURI), nsDependentCString(uri))))
1155         return(rv);
1156
1157     nsCOMPtr<nsIFileURL>    fileURL = do_QueryInterface(aIURI);
1158     if (!fileURL)
1159         return NS_OK;
1160
1161     nsCOMPtr<nsIFile>   aFile;
1162     if (NS_FAILED(rv = fileURL->GetFile(getter_AddRefs(aFile))))
1163         return(rv);
1164     if (!aFile)
1165         return(NS_ERROR_UNEXPECTED);
1166
1167     // ensure that we DO NOT resolve aliases
1168     aFile->SetFollowLinks(false);
1169
1170     nsAutoString name;
1171     if (NS_FAILED(rv = aFile->GetLeafName(name)))
1172         return(rv);
1173     if (name.IsEmpty())
1174         return(NS_ERROR_UNEXPECTED);
1175
1176 #ifdef  XP_WIN
1177     // special hack for IE favorites under Windows; strip off the
1178     // trailing ".url" or ".lnk" at the end of IE favorites names
1179     int32_t nameLen = name.Length();
1180     if ((strncmp(uri, ieFavoritesDir.get(), ieFavoritesDir.Length()) == 0) && (nameLen > 4))
1181     {
1182         nsAutoString extension;
1183         name.Right(extension, 4);
1184         if (extension.LowerCaseEqualsLiteral(".url") ||
1185             extension.LowerCaseEqualsLiteral(".lnk"))
1186         {
1187             name.Truncate(nameLen - 4);
1188         }
1189     }
1190 #endif
1191
1192     mRDFService->GetLiteral(name.get(), aResult);
1193
1194     return NS_OK;
1195 }
1196
1197
1198
1199 #ifdef USE_NC_EXTENSION
1200 nsresult
1201 FileSystemDataSource::GetExtension(nsIRDFResource *source, nsIRDFLiteral **aResult)
1202 {
1203     nsCOMPtr<nsIRDFLiteral> name;
1204     nsresult rv = GetName(source, getter_AddRefs(name));
1205     if (NS_FAILED(rv))
1206         return rv;
1207
1208     const char16_t* unicodeLeafName;
1209     rv = name->GetValueConst(&unicodeLeafName);
1210     if (NS_FAILED(rv))
1211         return rv;
1212
1213     nsAutoString filename(unicodeLeafName);
1214     int32_t lastDot = filename.RFindChar('.');
1215     if (lastDot == -1)
1216     {
1217         mRDFService->GetLiteral(EmptyString().get(), aResult);
1218     }
1219     else
1220     {
1221         nsAutoString extension;
1222         filename.Right(extension, (filename.Length() - lastDot));
1223         mRDFService->GetLiteral(extension.get(), aResult);
1224     }
1225
1226     return NS_OK;
1227 }
1228 #endif
1229
1230 #ifdef  XP_WIN
1231 nsresult
1232 FileSystemDataSource::getIEFavoriteURL(nsIRDFResource *source, nsString aFileURL, nsIRDFLiteral **urlLiteral)
1233 {
1234     nsresult        rv = NS_OK;
1235
1236     *urlLiteral = nullptr;
1237
1238     nsCOMPtr<nsIFile> f;
1239     NS_GetFileFromURLSpec(NS_ConvertUTF16toUTF8(aFileURL), getter_AddRefs(f));
1240
1241     bool value;
1242
1243     if (NS_SUCCEEDED(f->IsDirectory(&value)) && value)
1244     {
1245         if (isValidFolder(source))
1246             return(NS_RDF_NO_VALUE);
1247         aFileURL.AppendLiteral("desktop.ini");
1248     }
1249     else if (aFileURL.Length() > 4)
1250     {
1251         nsAutoString    extension;
1252
1253         aFileURL.Right(extension, 4);
1254         if (!extension.LowerCaseEqualsLiteral(".url"))
1255         {
1256             return(NS_RDF_NO_VALUE);
1257         }
1258     }
1259
1260     nsCOMPtr<nsIInputStream> strm;
1261     NS_NewLocalFileInputStream(getter_AddRefs(strm),f);
1262     nsCOMPtr<nsILineInputStream> linereader = do_QueryInterface(strm, &rv);
1263
1264     nsAutoString    line;
1265     nsAutoCString   cLine;
1266     while(NS_SUCCEEDED(rv))
1267     {
1268         bool    isEOF;
1269         rv = linereader->ReadLine(cLine, &isEOF);
1270         CopyASCIItoUTF16(cLine, line);
1271
1272         if (isEOF)
1273         {
1274             if (line.Find("URL=", true) == 0)
1275             {
1276                 line.Cut(0, 4);
1277                 rv = mRDFService->GetLiteral(line.get(), urlLiteral);
1278                 break;
1279             }
1280             else if (line.Find("CDFURL=", true) == 0)
1281             {
1282                 line.Cut(0, 7);
1283                 rv = mRDFService->GetLiteral(line.get(), urlLiteral);
1284                 break;
1285             }
1286             line.Truncate();
1287         }
1288     }
1289
1290     return(rv);
1291 }
1292 #endif
1293
1294
1295
1296 nsresult
1297 FileSystemDataSource::GetURL(nsIRDFResource *source, bool *isFavorite, nsIRDFLiteral** aResult)
1298 {
1299     if (isFavorite) *isFavorite = false;
1300
1301     nsresult        rv;
1302     nsCString       uri;
1303
1304     rv = source->GetValueUTF8(uri);
1305     if (NS_FAILED(rv))
1306         return(rv);
1307
1308     NS_ConvertUTF8toUTF16 url(uri);
1309
1310 #ifdef  XP_WIN
1311     // under Windows, if its an IE favorite, munge the URL
1312     if (!ieFavoritesDir.IsEmpty())
1313     {
1314         if (url.Find(ieFavoritesDir) == 0)
1315         {
1316             if (isFavorite) *isFavorite = true;
1317             rv = getIEFavoriteURL(source, url, aResult);
1318             return(rv);
1319         }
1320     }
1321 #endif
1322
1323     // if we fall through to here, its not any type of bookmark
1324     // stored in the platform native file system, so just set the URL
1325
1326     mRDFService->GetLiteral(url.get(), aResult);
1327
1328     return(NS_OK);
1329 }