ucb/source/ucp/webdav-neon/NeonUri.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include "sal/config.h"
  30
  31 #include <string.h>
  32 #include <rtl/uri.hxx>
  33 #include <rtl/ustring.hxx>
  34 #include <rtl/ustrbuf.hxx>
  35 #include "ne_alloc.h"
  36 #include "NeonUri.hxx"
  37 #include "DAVException.hxx"
  38
  39 #include "../inc/urihelper.hxx"
  40
  41 using namespace webdav_ucp;
  42
  43 # if defined __SUNPRO_CC
  44 // FIXME: not sure whether initializing a ne_uri statically is supposed to work
  45 // the string fields of ne_uri are char*, not const char*
  46 # pragma disable_warn
  47 # endif
  48
  49 #if HAVE_GCC_PRAGMA_DIAGNOSTIC_MODIFY
  50 #pragma GCC diagnostic ignored "-Wwrite-strings"
  51 #endif
  52
  53 namespace {
  54
  55 const ne_uri g_sUriDefaultsHTTP  = { (char *) "http",
  56                                      NULL,
  57                                      NULL,
  58                                      DEFAULT_HTTP_PORT,
  59                                      NULL,
  60                                      NULL,
  61                                      NULL };
  62 const ne_uri g_sUriDefaultsHTTPS = { (char *) "https",
  63                                      NULL,
  64                                      NULL,
  65                                      DEFAULT_HTTPS_PORT,
  66                                      NULL,
  67                                      NULL,
  68                                      NULL };
  69 const ne_uri g_sUriDefaultsFTP   = { (char *) "ftp",
  70                                      NULL,
  71                                      NULL,
  72                                      DEFAULT_FTP_PORT,
  73                                      NULL,
  74                                      NULL,
  75                                      NULL };
  76 } // namespace
  77
  78 # if defined __SUNPRO_CC
  79 # pragma enable_warn
  80 #endif
  81
  82 NeonUri::NeonUri( const ne_uri * inUri )
  83     throw ( DAVException )
  84 {
  85     if ( inUri == 0 )
  86         throw DAVException( DAVException::DAV_INVALID_ARG );
  87
  88     char * uri = ne_uri_unparse( inUri );
  89
  90     if ( uri == 0 )
  91         throw DAVException( DAVException::DAV_INVALID_ARG );
  92
  93     init( OString( uri ), inUri );
  94     ne_free( uri );
  95
  96     calculateURI();
  97 }
  98
  99 NeonUri::NeonUri( const OUString & inUri )
 100     throw ( DAVException )
 101 {
 102     if ( inUri.isEmpty() )
 103         throw DAVException( DAVException::DAV_INVALID_ARG );
 104
 105     // #i77023#
 106     OUString aEscapedUri( ucb_impl::urihelper::encodeURI( inUri ) );
 107
 108     OString theInputUri(
 109         aEscapedUri.getStr(), aEscapedUri.getLength(), RTL_TEXTENCODING_UTF8 );
 110
 111     ne_uri theUri;
 112     if ( ne_uri_parse( theInputUri.getStr(), &theUri ) != 0 )
 113     {
 114         ne_uri_free( &theUri );
 115         throw DAVException( DAVException::DAV_INVALID_ARG );
 116     }
 117
 118     init( theInputUri, &theUri );
 119     ne_uri_free( &theUri );
 120
 121     calculateURI();
 122 }
 123
 124 void NeonUri::init( const OString & rUri, const ne_uri * pUri )
 125 {
 126     // Complete URI.
 127     const ne_uri * pUriDefs
 128         = rUri.matchIgnoreAsciiCase( "ftp:" ) ?
 129               &g_sUriDefaultsFTP :
 130           rUri.matchIgnoreAsciiCase( "https:" ) ?
 131               &g_sUriDefaultsHTTPS :
 132               &g_sUriDefaultsHTTP;
 133
 134     mScheme   = OStringToOUString(
 135                     pUri->scheme ? pUri->scheme : pUriDefs->scheme,
 136                     RTL_TEXTENCODING_UTF8 );
 137     mUserInfo = OStringToOUString(
 138                     pUri->userinfo ? pUri->userinfo : pUriDefs->userinfo,
 139                     RTL_TEXTENCODING_UTF8 );
 140     mHostName = OStringToOUString(
 141                     pUri->host ? pUri->host : pUriDefs->host,
 142                     RTL_TEXTENCODING_UTF8 );
 143     mPort     = pUri->port > 0 ? pUri->port : pUriDefs->port;
 144     mPath     = OStringToOUString(
 145                     pUri->path ? pUri->path : pUriDefs->path,
 146                     RTL_TEXTENCODING_UTF8 );
 147
 148     if ( pUri->query )
 149     {
 150         mPath += "?" + OStringToOUString( pUri->query,  RTL_TEXTENCODING_UTF8 );
 151     }
 152
 153     if ( pUri->fragment )
 154     {
 155         mPath += "#" + OStringToOUString( pUri->fragment,  RTL_TEXTENCODING_UTF8 );
 156     }
 157 }
 158
 159 NeonUri::~NeonUri( )
 160 {
 161 }
 162
 163 void NeonUri::calculateURI ()
 164 {
 165     OUStringBuffer aBuf( mScheme );
 166     aBuf.appendAscii( "://" );
 167     if ( !mUserInfo.isEmpty() )
 168     {
 169         //TODO! differentiate between empty and missing userinfo
 170         aBuf.append( mUserInfo );
 171         aBuf.appendAscii( "@" );
 172     }
 173     // Is host a numeric IPv6 address?
 174     if ( ( mHostName.indexOf( ':' ) != -1 ) &&
 175          ( mHostName[ 0 ] != '[' ) )
 176     {
 177         aBuf.appendAscii( "[" );
 178         aBuf.append( mHostName );
 179         aBuf.appendAscii( "]" );
 180     }
 181     else
 182     {
 183         aBuf.append( mHostName );
 184     }
 185
 186     // append port, but only, if not default port.
 187     bool bAppendPort = true;
 188     switch ( mPort )
 189     {
 190     case DEFAULT_HTTP_PORT:
 191         bAppendPort = mScheme != "http";
 192         break;
 193
 194     case DEFAULT_HTTPS_PORT:
 195         bAppendPort = mScheme != "https";
 196         break;
 197
 198     case DEFAULT_FTP_PORT:
 199         bAppendPort = mScheme != "ftp";
 200         break;
 201     }
 202     if ( bAppendPort )
 203     {
 204         aBuf.appendAscii( ":" );
 205         aBuf.append( OUString::number( mPort ) );
 206     }
 207     aBuf.append( mPath );
 208
 209     mURI = aBuf.makeStringAndClear();
 210 }
 211
 212 OUString NeonUri::GetPathBaseName () const
 213 {
 214     sal_Int32 nPos = mPath.lastIndexOf ('/');
 215     sal_Int32 nTrail = 0;
 216     if (nPos == mPath.getLength () - 1)
 217     {
 218         // Trailing slash found. Skip.
 219         nTrail = 1;
 220         nPos = mPath.lastIndexOf ('/', nPos);
 221     }
 222     if (nPos != -1)
 223     {
 224         OUString aTemp(
 225             mPath.copy (nPos + 1, mPath.getLength () - nPos - 1 - nTrail) );
 226
 227         // query, fragment present?
 228         nPos = aTemp.indexOf( '?' );
 229         if ( nPos == -1 )
 230             nPos = aTemp.indexOf( '#' );
 231
 232         if ( nPos != -1 )
 233             aTemp = aTemp.copy( 0, nPos );
 234
 235         return aTemp;
 236     }
 237     else
 238         return OUString("/");
 239 }
 240
 241 bool NeonUri::operator== ( const NeonUri & rOther ) const
 242 {
 243     return ( mURI == rOther.mURI );
 244 }
 245
 246 OUString NeonUri::GetPathBaseNameUnescaped () const
 247 {
 248     return unescape( GetPathBaseName() );
 249 }
 250
 251 void NeonUri::AppendPath (const OUString& rPath)
 252 {
 253     if (mPath.lastIndexOf ('/') != mPath.getLength () - 1)
 254         mPath += "/";
 255
 256     mPath += rPath;
 257     calculateURI ();
 258 };
 259
 260 // static
 261 OUString NeonUri::escapeSegment( const OUString& segment )
 262 {
 263     return rtl::Uri::encode( segment,
 264                              rtl_UriCharClassPchar,
 265                              rtl_UriEncodeIgnoreEscapes,
 266                              RTL_TEXTENCODING_UTF8 );
 267 }
 268
 269 // static
 270 OUString NeonUri::unescape( const OUString& segment )
 271 {
 272     return rtl::Uri::decode( segment,
 273                              rtl_UriDecodeWithCharset,
 274                              RTL_TEXTENCODING_UTF8 );
 275 }
 276
 277 // static
 278 OUString NeonUri::makeConnectionEndPointString(
 279                                 const OUString & rHostName, int nPort )
 280 {
 281     OUStringBuffer aBuf;
 282
 283     // Is host a numeric IPv6 address?
 284     if ( ( rHostName.indexOf( ':' ) != -1 ) &&
 285          ( rHostName[ 0 ] != '[' ) )
 286     {
 287         aBuf.appendAscii( "[" );
 288         aBuf.append( rHostName );
 289         aBuf.appendAscii( "]" );
 290     }
 291     else
 292     {
 293         aBuf.append( rHostName );
 294     }
 295
 296     if ( ( nPort != DEFAULT_HTTP_PORT ) && ( nPort != DEFAULT_HTTPS_PORT ) )
 297     {
 298         aBuf.appendAscii( ":" );
 299         aBuf.append( OUString::number( nPort ) );
 300     }
 301     return aBuf.makeStringAndClear();
 302 }
 303
 304 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */