modules/utils/src/warp_iri.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /**
  17  * This file  have been implemented in compliance with  W3C WARP SPEC.
  18  * but there are some patent issue between  W3C WARP SPEC and APPLE.
  19  * so if you want to use this file, refer to the README file in root directory
  20  */
  21 #include <stddef.h>
  22 #include <list>
  23 #include <set>
  24 #include <string>
  25 #include <dpl/utils/warp_iri.h>
  26 #include <dpl/string.h>
  27 #include <dpl/auto_ptr.h>
  28 #include <dpl/foreach.h>
  29 #include <idna.h>
  30 #include <istream>
  31 #include <iri.h>
  32 //#include <ValidatorCommon.h>
  33
  34 namespace {
  35 // All schemes which are supported by external application should be ignored
  36 // by WARP engine.
  37 //
  38 // Warp specification require from iri to have host element. File protocol
  39 // does not contain host element so it's always denied by warp.
  40 // Unfortunatly all widgets are using file protocol to load its data from
  41 // hard drive. What's why we cannot check any iri with file schema.
  42
  43 const char *IRI_IGNORED_SCHEME[] = { "file://", "widget://", "app://", "tel:",
  44                                      "sms:", "smsto:", "mmsto:", "mailto:", "data:", "blob:",
  45                                      "tizen-service:", 0 };
  46
  47 const DPL::String SCHEMA_HTTP = DPL::FromUTF8String("http");
  48 const DPL::String SCHEMA_HTTPS = DPL::FromUTF8String("https");
  49 const DPL::String SCHEMA_FTP = DPL::FromUTF8String("ftp");
  50 } // namespace anonymous
  51
  52 // This will create AutoPtr deleter for iri_struct.
  53 // Deleter must be in the same namespace as definition of AutoPtr.
  54
  55 namespace DPL {
  56 DECLARE_DELETER(iri_struct, iri_destroy)
  57 } // namespace DPL
  58
  59 WarpIRI::WarpIRI() :
  60     m_domain(false),
  61     m_port(UNKNOWN_PORT),
  62     m_isAccessDefinition(false),
  63     m_isIRIValid(false)
  64 {}
  65
  66 void WarpIRI::set(const char *p_iri,
  67                   bool domain)
  68 {
  69     if (!p_iri) {
  70         m_isAccessDefinition = m_isIRIValid = false;
  71         return;
  72     }
  73
  74     m_domain = domain;
  75     m_isAccessDefinition = true;
  76     m_isIRIValid = true;
  77     m_host.clear();
  78
  79     if (strcmp(p_iri, "*") == 0) {
  80         return;
  81     }
  82
  83     DPL::AutoPtr<iri_struct> iri(iri_parse(p_iri));
  84
  85     if (!iri.get()) {
  86         LogError("Error in iri_parse!");
  87         m_isIRIValid = false;
  88         m_isAccessDefinition = false;
  89         return;
  90     }
  91
  92     if (iri->scheme == NULL || iri->host == NULL) {
  93         m_isIRIValid = false;
  94         m_isAccessDefinition = false;
  95         return;
  96     }
  97
  98     // all of this must be NULL in WARP definition
  99     if (iri->user || iri->path || iri->query || iri->anchor) {
 100         m_isAccessDefinition = false;
 101     }
 102
 103     m_schema = DPL::FromASCIIString(std::string(iri->scheme));
 104     m_port = static_cast<unsigned int>(iri->port);
 105
 106     if (m_port == 0) {
 107         m_port = getPort(m_schema);
 108         if (m_port == UNKNOWN_PORT) {
 109             m_isAccessDefinition = false;
 110             return;
 111         }
 112     }
 113
 114     std::string utf8host = iri->host;
 115     std::list<std::string> hostTokenList;
 116     DPL::Tokenize(utf8host, ".", std::front_inserter(hostTokenList));
 117
 118     if (SCHEMA_HTTP == m_schema || SCHEMA_HTTPS == m_schema) {
 119         FOREACH(i, hostTokenList) {
 120             char *output = NULL;
 121             int rc = idna_to_ascii_8z(i->c_str(),
 122                                       &output,
 123                                       IDNA_USE_STD3_ASCII_RULES);
 124
 125             if (IDNA_SUCCESS != rc) {
 126                 LogWarning("libidn error: " << rc << " " <<
 127                            idna_strerror((Idna_rc)rc));
 128                 m_isIRIValid = false;
 129                 m_isAccessDefinition = false;
 130             } else {
 131                 std::string token(output);
 132                 std::transform(token.begin(),
 133                                token.end(),
 134                                token.begin(),
 135                                    ::tolower);
 136                 m_host.push_back(DPL::FromUTF8String(token));
 137             }
 138             free(output);
 139         }
 140     } else {
 141         FOREACH(i, hostTokenList){
 142             m_host.push_back(DPL::FromUTF8String(*i));
 143         }
 144     }
 145 }
 146
 147 void WarpIRI::set(const DPL::String &iristring,
 148                   bool domain)
 149 {
 150     set(DPL::ToUTF8String(iristring).c_str(), domain);
 151 }
 152
 153 unsigned int WarpIRI::getPort(const DPL::String &schema) const
 154 {
 155     unsigned int port = UNKNOWN_PORT;
 156     if (schema == SCHEMA_HTTP) {
 157         port = 80;
 158     } else if (schema == SCHEMA_HTTPS) {
 159         port = 443;
 160     } else if (schema == SCHEMA_FTP) {
 161         port = 21;
 162     }
 163     return port;
 164 }
 165
 166 bool WarpIRI::isSubDomain(const WarpIRI &second) const
 167 {
 168     if (!m_isAccessDefinition || !second.m_isIRIValid) {
 169         return false;
 170     }
 171     if (m_schema != second.m_schema) {
 172         return false;
 173     }
 174     if (m_port != second.m_port) {
 175         return false;
 176     }
 177
 178     size_t size = m_host.size() < second.m_host.size() ?
 179         m_host.size() : second.m_host.size();
 180
 181     if (m_host.size() > second.m_host.size()) {
 182         return false;
 183     }
 184
 185     if (!m_domain && (m_host.size() != second.m_host.size())) {
 186         return false;
 187     }
 188
 189     for (size_t i = 0; i < size; ++i) {
 190         if (DPL::StringCompare(m_host[i], second.m_host[i])) {
 191             return false;
 192         }
 193     }
 194     return true;
 195 }
 196
 197 bool WarpIRI::isAccessDefinition() const
 198 {
 199     return m_isAccessDefinition;
 200 }
 201
 202 bool WarpIRI::getSubDomain() const
 203 {
 204     return m_domain;
 205 }
 206
 207 bool WarpIRI::isIRISchemaIgnored(const char *iri)
 208 {
 209     for (int i = 0; IRI_IGNORED_SCHEME[i]; ++i) {
 210         if (0 ==
 211             strncmp(iri, IRI_IGNORED_SCHEME[i],
 212                     strlen(IRI_IGNORED_SCHEME[i])))
 213         {
 214             return true;
 215         }
 216     }
 217     return false;
 218 }