LCOV - code coverage report
Current view: top level - framework/source/fwi/helper - networkdomain.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 20 0.0 %
Date: 2014-11-03 Functions: 0 3 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #include <helper/networkdomain.hxx>
      21             : 
      22             : #ifdef WNT
      23             : 
      24             : //  Windows
      25             : 
      26             : #define UNICODE
      27             : #if defined _MSC_VER
      28             : #pragma warning(push, 1)
      29             : #endif
      30             : #include <windows.h>
      31             : #if defined _MSC_VER
      32             : #pragma warning(pop)
      33             : #endif
      34             : 
      35             : static DWORD WINAPI GetUserDomainW_NT( LPWSTR lpBuffer, DWORD nSize )
      36             : {
      37             :     return GetEnvironmentVariable( TEXT("USERDOMAIN"), lpBuffer, nSize );
      38             : }
      39             : 
      40             : static OUString GetUserDomain()
      41             : {
      42             :     sal_Unicode aBuffer[256];
      43             :     DWORD   nResult;
      44             : 
      45             :     nResult = GetUserDomainW_NT( reinterpret_cast<LPWSTR>(aBuffer), sizeof( aBuffer ) );
      46             : 
      47             :     if ( nResult > 0 )
      48             :         return OUString( aBuffer );
      49             :     else
      50             :         return OUString();
      51             : }
      52             : 
      53             : //  Windows
      54             : 
      55             : namespace framework
      56             : {
      57             : 
      58             : OUString NetworkDomain::GetYPDomainName()
      59             : {
      60             :     return OUString();
      61             : }
      62             : 
      63             : OUString NetworkDomain::GetNTDomainName()
      64             : {
      65             :     return GetUserDomain();
      66             : }
      67             : 
      68             : }
      69             : 
      70             : #elif defined( UNIX )
      71             : 
      72             : #include <rtl/ustring.h>
      73             : #include <stdlib.h>
      74             : #include <errno.h>
      75             : #include <osl/thread.h>
      76             : 
      77             : //  Unix
      78             : 
      79             : #if defined( SOLARIS )
      80             : 
      81             : //  Solaris
      82             : 
      83             : #include <sys/systeminfo.h>
      84             : #include <sal/alloca.h>
      85             : 
      86             : static rtl_uString *getDomainName()
      87             : {
      88             :     /* Initialize and assume failure */
      89             :     rtl_uString *ustrDomainName = NULL;
      90             : 
      91             :     char    szBuffer[256];
      92             : 
      93             :     long    nCopied = sizeof(szBuffer);
      94             :     char    *pBuffer = szBuffer;
      95             :     long    nBufSize;
      96             : 
      97             :     do
      98             :     {
      99             :         nBufSize = nCopied;
     100             :         nCopied = sysinfo( SI_SRPC_DOMAIN, pBuffer, nBufSize );
     101             : 
     102             :         /*  If nCopied is greater than buffersize we need to allocate
     103             :             a buffer with suitable size */
     104             : 
     105             :         if ( nCopied > nBufSize )
     106             :             pBuffer = (char *)alloca( nCopied );
     107             : 
     108             :     } while ( nCopied > nBufSize );
     109             : 
     110             :     if ( -1 != nCopied  )
     111             :     {
     112             :         rtl_string2UString(
     113             :             &ustrDomainName,
     114             :             pBuffer,
     115             :             nCopied - 1,
     116             :             osl_getThreadTextEncoding(),
     117             :             OSTRING_TO_OUSTRING_CVTFLAGS );
     118             :     }
     119             : 
     120             :     return ustrDomainName;
     121             : }
     122             : 
     123             : #elif defined( LINUX ) /* endif SOLARIS */
     124             : 
     125             : //  Linux
     126             : 
     127             : #include <unistd.h>
     128             : #include <string.h>
     129             : 
     130           0 : static rtl_uString *getDomainName()
     131             : {
     132             :     /* Initialize and assume failure */
     133           0 :     rtl_uString *ustrDomainName = NULL;
     134             : 
     135             :     char    *pBuffer;
     136             :     int     result;
     137           0 :     size_t  nBufSize = 0;
     138             : 
     139           0 :     do
     140             :     {
     141           0 :         nBufSize += 256; /* Increase buffer size by steps of 256 bytes */
     142           0 :         pBuffer = (char *)alloca( nBufSize );
     143           0 :         result = getdomainname( pBuffer, nBufSize );
     144             :         /* If buffersize in not large enough -1 is returned and errno
     145             :         is set to EINVAL. This only applies to libc. With glibc the name
     146             :         is truncated. */
     147           0 :     } while ( -1 == result && EINVAL == errno );
     148             : 
     149           0 :     if ( 0 == result )
     150             :     {
     151             :         rtl_string2UString(
     152             :             &ustrDomainName,
     153             :             pBuffer,
     154           0 :             strlen( pBuffer ),
     155           0 :             osl_getThreadTextEncoding(),
     156           0 :             OSTRING_TO_OUSTRING_CVTFLAGS );
     157             :     }
     158             : 
     159           0 :     return ustrDomainName;
     160             : }
     161             : 
     162             : #else /* LINUX */
     163             : 
     164             : //  Other Unix
     165             : 
     166             : static rtl_uString *getDomainName()
     167             : {
     168             :     return NULL;
     169             : }
     170             : 
     171             : #endif
     172             : 
     173             : //  Unix
     174             : 
     175             : namespace framework
     176             : {
     177             : 
     178           0 : OUString NetworkDomain::GetYPDomainName()
     179             : {
     180           0 :     rtl_uString* pResult = getDomainName();
     181           0 :     if ( pResult )
     182           0 :         return OUString( pResult );
     183             :     else
     184           0 :         return OUString();
     185             : }
     186             : 
     187           0 : OUString NetworkDomain::GetNTDomainName()
     188             : {
     189           0 :     return OUString();
     190             : }
     191             : 
     192             : }
     193             : 
     194             : #else /* UNIX */
     195             : 
     196             : //  Other operating systems (non-Windows and non-Unix)
     197             : 
     198             : namespace framework
     199             : {
     200             : 
     201             : OUString NetworkDomain::GetYPDomainName()
     202             : {
     203             :     return OUString();
     204             : }
     205             : 
     206             : OUString NetworkDomain::GetNTDomainName()
     207             : {
     208             :     return OUString();
     209             : }
     210             : 
     211             : }
     212             : 
     213             : #endif
     214             : 
     215             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10