1 files changed, 38 insertions, 3 deletions

diff --git a/lib/util.cc b/lib/util.cc
index bb8a2e8..29e6738 100644
--- a/lib/util.cc
+++ b/lib/util.cc
@@ -4,24 +4,25 @@
 #include <cstring>
 #include <vector>
 #include <string>
 #include <stack>
 #include <algorithm>
 #include <openssl/bio.h>
 #include <openssl/evp.h>
 #include <openssl/sha.h>
 #include <openssl/hmac.h>
 #include <curl/curl.h>
 #include <opkele/util.h>
 #include <opkele/exception.h>
+#include <opkele/data.h>
 #include <opkele/debug.h>
 
 #include <config.h>
 #ifdef HAVE_DEMANGLE
 # include <cxxabi.h>
 #endif
 
 namespace opkele {
     using namespace std;
 
     namespace util {
 
@@ -202,37 +203,36 @@ namespace opkele {
         /*
          * Normalize URL according to the rules, described in rfc 3986, section 6
          *
          * - uppercase hex triplets (e.g. %ab -> %AB)
          * - lowercase scheme and host
          * - decode %-encoded characters, specified as unreserved in rfc 3986, section 2.3,
          *   that is - [:alpha:][:digit:]._~-
          * - remove dot segments
          * - remove empty and default ports
          * - if there's no path component, add '/'
          */
          string rfc_3986_normalize_uri(const string& uri) {
-             static const char *whitespace = " \t\r\n";
              string rv;
-             string::size_type ns = uri.find_first_not_of(whitespace);
+             string::size_type ns = uri.find_first_not_of(data::_whitespace_chars);
              if(ns==string::npos)
                  throw bad_input(OPKELE_CP_ "Can't normalize empty URI");
              string::size_type colon = uri.find(':',ns);
              if(colon==string::npos)
                  throw bad_input(OPKELE_CP_ "No scheme specified in URI");
              transform(
                      uri.begin()+ns, uri.begin()+colon+1,
                      back_inserter(rv), ::tolower );
              bool s;
-             string::size_type ul = uri.find_last_not_of(whitespace)+1;
+             string::size_type ul = uri.find_last_not_of(data::_whitespace_chars)+1;
              if(ul <= (colon+3))
                  throw bad_input(OPKELE_CP_ "Unexpected end of URI being normalized encountered");
              if(uri[colon+1]!='/' || uri[colon+2]!='/')
                  throw bad_input(OPKELE_CP_ "Unexpected input in URI being normalized after scheme component");
              if(rv=="http:")
                  s = false;
              else if(rv=="https:")
                  s = true;
              else{
                  /* TODO: support more schemes.  e.g. xri. How do we normalize
                   * xri?
                   */
@@ -421,15 +421,50 @@ namespace opkele {
                 evpmd = EVP_sha1();
             else
                 throw unsupported(OPKELE_CP_ "unknown association type");
             unsigned int md_len = 0;
             unsigned char md[SHA256_DIGEST_LENGTH];
             HMAC(evpmd,
                     &(secret.front()),secret.size(),
                     (const unsigned char*)kv.data(),kv.length(),
                     md,&md_len);
             return encode_base64(md,md_len);
         }
 
+        string normalize_identifier(const string& usi,bool strip_fragment) {
+            if(usi.empty())
+                return usi;
+            string rv;
+            string::size_type fsc = usi.find_first_not_of(data::_whitespace_chars);
+            if(fsc==string::npos)
+                return rv;
+            string::size_type lsc = usi.find_last_not_of(data::_whitespace_chars);
+            assert(lsc!=string::npos);
+            if(!strncasecmp(usi.c_str()+fsc,"xri://",sizeof("xri://")-1))
+                fsc += sizeof("xri://")-1;
+            if( (fsc+1) >= lsc )
+                return rv;
+            rv.assign(usi,fsc,lsc-fsc+1);
+            if(strchr(data::_iname_leaders,rv[0])) {
+                /* TODO: further normalize xri identity, fold case or
+                 * whatever... */
+            }else{
+                if(rv.find("://")==string::npos)
+                    rv.insert(0,"http://");
+                if(strip_fragment) {
+                    string::size_type fp = rv.find('#');
+                    if(fp!=string::npos) {
+                        string::size_type qp = rv.find('?');
+                        if(qp==string::npos || qp<fp)
+                            rv.erase(fp);
+                        else if(qp>fp)
+                            rv.erase(fp,qp-fp);
+                    }
+                }
+                rv = rfc_3986_normalize_uri(rv);
+            }
+            return rv;
+        }
+
     }
 
 }