src/kits/support/Url.cpp

   1 /*
   2  * Copyright 2010-2016 Haiku Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Christophe Huriaux, c.huriaux@gmail.com
   7  *              Andrew Lindesay, apl@lindesay.co.nz
   8  */
   9
  10
  11 #include <Url.h>
  12
  13 #include <ctype.h>
  14 #include <cstdio>
  15 #include <cstdlib>
  16 #include <new>
  17
  18 #include <MimeType.h>
  19 #include <Roster.h>
  20
  21 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
  22         #include <ICUWrapper.h>
  23 #endif
  24
  25 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
  26         #include <unicode/idna.h>
  27         #include <unicode/stringpiece.h>
  28 #endif
  29
  30
  31 static const char* kArchivedUrl = "be:url string";
  32
  33
  34 BUrl::BUrl(const char* url)
  35         :
  36         fUrlString(),
  37         fProtocol(),
  38         fUser(),
  39         fPassword(),
  40         fHost(),
  41         fPort(0),
  42         fPath(),
  43         fRequest(),
  44         fHasHost(false),
  45         fHasFragment(false)
  46 {
  47         SetUrlString(url);
  48 }
  49
  50
  51 BUrl::BUrl(BMessage* archive)
  52         :
  53         fUrlString(),
  54         fProtocol(),
  55         fUser(),
  56         fPassword(),
  57         fHost(),
  58         fPort(0),
  59         fPath(),
  60         fRequest(),
  61         fHasHost(false),
  62         fHasFragment(false)
  63 {
  64         BString url;
  65
  66         if (archive->FindString(kArchivedUrl, &url) == B_OK)
  67                 SetUrlString(url);
  68         else
  69                 _ResetFields();
  70 }
  71
  72
  73 BUrl::BUrl(const BUrl& other)
  74         :
  75         BArchivable(),
  76         fUrlString(),
  77         fProtocol(other.fProtocol),
  78         fUser(other.fUser),
  79         fPassword(other.fPassword),
  80         fHost(other.fHost),
  81         fPort(other.fPort),
  82         fPath(other.fPath),
  83         fRequest(other.fRequest),
  84         fFragment(other.fFragment),
  85         fUrlStringValid(other.fUrlStringValid),
  86         fAuthorityValid(other.fAuthorityValid),
  87         fUserInfoValid(other.fUserInfoValid),
  88         fHasProtocol(other.fHasProtocol),
  89         fHasUserName(other.fHasUserName),
  90         fHasPassword(other.fHasPassword),
  91         fHasHost(other.fHasHost),
  92         fHasPort(other.fHasPort),
  93         fHasPath(other.fHasPath),
  94         fHasRequest(other.fHasRequest),
  95         fHasFragment(other.fHasFragment)
  96 {
  97         if (fUrlStringValid)
  98                 fUrlString = other.fUrlString;
  99
 100         if (fAuthorityValid)
 101                 fAuthority = other.fAuthority;
 102
 103         if (fUserInfoValid)
 104                 fUserInfo = other.fUserInfo;
 105
 106 }
 107
 108
 109 BUrl::BUrl(const BUrl& base, const BString& location)
 110         :
 111         fUrlString(),
 112         fProtocol(),
 113         fUser(),
 114         fPassword(),
 115         fHost(),
 116         fPort(0),
 117         fPath(),
 118         fRequest(),
 119         fAuthorityValid(false),
 120         fUserInfoValid(false),
 121         fHasUserName(false),
 122         fHasPassword(false),
 123         fHasHost(false),
 124         fHasPort(false),
 125         fHasFragment(false)
 126 {
 127         // This implements the algorithm in RFC3986, Section 5.2.
 128
 129         BUrl relative(location);
 130         if (relative.HasProtocol()) {
 131                 SetProtocol(relative.Protocol());
 132                 if (relative.HasAuthority())
 133                         SetAuthority(relative.Authority());
 134                 SetPath(relative.Path());
 135                 SetRequest(relative.Request());
 136         } else {
 137                 if (relative.HasAuthority()) {
 138                         SetAuthority(relative.Authority());
 139                         SetPath(relative.Path());
 140                         SetRequest(relative.Request());
 141                 } else {
 142                         if (relative.Path().IsEmpty()) {
 143                                 _SetPathUnsafe(base.Path());
 144                                 if (relative.HasRequest())
 145                                         SetRequest(relative.Request());
 146                                 else
 147                                         SetRequest(base.Request());
 148                         } else {
 149                                 if (relative.Path()[0] == '/')
 150                                         SetPath(relative.Path());
 151                                 else {
 152                                         BString path = base._MergePath(relative.Path());
 153                                         SetPath(path);
 154                                 }
 155                                 SetRequest(relative.Request());
 156                         }
 157
 158                         if (base.HasAuthority())
 159                                 SetAuthority(base.Authority());
 160                 }
 161                 SetProtocol(base.Protocol());
 162         }
 163
 164         if (relative.HasFragment())
 165                 SetFragment(relative.Fragment());
 166 }
 167
 168
 169 BUrl::BUrl()
 170         :
 171         fUrlString(),
 172         fProtocol(),
 173         fUser(),
 174         fPassword(),
 175         fHost(),
 176         fPort(0),
 177         fPath(),
 178         fRequest(),
 179         fHasHost(false),
 180         fHasFragment(false)
 181 {
 182         _ResetFields();
 183 }
 184
 185
 186 BUrl::BUrl(const BPath& path)
 187         :
 188         fUrlString(),
 189         fProtocol(),
 190         fUser(),
 191         fPassword(),
 192         fHost(),
 193         fPort(0),
 194         fPath(),
 195         fRequest(),
 196         fHasHost(false),
 197         fHasFragment(false)
 198 {
 199         SetUrlString(UrlEncode(path.Path(), true, true));
 200         SetProtocol("file");
 201 }
 202
 203
 204 BUrl::~BUrl()
 205 {
 206 }
 207
 208
 209 // #pragma mark URL fields modifiers
 210
 211
 212 BUrl&
 213 BUrl::SetUrlString(const BString& url)
 214 {
 215         _ExplodeUrlString(url);
 216         return *this;
 217 }
 218
 219
 220 BUrl&
 221 BUrl::SetProtocol(const BString& protocol)
 222 {
 223         fProtocol = protocol;
 224         fHasProtocol = !fProtocol.IsEmpty();
 225         fUrlStringValid = false;
 226         return *this;
 227 }
 228
 229
 230 BUrl&
 231 BUrl::SetUserName(const BString& user)
 232 {
 233         fUser = user;
 234         fHasUserName = !fUser.IsEmpty();
 235         fUrlStringValid = false;
 236         fAuthorityValid = false;
 237         fUserInfoValid = false;
 238         return *this;
 239 }
 240
 241
 242 BUrl&
 243 BUrl::SetPassword(const BString& password)
 244 {
 245         fPassword = password;
 246         fHasPassword = !fPassword.IsEmpty();
 247         fUrlStringValid = false;
 248         fAuthorityValid = false;
 249         fUserInfoValid = false;
 250         return *this;
 251 }
 252
 253
 254 BUrl&
 255 BUrl::SetHost(const BString& host)
 256 {
 257         fHost = host;
 258         fHasHost = !fHost.IsEmpty();
 259         fUrlStringValid = false;
 260         fAuthorityValid = false;
 261         return *this;
 262 }
 263
 264
 265 BUrl&
 266 BUrl::SetPort(int port)
 267 {
 268         fPort = port;
 269         fHasPort = (port != 0);
 270         fUrlStringValid = false;
 271         fAuthorityValid = false;
 272         return *this;
 273 }
 274
 275
 276 BUrl&
 277 BUrl::SetPath(const BString& path)
 278 {
 279         // Implements RFC3986 section 5.2.4, "Remove dot segments"
 280
 281         // 1.
 282         BString output;
 283         BString input(path);
 284
 285         // 2.
 286         while(!input.IsEmpty())
 287         {
 288                 // 2.A.
 289                 if (input.StartsWith("./"))
 290                 {
 291                         input.Remove(0, 2);
 292                         continue;
 293                 }
 294
 295                 if (input.StartsWith("../"))
 296                 {
 297                         input.Remove(0, 3);
 298                         continue;
 299                 }
 300
 301                 // 2.B.
 302                 if (input.StartsWith("/./"))
 303                 {
 304                         input.Remove(0, 2);
 305                         continue;
 306                 }
 307
 308                 if (input == "/.")
 309                 {
 310                         input.Remove(1, 1);
 311                         continue;
 312                 }
 313
 314                 // 2.C.
 315                 if (input.StartsWith("/../"))
 316                 {
 317                         input.Remove(0, 3);
 318                         output.Truncate(output.FindLast('/'));
 319                         continue;
 320                 }
 321
 322                 if (input == "/..")
 323                 {
 324                         input.Remove(1, 2);
 325                         output.Truncate(output.FindLast('/'));
 326                         continue;
 327                 }
 328
 329                 // 2.D.
 330                 if (input == "." || input == "..")
 331                 {
 332                         break;
 333                 }
 334
 335                 if (input == "/.")
 336                 {
 337                         input.Remove(1, 1);
 338                         continue;
 339                 }
 340
 341                 // 2.E.
 342                 int slashpos = input.FindFirst('/', 1);
 343                 if (slashpos > 0) {
 344                         output.Append(input, slashpos);
 345                         input.Remove(0, slashpos);
 346                 } else {
 347                         output.Append(input);
 348                         break;
 349                 }
 350         }
 351
 352         _SetPathUnsafe(output);
 353         return *this;
 354 }
 355
 356
 357 BUrl&
 358 BUrl::SetRequest(const BString& request)
 359 {
 360         fRequest = request;
 361         fHasRequest = !fRequest.IsEmpty();
 362         fUrlStringValid = false;
 363         return *this;
 364 }
 365
 366
 367 BUrl&
 368 BUrl::SetFragment(const BString& fragment)
 369 {
 370         fFragment = fragment;
 371         fHasFragment = true;
 372         fUrlStringValid = false;
 373         return *this;
 374 }
 375
 376
 377 // #pragma mark URL fields access
 378
 379
 380 const BString&
 381 BUrl::UrlString() const
 382 {
 383         if (!fUrlStringValid) {
 384                 fUrlString.Truncate(0);
 385
 386                 if (HasProtocol()) {
 387                         fUrlString << fProtocol << ':';
 388                 }
 389
 390                 if (HasAuthority()) {
 391                         fUrlString << "//";
 392                         fUrlString << Authority();
 393                 }
 394                 fUrlString << Path();
 395
 396                 if (HasRequest())
 397                         fUrlString << '?' << fRequest;
 398
 399                 if (HasFragment())
 400                         fUrlString << '#' << fFragment;
 401
 402                 fUrlStringValid = true;
 403         }
 404
 405         return fUrlString;
 406 }
 407
 408
 409 const BString&
 410 BUrl::Protocol() const
 411 {
 412         return fProtocol;
 413 }
 414
 415
 416 const BString&
 417 BUrl::UserName() const
 418 {
 419         return fUser;
 420 }
 421
 422
 423 const BString&
 424 BUrl::Password() const
 425 {
 426         return fPassword;
 427 }
 428
 429
 430 const BString&
 431 BUrl::UserInfo() const
 432 {
 433         if (!fUserInfoValid) {
 434                 fUserInfo = fUser;
 435
 436                 if (HasPassword())
 437                         fUserInfo << ':' << fPassword;
 438
 439                 fUserInfoValid = true;
 440         }
 441
 442         return fUserInfo;
 443 }
 444
 445
 446 const BString&
 447 BUrl::Host() const
 448 {
 449         return fHost;
 450 }
 451
 452
 453 int
 454 BUrl::Port() const
 455 {
 456         return fPort;
 457 }
 458
 459
 460 const BString&
 461 BUrl::Authority() const
 462 {
 463         if (!fAuthorityValid) {
 464                 fAuthority.Truncate(0);
 465
 466                 if (HasUserInfo())
 467                         fAuthority << UserInfo() << '@';
 468                 fAuthority << Host();
 469
 470                 if (HasPort())
 471                         fAuthority << ':' << fPort;
 472
 473                 fAuthorityValid = true;
 474         }
 475         return fAuthority;
 476 }
 477
 478
 479 const BString&
 480 BUrl::Path() const
 481 {
 482         return fPath;
 483 }
 484
 485
 486 const BString&
 487 BUrl::Request() const
 488 {
 489         return fRequest;
 490 }
 491
 492
 493 const BString&
 494 BUrl::Fragment() const
 495 {
 496         return fFragment;
 497 }
 498
 499
 500 // #pragma mark URL fields tests
 501
 502
 503 bool
 504 BUrl::IsValid() const
 505 {
 506         if (!fHasProtocol)
 507                 return false;
 508
 509         if (fProtocol == "http" || fProtocol == "https" || fProtocol == "ftp"
 510                 || fProtocol == "ipp" || fProtocol == "afp" || fProtocol == "telnet"
 511                 || fProtocol == "gopher" || fProtocol == "nntp" || fProtocol == "sftp"
 512                 || fProtocol == "finger" || fProtocol == "pop" || fProtocol == "imap") {
 513                 return fHasHost && !fHost.IsEmpty();
 514         }
 515
 516         if (fProtocol == "file")
 517                 return fHasPath;
 518
 519         return true;
 520 }
 521
 522
 523 bool
 524 BUrl::HasProtocol() const
 525 {
 526         return fHasProtocol;
 527 }
 528
 529
 530 bool
 531 BUrl::HasAuthority() const
 532 {
 533         return fHasHost || fHasUserName;
 534 }
 535
 536
 537 bool
 538 BUrl::HasUserName() const
 539 {
 540         return fHasUserName;
 541 }
 542
 543
 544 bool
 545 BUrl::HasPassword() const
 546 {
 547         return fHasPassword;
 548 }
 549
 550
 551 bool
 552 BUrl::HasUserInfo() const
 553 {
 554         return fHasUserName || fHasPassword;
 555 }
 556
 557
 558 bool
 559 BUrl::HasHost() const
 560 {
 561         return fHasHost;
 562 }
 563
 564
 565 bool
 566 BUrl::HasPort() const
 567 {
 568         return fHasPort;
 569 }
 570
 571
 572 bool
 573 BUrl::HasPath() const
 574 {
 575         return fHasPath;
 576 }
 577
 578
 579 bool
 580 BUrl::HasRequest() const
 581 {
 582         return fHasRequest;
 583 }
 584
 585
 586 bool
 587 BUrl::HasFragment() const
 588 {
 589         return fHasFragment;
 590 }
 591
 592
 593 // #pragma mark URL encoding/decoding of needed fields
 594
 595
 596 void
 597 BUrl::UrlEncode(bool strict)
 598 {
 599         fUser = _DoUrlEncodeChunk(fUser, strict);
 600         fPassword = _DoUrlEncodeChunk(fPassword, strict);
 601         fHost = _DoUrlEncodeChunk(fHost, strict);
 602         fFragment = _DoUrlEncodeChunk(fFragment, strict);
 603         fPath = _DoUrlEncodeChunk(fPath, strict, true);
 604 }
 605
 606
 607 void
 608 BUrl::UrlDecode(bool strict)
 609 {
 610         fUser = _DoUrlDecodeChunk(fUser, strict);
 611         fPassword = _DoUrlDecodeChunk(fPassword, strict);
 612         fHost = _DoUrlDecodeChunk(fHost, strict);
 613         fFragment = _DoUrlDecodeChunk(fFragment, strict);
 614         fPath = _DoUrlDecodeChunk(fPath, strict);
 615 }
 616
 617
 618 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
 619 status_t
 620 BUrl::IDNAToAscii()
 621 {
 622         UErrorCode err = U_ZERO_ERROR;
 623         icu::IDNA* converter = icu::IDNA::createUTS46Instance(0, err);
 624         icu::IDNAInfo info;
 625
 626         BString result;
 627         BStringByteSink sink(&result);
 628         converter->nameToASCII_UTF8(icu::StringPiece(fHost.String()), sink, info,
 629                 err);
 630
 631         delete converter;
 632
 633         if (U_FAILURE(err))
 634                 return B_ERROR;
 635
 636         fHost = result;
 637         return B_OK;
 638 }
 639 #endif
 640
 641
 642 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
 643 status_t
 644 BUrl::IDNAToUnicode()
 645 {
 646         UErrorCode err = U_ZERO_ERROR;
 647         icu::IDNA* converter = icu::IDNA::createUTS46Instance(0, err);
 648         icu::IDNAInfo info;
 649
 650         BString result;
 651         BStringByteSink sink(&result);
 652         converter->nameToUnicodeUTF8(icu::StringPiece(fHost.String()), sink, info,
 653                 err);
 654
 655         delete converter;
 656
 657         if (U_FAILURE(err))
 658                 return B_ERROR;
 659
 660         fHost = result;
 661         return B_OK;
 662 }
 663 #endif
 664
 665
 666 // #pragma mark - utility functionality
 667
 668
 669 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
 670 bool
 671 BUrl::HasPreferredApplication() const
 672 {
 673         BString appSignature = PreferredApplication();
 674         BMimeType mime(appSignature.String());
 675
 676         if (appSignature.IFindFirst("application/") == 0
 677                 && mime.IsValid())
 678                 return true;
 679
 680         return false;
 681 }
 682 #endif
 683
 684
 685 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
 686 BString
 687 BUrl::PreferredApplication() const
 688 {
 689         BString appSignature;
 690         BMimeType mime(_UrlMimeType().String());
 691         mime.GetPreferredApp(appSignature.LockBuffer(B_MIME_TYPE_LENGTH));
 692         appSignature.UnlockBuffer();
 693
 694         return BString(appSignature);
 695 }
 696 #endif
 697
 698
 699 #ifdef HAIKU_TARGET_PLATFORM_HAIKU
 700 status_t
 701 BUrl::OpenWithPreferredApplication(bool onProblemAskUser) const
 702 {
 703         if (!IsValid())
 704                 return B_BAD_VALUE;
 705
 706         BString urlString = UrlString();
 707         if (urlString.Length() > B_PATH_NAME_LENGTH) {
 708                 // TODO: BAlert
 709                 //      if (onProblemAskUser)
 710                 //              BAlert ... Too long URL!
 711 #if DEBUG
 712                 fprintf(stderr, "URL too long");
 713 #endif
 714                 return B_NAME_TOO_LONG;
 715         }
 716
 717         char* argv[] = {
 718                 const_cast<char*>("BUrlInvokedApplication"),
 719                 const_cast<char*>(urlString.String()),
 720                 NULL
 721         };
 722
 723 #if DEBUG
 724         if (HasPreferredApplication())
 725                 printf("HasPreferredApplication() == true\n");
 726         else
 727                 printf("HasPreferredApplication() == false\n");
 728 #endif
 729
 730         status_t status = be_roster->Launch(_UrlMimeType().String(), 1, argv+1);
 731         if (status != B_OK) {
 732 #if DEBUG
 733                 fprintf(stderr, "Opening URL failed: %s\n", strerror(status));
 734 #endif
 735         }
 736
 737         return status;
 738 }
 739 #endif
 740
 741
 742 // #pragma mark Url encoding/decoding of string
 743
 744
 745 /*static*/ BString
 746 BUrl::UrlEncode(const BString& url, bool strict, bool directory)
 747 {
 748         return _DoUrlEncodeChunk(url, strict, directory);
 749 }
 750
 751
 752 /*static*/ BString
 753 BUrl::UrlDecode(const BString& url, bool strict)
 754 {
 755         return _DoUrlDecodeChunk(url, strict);
 756 }
 757
 758
 759 // #pragma mark BArchivable members
 760
 761
 762 status_t
 763 BUrl::Archive(BMessage* into, bool deep) const
 764 {
 765         status_t ret = BArchivable::Archive(into, deep);
 766
 767         if (ret == B_OK)
 768                 ret = into->AddString(kArchivedUrl, UrlString());
 769
 770         return ret;
 771 }
 772
 773
 774 /*static*/ BArchivable*
 775 BUrl::Instantiate(BMessage* archive)
 776 {
 777         if (validate_instantiation(archive, "BUrl"))
 778                 return new(std::nothrow) BUrl(archive);
 779         return NULL;
 780 }
 781
 782
 783 // #pragma mark URL comparison
 784
 785
 786 bool
 787 BUrl::operator==(BUrl& other) const
 788 {
 789         UrlString();
 790         other.UrlString();
 791
 792         return fUrlString == other.fUrlString;
 793 }
 794
 795
 796 bool
 797 BUrl::operator!=(BUrl& other) const
 798 {
 799         return !(*this == other);
 800 }
 801
 802
 803 // #pragma mark URL assignment
 804
 805
 806 const BUrl&
 807 BUrl::operator=(const BUrl& other)
 808 {
 809         fUrlStringValid = other.fUrlStringValid;
 810         if (fUrlStringValid)
 811                 fUrlString = other.fUrlString;
 812
 813         fAuthorityValid = other.fAuthorityValid;
 814         if (fAuthorityValid)
 815                 fAuthority = other.fAuthority;
 816
 817         fUserInfoValid = other.fUserInfoValid;
 818         if (fUserInfoValid)
 819                 fUserInfo = other.fUserInfo;
 820
 821         fProtocol = other.fProtocol;
 822         fUser = other.fUser;
 823         fPassword = other.fPassword;
 824         fHost = other.fHost;
 825         fPort = other.fPort;
 826         fPath = other.fPath;
 827         fRequest = other.fRequest;
 828         fFragment = other.fFragment;
 829
 830         fHasProtocol = other.fHasProtocol;
 831         fHasUserName = other.fHasUserName;
 832         fHasPassword = other.fHasPassword;
 833         fHasHost = other.fHasHost;
 834         fHasPort = other.fHasPort;
 835         fHasPath = other.fHasPath;
 836         fHasRequest = other.fHasRequest;
 837         fHasFragment = other.fHasFragment;
 838
 839         return *this;
 840 }
 841
 842
 843 const BUrl&
 844 BUrl::operator=(const BString& string)
 845 {
 846         SetUrlString(string);
 847         return *this;
 848 }
 849
 850
 851 const BUrl&
 852 BUrl::operator=(const char* string)
 853 {
 854         SetUrlString(string);
 855         return *this;
 856 }
 857
 858
 859 // #pragma mark URL to string conversion
 860
 861
 862 BUrl::operator const char*() const
 863 {
 864         return UrlString();
 865 }
 866
 867
 868 void
 869 BUrl::_ResetFields()
 870 {
 871         fHasProtocol = false;
 872         fHasUserName = false;
 873         fHasPassword = false;
 874         fHasHost = false;
 875         fHasPort = false;
 876         fHasPath = false;
 877         fHasRequest = false;
 878         fHasFragment = false;
 879
 880         fProtocol.Truncate(0);
 881         fUser.Truncate(0);
 882         fPassword.Truncate(0);
 883         fHost.Truncate(0);
 884         fPort = 0;
 885         fPath.Truncate(0);
 886         fRequest.Truncate(0);
 887         fFragment.Truncate(0);
 888
 889         // Force re-generation of these fields
 890         fUrlStringValid = false;
 891         fUserInfoValid = false;
 892         fAuthorityValid = false;
 893 }
 894
 895
 896 bool
 897 BUrl::_ContainsDelimiter(const BString& url)
 898 {
 899         int32 len = url.Length();
 900
 901         for (int32 i = 0; i < len; i++) {
 902                 switch (url[i]) {
 903                         case ' ':
 904                         case '\n':
 905                         case '\t':
 906                         case '\r':
 907                         case '<':
 908                         case '>':
 909                         case '"':
 910                                 return true;
 911                 }
 912         }
 913
 914         return false;
 915 }
 916
 917
 918 enum explode_url_parse_state {
 919         EXPLODE_PROTOCOL,
 920         EXPLODE_PROTOCOLTERMINATOR,
 921         EXPLODE_AUTHORITYORPATH,
 922         EXPLODE_AUTHORITY,
 923         EXPLODE_PATH,
 924         EXPLODE_REQUEST, // query
 925         EXPLODE_FRAGMENT,
 926         EXPLODE_COMPLETE
 927 };
 928
 929
 930 typedef bool (*explode_char_match_fn)(char c);
 931
 932
 933 static bool
 934 explode_is_protocol_char(char c)
 935 {
 936         return isalnum(c) || c == '+' || c == '.' || c == '-';
 937 }
 938
 939
 940 static bool
 941 explode_is_authority_char(char c)
 942 {
 943         return !(c == '/' || c == '?' || c == '#');
 944 }
 945
 946
 947 static bool
 948 explode_is_path_char(char c)
 949 {
 950         return !(c == '#' || c == '?');
 951 }
 952
 953
 954 static bool
 955 explode_is_request_char(char c)
 956 {
 957         return c != '#';
 958 }
 959
 960
 961 static int32
 962 char_offset_until_fn_false(const char* url, int32 len, int32 offset,
 963         explode_char_match_fn fn)
 964 {
 965         while (offset < len && fn(url[offset]))
 966                 offset++;
 967
 968         return offset;
 969 }
 970
 971 /*
 972  * This function takes a URL in string-form and parses the components of the URL out.
 973  */
 974 status_t
 975 BUrl::_ExplodeUrlString(const BString& url)
 976 {
 977         _ResetFields();
 978
 979         // RFC3986, Appendix C; the URL should not contain whitespace or delimiters
 980         // by this point.
 981
 982         if (_ContainsDelimiter(url))
 983                 return B_BAD_VALUE;
 984
 985         explode_url_parse_state state = EXPLODE_PROTOCOL;
 986         int32 offset = 0;
 987         int32 length = url.Length();
 988         const char *url_c = url.String();
 989
 990         // The regexp is provided in RFC3986 (URI generic syntax), Appendix B
 991         // ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?
 992         // The ensuing logic attempts to simulate the behaviour of extracting the groups
 993         // from the string without requiring a group-capable regex engine.
 994
 995         while (offset < length) {
 996                 switch (state) {
 997
 998                         case EXPLODE_PROTOCOL:
 999                         {
1000                                 int32 end_protocol = char_offset_until_fn_false(url_c, length,
1001                                         offset, explode_is_protocol_char);
1002
1003                                 if (end_protocol < length) {
1004                                         SetProtocol(BString(&url_c[offset], end_protocol - offset));
1005                                         state = EXPLODE_PROTOCOLTERMINATOR;
1006                                         offset = end_protocol;
1007                                 } else {
1008                                         // No protocol was found, try parsing from the string
1009                                         // start, beginning with authority or path
1010                                         SetProtocol("");
1011                                         offset = 0;
1012                                         state = EXPLODE_AUTHORITYORPATH;
1013                                 }
1014                                 break;
1015                         }
1016
1017                         case EXPLODE_PROTOCOLTERMINATOR:
1018                         {
1019                                 if (url[offset] == ':') {
1020                                         offset++;
1021                                 } else {
1022                                         // No protocol was found, try parsing from the string
1023                                         // start, beginning with authority or path
1024                                         SetProtocol("");
1025                                         offset = 0;
1026                                 }
1027                                 state = EXPLODE_AUTHORITYORPATH;
1028                                 break;
1029                         }
1030
1031                         case EXPLODE_AUTHORITYORPATH:
1032                         {
1033                                 // The authority must start with //. If it isn't there, skip
1034                                 // to parsing the path.
1035                                 if (strncmp(&url_c[offset], "//", 2) == 0) {
1036                                         state = EXPLODE_AUTHORITY;
1037                                         offset += 2;
1038                                 } else {
1039                                         state = EXPLODE_PATH;
1040                                 }
1041                                 break;
1042                         }
1043
1044                         case EXPLODE_AUTHORITY:
1045                         {
1046                                 int end_authority = char_offset_until_fn_false(url_c, length,
1047                                         offset, explode_is_authority_char);
1048                                 SetAuthority(BString(&url_c[offset], end_authority - offset));
1049                                 state = EXPLODE_PATH;
1050                                 offset = end_authority;
1051                                 break;
1052                         }
1053
1054                         case EXPLODE_PATH:
1055                         {
1056                                 int end_path = char_offset_until_fn_false(url_c, length, offset,
1057                                         explode_is_path_char);
1058                                 SetPath(BString(&url_c[offset], end_path - offset));
1059                                 state = EXPLODE_REQUEST;
1060                                 offset = end_path;
1061                                 break;
1062                         }
1063
1064                         case EXPLODE_REQUEST: // query
1065                         {
1066                                 if (url_c[offset] == '?') {
1067                                         offset++;
1068                                         int end_request = char_offset_until_fn_false(url_c, length,
1069                                                 offset, explode_is_request_char);
1070                                         SetRequest(BString(&url_c[offset], end_request - offset));
1071                                         offset = end_request;
1072                                 }
1073                                 state = EXPLODE_FRAGMENT;
1074                                 break;
1075                         }
1076
1077                         case EXPLODE_FRAGMENT:
1078                         {
1079                                 if (url_c[offset] == '#') {
1080                                         offset++;
1081                                         SetFragment(BString(&url_c[offset], length - offset));
1082                                         offset = length;
1083                                 }
1084                                 state = EXPLODE_COMPLETE;
1085                                 break;
1086                         }
1087
1088                         case EXPLODE_COMPLETE:
1089                                 // should never be reached - keeps the compiler happy
1090                                 break;
1091
1092                 }
1093         }
1094
1095         return B_OK;
1096 }
1097
1098
1099 BString
1100 BUrl::_MergePath(const BString& relative) const
1101 {
1102         // This implements RFC3986, Section 5.2.3.
1103         if (HasAuthority() && fPath == "")
1104         {
1105                 BString result("/");
1106                 result << relative;
1107                 return result;
1108         }
1109
1110         BString result(fPath);
1111         result.Truncate(result.FindLast("/") + 1);
1112         result << relative;
1113
1114         return result;
1115 }
1116
1117
1118 // This sets the path without normalizing it. If fed with a path that has . or
1119 // .. segments, this would make the URL invalid.
1120 void
1121 BUrl::_SetPathUnsafe(const BString& path)
1122 {
1123         fPath = path;
1124         fHasPath = true; // RFC says an empty path is still a path
1125         fUrlStringValid = false;
1126 }
1127
1128
1129 enum authority_parse_state {
1130         AUTHORITY_USERNAME,
1131         AUTHORITY_PASSWORD,
1132         AUTHORITY_HOST,
1133         AUTHORITY_PORT,
1134         AUTHORITY_COMPLETE
1135 };
1136
1137
1138 static bool
1139 authority_is_username_char(char c)
1140 {
1141         return !(c == ':' || c == '@');
1142 }
1143
1144
1145 static bool
1146 authority_is_password_char(char c)
1147 {
1148         return !(c == '@');
1149 }
1150
1151
1152 static bool
1153 authority_is_ipv6_host_char(char c) {
1154         return (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')
1155                 || (c >= '0' && c <= '9') || c == ':';
1156 }
1157
1158
1159 static bool
1160 authority_is_host_char(char c) {
1161         return !(c == ':' || c == '/');
1162 }
1163
1164
1165 static bool
1166 authority_is_port_char(char c) {
1167         return c >= '0' && c <= '9';
1168 }
1169
1170
1171 void
1172 BUrl::SetAuthority(const BString& authority)
1173 {
1174         fAuthority = authority;
1175
1176         fUser.Truncate(0);
1177         fPassword.Truncate(0);
1178         fHost.Truncate(0);
1179         fPort = 0;
1180         fHasPort = false;
1181         fHasUserName = false;
1182         fHasPassword = false;
1183
1184         bool hasUsernamePassword = B_ERROR != fAuthority.FindFirst('@');
1185         authority_parse_state state = AUTHORITY_USERNAME;
1186         int32 offset = 0;
1187         int32 length = authority.Length();
1188         const char *authority_c = authority.String();
1189
1190         while (AUTHORITY_COMPLETE != state && offset < length) {
1191
1192                 switch (state) {
1193
1194                         case AUTHORITY_USERNAME:
1195                         {
1196                                 if (hasUsernamePassword) {
1197                                         int32 end_username = char_offset_until_fn_false(
1198                                                 authority_c, length, offset,
1199                                                 authority_is_username_char);
1200
1201                                         SetUserName(BString(&authority_c[offset],
1202                                                 end_username - offset));
1203
1204                                         state = AUTHORITY_PASSWORD;
1205                                         offset = end_username;
1206                                 } else {
1207                                         state = AUTHORITY_HOST;
1208                                 }
1209                                 break;
1210                         }
1211
1212                         case AUTHORITY_PASSWORD:
1213                         {
1214                                 if (hasUsernamePassword && ':' == authority[offset]) {
1215                                         offset++; // move past the delimiter
1216                                         int32 end_password = char_offset_until_fn_false(
1217                                                 authority_c, length, offset,
1218                                                 authority_is_password_char);
1219
1220                                         SetPassword(BString(&authority_c[offset],
1221                                                 end_password - offset));
1222
1223                                         offset = end_password;
1224                                 }
1225
1226                                 // if the host was preceded by a username + password couple
1227                                 // then there will be an '@' delimiter to avoid.
1228
1229                                 if (authority_c[offset] == '@') {
1230                                         offset++;
1231                                 }
1232
1233                                 state = AUTHORITY_HOST;
1234                                 break;
1235                         }
1236
1237                         case AUTHORITY_HOST:
1238                         {
1239
1240                                 // the host may be enclosed within brackets in order to express
1241                                 // an IPV6 address.
1242
1243                                 if (authority_c[offset] == '[') {
1244                                         int32 end_ipv6_host = char_offset_until_fn_false(
1245                                                 authority_c, length, offset + 1,
1246                                                 authority_is_ipv6_host_char);
1247
1248                                         if (authority_c[end_ipv6_host] == ']') {
1249                                                 SetHost(BString(&authority_c[offset],
1250                                                         (end_ipv6_host - offset) + 1));
1251                                                 state = AUTHORITY_PORT;
1252                                                 offset = end_ipv6_host + 1;
1253                                         }
1254                                 }
1255
1256                                 // if an IPV6 host was not found.
1257
1258                                 if (AUTHORITY_HOST == state) {
1259                                         int32 end_host = char_offset_until_fn_false(
1260                                                 authority_c, length, offset, authority_is_host_char);
1261
1262                                         SetHost(BString(&authority_c[offset], end_host - offset));
1263                                         state = AUTHORITY_PORT;
1264                                         offset = end_host;
1265                                 }
1266
1267                                 break;
1268                         }
1269
1270                         case AUTHORITY_PORT:
1271                         {
1272                                 if (authority_c[offset] == ':') {
1273                                         offset++;
1274                                         int32 end_port = char_offset_until_fn_false(
1275                                                 authority_c, length, offset, authority_is_port_char);
1276                                         SetPort(atoi(&authority_c[offset]));
1277                                         offset = end_port;
1278                                 }
1279
1280                                 state = AUTHORITY_COMPLETE;
1281
1282                                 break;
1283                         }
1284
1285                         case AUTHORITY_COMPLETE:
1286                                 // should never be reached - keeps the compiler happy
1287                                 break;
1288                 }
1289         }
1290
1291         // An empty authority is still an authority, making it possible to have
1292         // URLs such as file:///path/to/file.
1293         // TODO however, there is no way to unset the authority once it is set...
1294         // We may want to take a const char* parameter and allow NULL.
1295         fHasHost = true;
1296 }
1297
1298
1299 /*static*/ BString
1300 BUrl::_DoUrlEncodeChunk(const BString& chunk, bool strict, bool directory)
1301 {
1302         BString result;
1303
1304         for (int32 i = 0; i < chunk.Length(); i++) {
1305                 if (_IsUnreserved(chunk[i])
1306                                 || (directory && (chunk[i] == '/' || chunk[i] == '\\'))) {
1307                         result << chunk[i];
1308                 } else {
1309                         if (chunk[i] == ' ' && !strict) {
1310                                 result << '+';
1311                                         // In non-strict mode, spaces are encoded by a plus sign
1312                         } else {
1313                                 char hexString[5];
1314                                 snprintf(hexString, 5, "%X", chunk[i]);
1315
1316                                 result << '%' << hexString;
1317                         }
1318                 }
1319         }
1320
1321         return result;
1322 }
1323
1324
1325 /*static*/ BString
1326 BUrl::_DoUrlDecodeChunk(const BString& chunk, bool strict)
1327 {
1328         BString result;
1329
1330         for (int32 i = 0; i < chunk.Length(); i++) {
1331                 if (chunk[i] == '+' && !strict)
1332                         result << ' ';
1333                 else {
1334                         char decoded = 0;
1335                         char* out = NULL;
1336                         char hexString[3];
1337
1338                         if (chunk[i] == '%' && i < chunk.Length() - 2
1339                                 && isxdigit(chunk[i + 1]) && isxdigit(chunk[i+2])) {
1340                                 hexString[0] = chunk[i + 1];
1341                                 hexString[1] = chunk[i + 2];
1342                                 hexString[2] = 0;
1343                                 decoded = (char)strtol(hexString, &out, 16);
1344                         }
1345
1346                         if (out == hexString + 2) {
1347                                 i += 2;
1348                                 result << decoded;
1349                         } else
1350                                 result << chunk[i];
1351                 }
1352         }
1353         return result;
1354 }
1355
1356
1357 bool
1358 BUrl::_IsProtocolValid()
1359 {
1360         for (int8 index = 0; index < fProtocol.Length(); index++) {
1361                 char c = fProtocol[index];
1362
1363                 if (index == 0 && !isalpha(c))
1364                         return false;
1365                 else if (!isalnum(c) && c != '+' && c != '-' && c != '.')
1366                         return false;
1367         }
1368
1369         return fProtocol.Length() > 0;
1370 }
1371
1372
1373 bool
1374 BUrl::_IsUnreserved(char c)
1375 {
1376         return isalnum(c) || c == '-' || c == '.' || c == '_' || c == '~';
1377 }
1378
1379
1380 bool
1381 BUrl::_IsGenDelim(char c)
1382 {
1383         return c == ':' || c == '/' || c == '?' || c == '#' || c == '['
1384                 || c == ']' || c == '@';
1385 }
1386
1387
1388 bool
1389 BUrl::_IsSubDelim(char c)
1390 {
1391         return c == '!' || c == '$' || c == '&' || c == '\'' || c == '('
1392                 || c == ')' || c == '*' || c == '+' || c == ',' || c == ';'
1393                 || c == '=';
1394 }
1395
1396
1397 BString
1398 BUrl::_UrlMimeType() const
1399 {
1400         BString mime;
1401         mime << "application/x-vnd.Be.URL." << fProtocol;
1402
1403         return BString(mime);
1404 }