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