shell/source/backends/macbe/macbackend.mm

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 // For MAXHOSTNAMELEN constant
  22 #include <sys/param.h>
  23
  24 #include <premac.h>
  25 #include <SystemConfiguration/SystemConfiguration.h>
  26 #include <Foundation/NSPathUtilities.h>
  27 #include <postmac.h>
  28
  29 #include "macbackend.hxx"
  30
  31 #include "com/sun/star/beans/Optional.hpp"
  32 #include "rtl/ustrbuf.hxx"
  33 #include "osl/file.h"
  34
  35 #define SPACE      ' '
  36 #define SEMI_COLON ';'
  37
  38 typedef struct
  39 {
  40     rtl::OUString Server;
  41     sal_Int32 Port;
  42 } ProxyEntry;
  43
  44 typedef enum {
  45     sHTTP,
  46     sHTTPS,
  47     sFTP
  48 } ServiceType;
  49
  50 //------------------------------------------------------------------------
  51 // helper functions
  52 //------------------------------------------------------------------------
  53
  54 namespace // private
  55 {
  56
  57 /*
  58  * Returns current proxy settings for selected service type (HTTP or
  59  * FTP) as a C string (in the buffer specified by host and hostSize)
  60  * and a port number.
  61  */
  62
  63 bool GetProxySetting(ServiceType sType, char *host, size_t hostSize, UInt16 *port)
  64 {
  65     bool                result;
  66     CFDictionaryRef     proxyDict;
  67     CFNumberRef         enableNum;
  68     int                 enable;
  69     CFStringRef         hostStr;
  70     CFNumberRef         portNum;
  71     int                 portInt;
  72
  73     proxyDict = SCDynamicStoreCopyProxies(NULL);
  74
  75     if (!proxyDict)
  76         return false;
  77
  78     CFStringRef proxiesEnable;
  79     CFStringRef proxiesProxy;
  80     CFStringRef proxiesPort;
  81
  82     switch ( sType )
  83     {
  84         case sHTTP : proxiesEnable =  kSCPropNetProxiesHTTPEnable;
  85                      proxiesProxy = kSCPropNetProxiesHTTPProxy;
  86                      proxiesPort = kSCPropNetProxiesHTTPPort;
  87             break;
  88         case sHTTPS: proxiesEnable = kSCPropNetProxiesHTTPSEnable;
  89                      proxiesProxy = kSCPropNetProxiesHTTPSProxy;
  90                      proxiesPort = kSCPropNetProxiesHTTPSPort;
  91             break;
  92         default: proxiesEnable = kSCPropNetProxiesFTPEnable;
  93                  proxiesProxy = kSCPropNetProxiesFTPProxy;
  94                  proxiesPort = kSCPropNetProxiesFTPPort;
  95             break;
  96     }
  97     // Proxy enabled?
  98     enableNum = (CFNumberRef) CFDictionaryGetValue( proxyDict,
  99                                                    proxiesEnable );
 100
 101     result = (enableNum != NULL) && (CFGetTypeID(enableNum) == CFNumberGetTypeID());
 102
 103     if (result)
 104         result = CFNumberGetValue(enableNum, kCFNumberIntType, &enable) && (enable != 0);
 105
 106     // Proxy enabled -> get hostname
 107     if (result)
 108     {
 109         hostStr = (CFStringRef) CFDictionaryGetValue( proxyDict,
 110                                                      proxiesProxy );
 111
 112         result = (hostStr != NULL) && (CFGetTypeID(hostStr) == CFStringGetTypeID());
 113     }
 114
 115     if (result)
 116         result = CFStringGetCString(hostStr, host, (CFIndex) hostSize, kCFStringEncodingASCII);
 117
 118     // Get proxy port
 119     if (result)
 120     {
 121         portNum = (CFNumberRef) CFDictionaryGetValue( proxyDict,
 122                                                      proxiesPort );
 123
 124         result = (portNum != NULL) && (CFGetTypeID(portNum) == CFNumberGetTypeID());
 125     }
 126     else
 127     {
 128         CFRelease(proxyDict);
 129         return false;
 130     }
 131
 132     if (result)
 133         result = CFNumberGetValue(portNum, kCFNumberIntType, &portInt);
 134
 135     if (result)
 136         *port = (UInt16) portInt;
 137
 138     if (proxyDict)
 139         CFRelease(proxyDict);
 140
 141     if (!result)
 142     {
 143         *host = 0;
 144         *port = 0;
 145     }
 146
 147     return result;
 148 }
 149
 150 } // end private namespace
 151
 152 //------------------------------------------------------------------------------
 153
 154 MacOSXBackend::MacOSXBackend()
 155 {
 156 }
 157
 158 //------------------------------------------------------------------------------
 159
 160 MacOSXBackend::~MacOSXBackend(void)
 161 {
 162 }
 163
 164 //------------------------------------------------------------------------------
 165
 166 MacOSXBackend* MacOSXBackend::createInstance()
 167 {
 168     return new MacOSXBackend;
 169 }
 170
 171 // ---------------------------------------------------------------------------------------
 172
 173 rtl::OUString CFStringToOUString(const CFStringRef sOrig) {
 174     CFRetain(sOrig);
 175
 176     CFIndex nStringLen = CFStringGetLength(sOrig)+1;
 177
 178     // Allocate a c string buffer
 179     char sBuffer[nStringLen];
 180
 181     CFStringGetCString(sOrig, sBuffer, nStringLen, kCFStringEncodingASCII);
 182
 183     CFRelease(sOrig);
 184
 185     return rtl::OUString::createFromAscii((sal_Char*)sBuffer);
 186 }
 187
 188 rtl::OUString GetOUString( NSString* pStr )
 189 {
 190     if( ! pStr )
 191         return rtl::OUString();
 192     int nLen = [pStr length];
 193     if( nLen == 0 )
 194         return rtl::OUString();
 195
 196     rtl::OUStringBuffer aBuf( nLen+1 );
 197     aBuf.setLength( nLen );
 198     [pStr getCharacters: const_cast<sal_Unicode*>(aBuf.getStr())];
 199     return aBuf.makeStringAndClear();
 200 }
 201
 202 void MacOSXBackend::setPropertyValue(
 203     rtl::OUString const &, css::uno::Any const &)
 204     throw (
 205         css::beans::UnknownPropertyException, css::beans::PropertyVetoException,
 206         css::lang::IllegalArgumentException, css::lang::WrappedTargetException,
 207         css::uno::RuntimeException)
 208 {
 209     throw css::lang::IllegalArgumentException(
 210         rtl::OUString(
 211             "setPropertyValue not supported"),
 212         static_cast< cppu::OWeakObject * >(this), -1);
 213 }
 214
 215 css::uno::Any MacOSXBackend::getPropertyValue(
 216     rtl::OUString const & PropertyName)
 217     throw (
 218         css::beans::UnknownPropertyException, css::lang::WrappedTargetException,
 219         css::uno::RuntimeException)
 220 {
 221     if ( PropertyName == "WorkPathVariable" )
 222     {
 223         rtl::OUString aDocDir;
 224         NSArray* pPaths = NSSearchPathForDirectoriesInDomains( NSDocumentDirectory, NSUserDomainMask, true );
 225         if( pPaths && [pPaths count] > 0 )
 226         {
 227             aDocDir = GetOUString( [pPaths objectAtIndex: 0] );
 228
 229             rtl::OUString aDocURL;
 230             if( aDocDir.getLength() > 0 &&
 231                 osl_getFileURLFromSystemPath( aDocDir.pData, &aDocURL.pData ) == osl_File_E_None )
 232             {
 233                 return css::uno::makeAny(
 234                     css::beans::Optional< css::uno::Any >(
 235                         true, css::uno::makeAny( aDocURL ) ) );
 236             }
 237             else
 238             {
 239                 OSL_TRACE( "user documents list contains empty file path or conversion failed" );
 240             }
 241         }
 242         else
 243         {
 244             OSL_TRACE( "Got nil or empty list of user document directories" );
 245         }
 246         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 247     } else if ( PropertyName == "ooInetFTPProxyName" )
 248     {
 249         ProxyEntry aFtpProxy;
 250
 251         char host[MAXHOSTNAMELEN];
 252         UInt16 port;
 253         bool retVal;
 254
 255         retVal = GetProxySetting(sFTP, host, 100, &port);
 256
 257         if (retVal)
 258         {
 259             aFtpProxy.Server = rtl::OUString::createFromAscii( host );
 260         }
 261
 262         // ftp proxy name
 263         if( aFtpProxy.Server.getLength() > 0 )
 264         {
 265             return css::uno::makeAny(
 266                 css::beans::Optional< css::uno::Any >(
 267                     true, uno::makeAny( aFtpProxy.Server ) ) );
 268         }
 269         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 270     } else if ( PropertyName == "ooInetFTPProxyPort" )
 271     {
 272         ProxyEntry aFtpProxy;
 273
 274         char host[MAXHOSTNAMELEN];
 275         UInt16 port;
 276         bool retVal;
 277
 278         retVal = GetProxySetting(sFTP, host, 100, &port);
 279
 280         if (retVal)
 281         {
 282             aFtpProxy.Port = port;
 283         }
 284
 285         // ftp proxy port
 286         if( aFtpProxy.Port > 0 )
 287         {
 288             return css::uno::makeAny(
 289                 css::beans::Optional< css::uno::Any >(
 290                     true, uno::makeAny( aFtpProxy.Port ) ) );
 291         }
 292         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 293     } else if ( PropertyName == "ooInetHTTPProxyName" )
 294     {
 295         ProxyEntry aHttpProxy;
 296
 297         char host[MAXHOSTNAMELEN];
 298         UInt16 port;
 299         bool retVal;
 300
 301         retVal = GetProxySetting(sHTTP, host, 100, &port);
 302
 303         if (retVal)
 304         {
 305             aHttpProxy.Server = rtl::OUString::createFromAscii( host );
 306         }
 307
 308         // http proxy name
 309         if( aHttpProxy.Server.getLength() > 0 )
 310         {
 311             return css::uno::makeAny(
 312                 css::beans::Optional< css::uno::Any >(
 313                     true, uno::makeAny( aHttpProxy.Server ) ) );
 314         }
 315         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 316     } else if ( PropertyName == "ooInetHTTPProxyPort" )
 317     {
 318         ProxyEntry aHttpProxy;
 319
 320         char host[MAXHOSTNAMELEN];
 321         UInt16 port;
 322         bool retVal;
 323
 324         retVal = GetProxySetting(sHTTP, host, 100, &port);
 325
 326         if (retVal)
 327         {
 328             aHttpProxy.Port = port;
 329         }
 330
 331         // http proxy port
 332         if( aHttpProxy.Port > 0 )
 333         {
 334             return css::uno::makeAny(
 335                 css::beans::Optional< css::uno::Any >(
 336                     true, uno::makeAny( aHttpProxy.Port ) ) );
 337         }
 338         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 339     } else if ( PropertyName == "ooInetHTTPSProxyName" )
 340     {
 341         ProxyEntry aHttpsProxy;
 342
 343         char host[MAXHOSTNAMELEN];
 344         UInt16 port;
 345         bool retVal;
 346
 347         retVal = GetProxySetting(sHTTPS, host, 100, &port);
 348
 349         if (retVal)
 350         {
 351             aHttpsProxy.Server = rtl::OUString::createFromAscii( host );
 352         }
 353
 354         // https proxy name
 355         if( aHttpsProxy.Server.getLength() > 0 )
 356         {
 357             return css::uno::makeAny(
 358                 css::beans::Optional< css::uno::Any >(
 359                     true, uno::makeAny( aHttpsProxy.Server ) ) );
 360         }
 361         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 362     } else if ( PropertyName == "ooInetHTTPSProxyPort" )
 363     {
 364         ProxyEntry aHttpsProxy;
 365
 366         char host[MAXHOSTNAMELEN];
 367         UInt16 port;
 368         bool retVal;
 369
 370         retVal = GetProxySetting(sHTTPS, host, 100, &port);
 371
 372         if (retVal)
 373         {
 374             aHttpsProxy.Port = port;
 375         }
 376
 377         // https proxy port
 378         if( aHttpsProxy.Port > 0 )
 379         {
 380             return css::uno::makeAny(
 381                 css::beans::Optional< css::uno::Any >(
 382                     true, uno::makeAny( aHttpsProxy.Port ) ) );
 383         }
 384         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 385     } else if ( PropertyName == "ooInetProxyType" )
 386     {
 387         // override default for ProxyType, which is "0" meaning "No proxies".
 388         sal_Int32 nProperties = 1;
 389         return css::uno::makeAny(
 390             css::beans::Optional< css::uno::Any >(
 391                 true, uno::makeAny( nProperties ) ) );
 392     } else if ( PropertyName == "ooInetNoProxy" )
 393     {
 394         rtl::OUString aProxyBypassList;
 395
 396         CFArrayRef rExceptionsList;
 397         CFDictionaryRef rProxyDict = SCDynamicStoreCopyProxies(NULL);
 398
 399         if (!rProxyDict)
 400             rExceptionsList = 0;
 401         else
 402             rExceptionsList = (CFArrayRef) CFDictionaryGetValue(rProxyDict, kSCPropNetProxiesExceptionsList);
 403
 404         if (rExceptionsList)
 405         {
 406             for (CFIndex idx = 0; idx < CFArrayGetCount(rExceptionsList); idx++)
 407             {
 408                 CFStringRef rException = (CFStringRef) CFArrayGetValueAtIndex(rExceptionsList, idx);
 409
 410                 if (idx>0)
 411                     aProxyBypassList += rtl::OUString(";");
 412
 413                 aProxyBypassList += CFStringToOUString(rException);
 414             }
 415         }
 416
 417         if (rProxyDict)
 418             CFRelease(rProxyDict);
 419
 420         // fill proxy bypass list
 421         if( aProxyBypassList.getLength() > 0 )
 422         {
 423             return css::uno::makeAny(
 424                 css::beans::Optional< css::uno::Any >(
 425                     true,
 426                     uno::makeAny( aProxyBypassList.replace( SPACE, SEMI_COLON ) ) ) );
 427         }
 428         return css::uno::makeAny(css::beans::Optional< css::uno::Any >());
 429     } else {
 430         throw css::beans::UnknownPropertyException(
 431             PropertyName, static_cast< cppu::OWeakObject * >(this));
 432     }
 433 }
 434
 435 //------------------------------------------------------------------------------
 436
 437 rtl::OUString SAL_CALL MacOSXBackend::getBackendName(void)
 438 {
 439     return rtl::OUString("com.sun.star.comp.configuration.backend.MacOSXBackend");
 440 }
 441
 442 //------------------------------------------------------------------------------
 443
 444 rtl::OUString SAL_CALL MacOSXBackend::getImplementationName(void)
 445     throw (uno::RuntimeException)
 446 {
 447     return getBackendName();
 448 }
 449
 450 //------------------------------------------------------------------------------
 451
 452 uno::Sequence<rtl::OUString> SAL_CALL MacOSXBackend::getBackendServiceNames(void)
 453 {
 454     uno::Sequence<rtl::OUString> aServiceNameList(1);
 455     aServiceNameList[0] = rtl::OUString( "com.sun.star.configuration.backend.MacOSXBackend");
 456
 457     return aServiceNameList;
 458 }
 459
 460 //------------------------------------------------------------------------------
 461
 462 sal_Bool SAL_CALL MacOSXBackend::supportsService(const rtl::OUString& aServiceName)
 463     throw (uno::RuntimeException)
 464 {
 465     uno::Sequence< rtl::OUString > const svc = getBackendServiceNames();
 466
 467     for(sal_Int32 i = 0; i < svc.getLength(); ++i )
 468         if(svc[i] == aServiceName)
 469             return true;
 470
 471     return false;
 472 }
 473
 474 //------------------------------------------------------------------------------
 475
 476 uno::Sequence<rtl::OUString> SAL_CALL MacOSXBackend::getSupportedServiceNames(void)
 477     throw (uno::RuntimeException)
 478 {
 479     return getBackendServiceNames();
 480 }
 481
 482 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */