modules_wearable/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 <memory>
  24 #include <set>
  25 #include <string>
  26 #include <dpl/utils/warp_iri.h>
  27 #include <dpl/string.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 WarpIRI::WarpIRI() :
  53     m_domain(false),
  54     m_port(UNKNOWN_PORT),
  55     m_isAccessDefinition(false),
  56     m_isIRIValid(false)
  57 {}
  58
  59 void WarpIRI::set(const char *p_iri,
  60                   bool domain)
  61 {
  62     if (!p_iri) {
  63         m_isAccessDefinition = m_isIRIValid = false;
  64         return;
  65     }
  66
  67     m_domain = domain;
  68     m_isAccessDefinition = true;
  69     m_isIRIValid = true;
  70     m_host.clear();
  71
  72     if (strcmp(p_iri, "*") == 0) {
  73         return;
  74     }
  75     std::unique_ptr<iri_struct, decltype(&iri_destroy)> iri(iri_parse(p_iri), iri_destroy);
  76
  77     if (!iri.get()) {
  78         LogError("Error in iri_parse!");
  79         m_isIRIValid = false;
  80         m_isAccessDefinition = false;
  81         return;
  82     }
  83
  84     if (iri->scheme == NULL || iri->host == NULL) {
  85         m_isIRIValid = false;
  86         m_isAccessDefinition = false;
  87         return;
  88     }
  89
  90     // all of this must be NULL in WARP definition
  91     if (iri->user || iri->path || iri->query || iri->anchor) {
  92         m_isAccessDefinition = false;
  93     }
  94
  95     m_schema = DPL::FromASCIIString(std::string(iri->scheme));
  96     m_port = static_cast<unsigned int>(iri->port);
  97
  98     if (m_port == 0) {
  99         m_port = getPort(m_schema);
 100         if (m_port == UNKNOWN_PORT) {
 101             m_isAccessDefinition = false;
 102             return;
 103         }
 104     }
 105
 106     std::string utf8host = iri->host;
 107     std::list<std::string> hostTokenList;
 108     DPL::Tokenize(utf8host, ".", std::front_inserter(hostTokenList));
 109
 110     if (SCHEMA_HTTP == m_schema || SCHEMA_HTTPS == m_schema) {
 111         FOREACH(i, hostTokenList) {
 112             char *output = NULL;
 113             int rc = idna_to_ascii_8z(i->c_str(),
 114                                       &output,
 115                                       IDNA_USE_STD3_ASCII_RULES);
 116
 117             if (IDNA_SUCCESS != rc) {
 118                 LogWarning("libidn error: " << rc << " " <<
 119                            idna_strerror((Idna_rc)rc));
 120                 m_isIRIValid = false;
 121                 m_isAccessDefinition = false;
 122             } else {
 123                 std::string token(output);
 124                 std::transform(token.begin(),
 125                                token.end(),
 126                                token.begin(),
 127                                    ::tolower);
 128                 m_host.push_back(DPL::FromUTF8String(token));
 129             }
 130             free(output);
 131         }
 132     } else {
 133         FOREACH(i, hostTokenList){
 134             m_host.push_back(DPL::FromUTF8String(*i));
 135         }
 136     }
 137 }
 138
 139 void WarpIRI::set(const DPL::String &iristring,
 140                   bool domain)
 141 {
 142     set(DPL::ToUTF8String(iristring).c_str(), domain);
 143 }
 144
 145 unsigned int WarpIRI::getPort(const DPL::String &schema) const
 146 {
 147     unsigned int port = UNKNOWN_PORT;
 148     if (schema == SCHEMA_HTTP) {
 149         port = 80;
 150     } else if (schema == SCHEMA_HTTPS) {
 151         port = 443;
 152     } else if (schema == SCHEMA_FTP) {
 153         port = 21;
 154     }
 155     return port;
 156 }
 157
 158 bool WarpIRI::isSubDomain(const WarpIRI &second) const
 159 {
 160     if (!m_isAccessDefinition || !second.m_isIRIValid) {
 161         return false;
 162     }
 163     if (m_schema != second.m_schema) {
 164         return false;
 165     }
 166     if (m_port != second.m_port) {
 167         return false;
 168     }
 169
 170     size_t size = m_host.size() < second.m_host.size() ?
 171         m_host.size() : second.m_host.size();
 172
 173     if (m_host.size() > second.m_host.size()) {
 174         return false;
 175     }
 176
 177     if (!m_domain && (m_host.size() != second.m_host.size())) {
 178         return false;
 179     }
 180
 181     for (size_t i = 0; i < size; ++i) {
 182         if (DPL::StringCompare(m_host[i], second.m_host[i])) {
 183             return false;
 184         }
 185     }
 186     return true;
 187 }
 188
 189 bool WarpIRI::isAccessDefinition() const
 190 {
 191     return m_isAccessDefinition;
 192 }
 193
 194 bool WarpIRI::getSubDomain() const
 195 {
 196     return m_domain;
 197 }
 198
 199 bool WarpIRI::isIRISchemaIgnored(const char *iri)
 200 {
 201     for (int i = 0; IRI_IGNORED_SCHEME[i]; ++i) {
 202         if (0 ==
 203             strncmp(iri, IRI_IGNORED_SCHEME[i],
 204                     strlen(IRI_IGNORED_SCHEME[i])))
 205         {
 206             return true;
 207         }
 208     }
 209     return false;
 210 }