sal/osl/w32/security.cxx

   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 "system.h"
  21 #include <userenv.h>
  22
  23 #include <cassert>
  24 #include <osl/security.h>
  25 #include <osl/diagnose.h>
  26 #include <osl/thread.h>
  27 #include <osl/file.h>
  28 #include <systools/win32/comtools.hxx>
  29 #include <systools/win32/uwinapi.h>
  30 #include <sddl.h>
  31 #include <sal/macros.h>
  32 #include <sal/log.hxx>
  33 #include <o3tl/char16_t2wchar_t.hxx>
  34 #include "secimpl.hxx"
  35
  36 /* To get an impersonation token we need to create an impersonation
  37    duplicate so every access token has to be created with duplicate
  38    access rights */
  39
  40 #define TOKEN_DUP_QUERY (TOKEN_QUERY|TOKEN_DUPLICATE)
  41
  42 static bool GetSpecialFolder(rtl_uString **strPath, REFKNOWNFOLDERID rFolder);
  43 // We use LPCTSTR here, because we use it with SE_foo_NAME constants
  44 // which are defined in winnt.h as UNICODE-dependent TEXT("PrivilegeName")
  45 static bool Privilege(LPCTSTR pszPrivilege, bool bEnable);
  46 static bool getUserNameImpl(oslSecurity Security, rtl_uString **strName, bool bIncludeDomain);
  47
  48 oslSecurity SAL_CALL osl_getCurrentSecurity(void)
  49 {
  50     oslSecurityImpl* pSecImpl = static_cast<oslSecurityImpl *>(malloc(sizeof(oslSecurityImpl)));
  51     if (pSecImpl)
  52     {
  53         pSecImpl->m_pNetResource = nullptr;
  54         pSecImpl->m_User[0] = '\0';
  55         pSecImpl->m_hToken = nullptr;
  56         pSecImpl->m_hProfile = nullptr;
  57     }
  58     return pSecImpl;
  59 }
  60
  61 oslSecurityError SAL_CALL osl_loginUser( rtl_uString *strUserName, rtl_uString *strPasswd, oslSecurity *pSecurity )
  62 {
  63     oslSecurityError ret;
  64
  65     sal_Unicode*    strUser;
  66     sal_Unicode*    strDomain = o3tl::toU(_wcsdup(o3tl::toW(rtl_uString_getStr(strUserName))));
  67     HANDLE  hUserToken;
  68     LUID luid;
  69
  70     if (nullptr != (strUser = o3tl::toU(wcschr(o3tl::toW(strDomain), L'/'))))
  71         *strUser++ = L'\0';
  72     else
  73     {
  74         strUser   = strDomain;
  75         strDomain = nullptr;
  76     }
  77
  78     // this process must have the right: 'act as a part of operatingsystem'
  79     OSL_ASSERT(LookupPrivilegeValue(nullptr, SE_TCB_NAME, &luid));
  80     (void) luid;
  81
  82     if (LogonUserW(o3tl::toW(strUser), strDomain ? o3tl::toW(strDomain) : L"", o3tl::toW(rtl_uString_getStr(strPasswd)),
  83                   LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT,
  84                    &hUserToken))
  85     {
  86         oslSecurityImpl* pSecImpl = static_cast<oslSecurityImpl *>(malloc(sizeof(oslSecurityImpl)));
  87         if (pSecImpl)
  88         {
  89             pSecImpl->m_pNetResource = nullptr;
  90             pSecImpl->m_hToken = hUserToken;
  91             pSecImpl->m_hProfile = nullptr;
  92             wcscpy(o3tl::toW(pSecImpl->m_User), o3tl::toW(strUser));
  93         }
  94         *pSecurity = pSecImpl;
  95         ret = pSecImpl ? osl_Security_E_None : osl_Security_E_Unknown;
  96     }
  97     else
  98     {
  99         ret = osl_Security_E_UserUnknown;
 100     }
 101
 102     if (strDomain)
 103         free(strDomain);
 104     else
 105         free(strUser);
 106
 107     return ret;
 108 }
 109
 110 oslSecurityError SAL_CALL osl_loginUserOnFileServer(rtl_uString *strUserName,
 111                                                     rtl_uString *strPasswd,
 112                                                     rtl_uString *strFileServer,
 113                                                     oslSecurity *pSecurity)
 114 {
 115     oslSecurityError    ret;
 116     DWORD               err;
 117     NETRESOURCEW        netResource;
 118     sal_Unicode*                remoteName;
 119     sal_Unicode*                userName;
 120
 121     remoteName  = static_cast<sal_Unicode *>(malloc((rtl_uString_getLength(strFileServer) + rtl_uString_getLength(strUserName) + 4) * sizeof(sal_Unicode)));
 122     userName    = static_cast<sal_Unicode *>(malloc((rtl_uString_getLength(strFileServer) + rtl_uString_getLength(strUserName) + 2) * sizeof(sal_Unicode)));
 123
 124     wcscpy(o3tl::toW(remoteName), L"\\\\");
 125     wcscat(o3tl::toW(remoteName), o3tl::toW(rtl_uString_getStr(strFileServer)));
 126     wcscat(o3tl::toW(remoteName), L"\\");
 127     wcscat(o3tl::toW(remoteName), o3tl::toW(rtl_uString_getStr(strUserName)));
 128
 129     wcscpy(o3tl::toW(userName), o3tl::toW(rtl_uString_getStr(strFileServer)));
 130     wcscat(o3tl::toW(userName), L"\\");
 131     wcscat(o3tl::toW(userName), o3tl::toW(rtl_uString_getStr(strUserName)));
 132
 133     netResource.dwScope         = RESOURCE_GLOBALNET;
 134     netResource.dwType          = RESOURCETYPE_DISK;
 135     netResource.dwDisplayType   = RESOURCEDISPLAYTYPE_SHARE;
 136     netResource.dwUsage         = RESOURCEUSAGE_CONNECTABLE;
 137     netResource.lpLocalName     = nullptr;
 138     netResource.lpRemoteName    = o3tl::toW(remoteName);
 139     netResource.lpComment       = nullptr;
 140     netResource.lpProvider      = nullptr;
 141
 142     err = WNetAddConnection2W(&netResource, o3tl::toW(rtl_uString_getStr(strPasswd)), o3tl::toW(userName), 0);
 143
 144     if ((err == NO_ERROR) || (err == ERROR_ALREADY_ASSIGNED))
 145     {
 146         oslSecurityImpl* pSecImpl = static_cast<oslSecurityImpl *>(malloc(sizeof(oslSecurityImpl)));
 147         if (pSecImpl)
 148         {
 149             pSecImpl->m_pNetResource = static_cast<NETRESOURCEW *>(malloc(sizeof(NETRESOURCE)));
 150             if (pSecImpl->m_pNetResource)
 151             {
 152                 *pSecImpl->m_pNetResource = netResource;
 153                 pSecImpl->m_hToken = nullptr;
 154                 pSecImpl->m_hProfile = nullptr;
 155                 wcscpy(o3tl::toW(pSecImpl->m_User), o3tl::toW(rtl_uString_getStr(strUserName)));
 156             }
 157             else
 158             {
 159                 free(pSecImpl);
 160                 pSecImpl = nullptr;
 161             }
 162         }
 163         *pSecurity = pSecImpl;
 164
 165         ret = pSecImpl ? osl_Security_E_None : osl_Security_E_Unknown;
 166     }
 167     else
 168     {
 169         ret = osl_Security_E_UserUnknown;
 170     }
 171
 172     free(remoteName);
 173     free(userName);
 174
 175     return ret;
 176 }
 177
 178 sal_Bool SAL_CALL osl_isAdministrator(oslSecurity Security)
 179 {
 180     if (!Security)
 181         return false;
 182
 183     HANDLE                      hImpersonationToken = nullptr;
 184     PSID                        psidAdministrators;
 185     SID_IDENTIFIER_AUTHORITY    siaNtAuthority = { SECURITY_NT_AUTHORITY };
 186     bool                    bSuccess = false;
 187
 188     /* If Security contains an access token we need to duplicate it to an impersonation
 189        access token. NULL works with CheckTokenMembership() as the current effective
 190        impersonation token
 191      */
 192
 193     if ( static_cast<oslSecurityImpl*>(Security)->m_hToken )
 194     {
 195         if ( !DuplicateToken (static_cast<oslSecurityImpl*>(Security)->m_hToken, SecurityImpersonation, &hImpersonationToken) )
 196             return false;
 197     }
 198
 199     /* CheckTokenMembership() can be used on W2K and higher (NT4 no longer supported by OOo)
 200        and also works on Vista to retrieve the effective user rights. Just checking for
 201        membership of Administrators group is not enough on Vista this would require additional
 202        complicated checks as described in KB article Q118626: http://support.microsoft.com/kb/118626/en-us
 203     */
 204
 205     if (AllocateAndInitializeSid(&siaNtAuthority,
 206                                  2,
 207                                  SECURITY_BUILTIN_DOMAIN_RID,
 208                                  DOMAIN_ALIAS_RID_ADMINS,
 209                                  0, 0, 0, 0, 0, 0,
 210                                  &psidAdministrators))
 211     {
 212         BOOL fSuccess = FALSE;
 213
 214         if (CheckTokenMembership(hImpersonationToken, psidAdministrators, &fSuccess) && fSuccess)
 215             bSuccess = true;
 216
 217         FreeSid(psidAdministrators);
 218     }
 219
 220     if (hImpersonationToken)
 221         CloseHandle(hImpersonationToken);
 222
 223     return bSuccess;
 224 }
 225
 226 void SAL_CALL osl_freeSecurityHandle(oslSecurity Security)
 227 {
 228     if (!Security)
 229         return;
 230
 231     oslSecurityImpl *pSecImpl = static_cast<oslSecurityImpl*>(Security);
 232
 233     if (pSecImpl->m_pNetResource != nullptr)
 234     {
 235         WNetCancelConnection2W(pSecImpl->m_pNetResource->lpRemoteName, 0, true);
 236
 237         free(pSecImpl->m_pNetResource->lpRemoteName);
 238         free(pSecImpl->m_pNetResource);
 239     }
 240
 241     if (pSecImpl->m_hToken)
 242         CloseHandle(pSecImpl->m_hToken);
 243
 244     if ( pSecImpl->m_hProfile )
 245         CloseHandle(pSecImpl->m_hProfile);
 246
 247     free (pSecImpl);
 248 }
 249
 250 sal_Bool SAL_CALL osl_getUserIdent(oslSecurity Security, rtl_uString **strIdent)
 251 {
 252     if (!Security)
 253        return false;
 254
 255     oslSecurityImpl *pSecImpl = static_cast<oslSecurityImpl*>(Security);
 256
 257     HANDLE hAccessToken = pSecImpl->m_hToken;
 258
 259     if (hAccessToken == nullptr)
 260         OpenProcessToken(GetCurrentProcess(), TOKEN_DUP_QUERY, &hAccessToken);
 261
 262     if (hAccessToken)
 263     {
 264         DWORD  nInfoBuffer = 512;
 265         UCHAR* pInfoBuffer = static_cast<UCHAR *>(malloc(nInfoBuffer));
 266
 267         while (!GetTokenInformation(hAccessToken, TokenUser,
 268                                        pInfoBuffer, nInfoBuffer, &nInfoBuffer))
 269         {
 270             if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 271             {
 272                 if (auto p = static_cast<UCHAR *>(realloc(pInfoBuffer, nInfoBuffer)))
 273                     pInfoBuffer = p;
 274                 else
 275                 {
 276                     free(pInfoBuffer);
 277                     pInfoBuffer = nullptr;
 278                     break;
 279                 }
 280             }
 281             else
 282             {
 283                 free(pInfoBuffer);
 284                 pInfoBuffer = nullptr;
 285                 break;
 286             }
 287         }
 288
 289         if (pSecImpl->m_hToken == nullptr)
 290             CloseHandle(hAccessToken);
 291
 292         if (pInfoBuffer)
 293         {
 294             PSID pSid = reinterpret_cast<PTOKEN_USER>(pInfoBuffer)->User.Sid;
 295
 296             LPWSTR pSidStr = nullptr;
 297             bool bResult = ConvertSidToStringSidW(pSid, &pSidStr);
 298             if (bResult)
 299             {
 300                 rtl_uString_newFromStr(strIdent, o3tl::toU(pSidStr));
 301                 LocalFree(pSidStr);
 302             }
 303             else
 304             {
 305                 const DWORD dwError = GetLastError();
 306                 SAL_WARN(
 307                     "sal.osl",
 308                     "ConvertSidToStringSidW failed. GetLastError returned: " << dwError);
 309             }
 310
 311             free(pInfoBuffer);
 312
 313             return bResult;
 314         }
 315     }
 316     else
 317     {
 318         DWORD needed = 0;
 319
 320         WNetGetUserW(nullptr, nullptr, &needed);
 321         if (needed < 16)
 322             needed = 16;
 323
 324         if (auto Ident = static_cast<sal_Unicode *>(malloc(needed*sizeof(sal_Unicode))))
 325         {
 326             if (WNetGetUserW(nullptr, o3tl::toW(Ident), &needed) != NO_ERROR)
 327             {
 328                 wcscpy(o3tl::toW(Ident), L"unknown");
 329                 Ident[7] = L'\0';
 330             }
 331
 332             rtl_uString_newFromStr( strIdent, Ident);
 333             free(Ident);
 334             return true;
 335         }
 336     }
 337     return false;
 338 }
 339
 340 sal_Bool SAL_CALL osl_getUserName(oslSecurity Security, rtl_uString **strName)
 341 {
 342     return getUserNameImpl(Security, strName, true);
 343 }
 344
 345 sal_Bool SAL_CALL osl_getShortUserName(oslSecurity Security, rtl_uString **strName)
 346 {
 347     return getUserNameImpl(Security, strName, false);
 348 }
 349
 350 sal_Bool SAL_CALL osl_getHomeDir(oslSecurity Security, rtl_uString **pustrDirectory)
 351 {
 352     if (!Security)
 353         return false;
 354
 355     rtl_uString *ustrSysDir = nullptr;
 356     bool bSuccess = false;
 357
 358     oslSecurityImpl *pSecImpl = static_cast<oslSecurityImpl*>(Security);
 359
 360     if (pSecImpl->m_pNetResource != nullptr)
 361     {
 362         rtl_uString_newFromStr( &ustrSysDir, o3tl::toU(pSecImpl->m_pNetResource->lpRemoteName));
 363
 364         bSuccess = osl_File_E_None == osl_getFileURLFromSystemPath( ustrSysDir, pustrDirectory );
 365     }
 366     else
 367     {
 368             bSuccess = GetSpecialFolder(&ustrSysDir, FOLDERID_Documents) &&
 369                                  (osl_File_E_None == osl_getFileURLFromSystemPath(ustrSysDir, pustrDirectory));
 370     }
 371
 372     if ( ustrSysDir )
 373         rtl_uString_release( ustrSysDir );
 374
 375     return bSuccess;
 376 }
 377
 378 sal_Bool SAL_CALL osl_getConfigDir(oslSecurity Security, rtl_uString **pustrDirectory)
 379 {
 380     if (!Security)
 381         return false;
 382
 383     bool bSuccess = false;
 384     oslSecurityImpl *pSecImpl = static_cast<oslSecurityImpl*>(Security);
 385
 386     if (pSecImpl->m_pNetResource != nullptr)
 387     {
 388         rtl_uString *ustrSysDir = nullptr;
 389
 390         rtl_uString_newFromStr( &ustrSysDir, o3tl::toU(pSecImpl->m_pNetResource->lpRemoteName));
 391         bSuccess = osl_File_E_None == osl_getFileURLFromSystemPath( ustrSysDir, pustrDirectory);
 392
 393         if ( ustrSysDir )
 394             rtl_uString_release( ustrSysDir );
 395     }
 396     else
 397     {
 398         if (pSecImpl->m_hToken)
 399         {
 400             /* not implemented */
 401             OSL_ASSERT(false);
 402         }
 403         else
 404         {
 405             rtl_uString *ustrFile = nullptr;
 406             sal_Unicode sFile[_MAX_PATH];
 407
 408             if ( !GetSpecialFolder( &ustrFile, FOLDERID_RoamingAppData) )
 409             {
 410                 OSL_VERIFY(GetWindowsDirectoryW(o3tl::toW(sFile), _MAX_DIR) > 0);
 411
 412                 rtl_uString_newFromStr( &ustrFile, sFile);
 413             }
 414
 415             bSuccess = osl_File_E_None == osl_getFileURLFromSystemPath(ustrFile, pustrDirectory);
 416
 417             if ( ustrFile )
 418                 rtl_uString_release( ustrFile );
 419         }
 420     }
 421
 422     return bSuccess;
 423 }
 424
 425 sal_Bool SAL_CALL osl_loadUserProfile(oslSecurity Security)
 426 {
 427     /*  CreateProcessAsUser does not load the specified user's profile
 428         into the HKEY_USERS registry key. This means that access to information
 429         in the HKEY_CURRENT_USER registry key may not produce results consistent
 430         with a normal interactive logon.
 431         It is your responsibility to load the user's registry hive into HKEY_USERS
 432         with the LoadUserProfile function before calling CreateProcessAsUser.
 433     */
 434
 435     RegCloseKey(HKEY_CURRENT_USER);
 436
 437     if (!Privilege(SE_RESTORE_NAME, true))
 438         return false;
 439
 440     bool bOk = false;
 441     HANDLE hAccessToken = static_cast<oslSecurityImpl*>(Security)->m_hToken;
 442
 443     /* try to create user profile */
 444     if ( !hAccessToken )
 445     {
 446         /* retrieve security handle if not done before e.g. osl_getCurrentSecurity()
 447         */
 448         HANDLE hProcess = GetCurrentProcess();
 449
 450         if (hProcess != nullptr)
 451         {
 452             OpenProcessToken(hProcess, TOKEN_IMPERSONATE, &hAccessToken);
 453             CloseHandle(hProcess);
 454         }
 455     }
 456
 457     rtl_uString *buffer = nullptr;
 458     PROFILEINFOW pi;
 459
 460     getUserNameImpl(Security, &buffer, false);
 461
 462     ZeroMemory(&pi, sizeof(pi));
 463     pi.dwSize = sizeof(pi);
 464     pi.lpUserName = o3tl::toW(rtl_uString_getStr(buffer));
 465     pi.dwFlags = PI_NOUI;
 466
 467     if (LoadUserProfileW(hAccessToken, &pi))
 468     {
 469         UnloadUserProfile(hAccessToken, pi.hProfile);
 470
 471         bOk = true;
 472     }
 473
 474     rtl_uString_release(buffer);
 475
 476     if (hAccessToken && (hAccessToken != static_cast<oslSecurityImpl*>(Security)->m_hToken))
 477         CloseHandle(hAccessToken);
 478
 479     return bOk;
 480 }
 481
 482 void SAL_CALL osl_unloadUserProfile(oslSecurity Security)
 483 {
 484     if ( static_cast<oslSecurityImpl*>(Security)->m_hProfile == nullptr )
 485         return;
 486
 487     HANDLE hAccessToken = static_cast<oslSecurityImpl*>(Security)->m_hToken;
 488
 489     if ( !hAccessToken )
 490     {
 491         /* retrieve security handle if not done before e.g. osl_getCurrentSecurity()
 492         */
 493         HANDLE hProcess = GetCurrentProcess();
 494
 495         if (hProcess != nullptr)
 496         {
 497             OpenProcessToken(hProcess, TOKEN_IMPERSONATE, &hAccessToken);
 498             CloseHandle(hProcess);
 499         }
 500     }
 501
 502     /* unloading the user profile */
 503     UnloadUserProfile(hAccessToken, static_cast<oslSecurityImpl*>(Security)->m_hProfile);
 504
 505     static_cast<oslSecurityImpl*>(Security)->m_hProfile = nullptr;
 506
 507     if (hAccessToken && (hAccessToken != static_cast<oslSecurityImpl*>(Security)->m_hToken))
 508         CloseHandle(hAccessToken);
 509 }
 510
 511 static bool GetSpecialFolder(rtl_uString **strPath, REFKNOWNFOLDERID rFolder)
 512 {
 513     sal::systools::CoTaskMemAllocated<wchar_t> PathW;
 514     if (SUCCEEDED(SHGetKnownFolderPath(rFolder, KF_FLAG_CREATE, nullptr, &PathW)))
 515     {
 516         rtl_uString_newFromStr(strPath, o3tl::toU(PathW));
 517         return true;
 518     }
 519
 520     return false;
 521 }
 522
 523 // We use LPCTSTR here, because we use it with SE_foo_NAME constants
 524 // which are defined in winnt.h as UNICODE-dependent TEXT("PrivilegeName")
 525 static bool Privilege(LPCTSTR strPrivilege, bool bEnable)
 526 {
 527     HANDLE           hToken;
 528     TOKEN_PRIVILEGES tp;
 529
 530     // obtain the processes token
 531     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_DUP_QUERY, &hToken))
 532         return false;
 533
 534     // get the luid
 535     if (!LookupPrivilegeValue(nullptr, strPrivilege, &tp.Privileges[0].Luid))
 536         return false;
 537
 538     tp.PrivilegeCount = 1;
 539
 540     if (bEnable)
 541         tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 542     else
 543         tp.Privileges[0].Attributes = 0;
 544
 545     // enable or disable the privilege
 546     if (!AdjustTokenPrivileges(hToken, FALSE, &tp, 0, nullptr, nullptr))
 547         return false;
 548
 549     if (!CloseHandle(hToken))
 550         return false;
 551
 552     return true;
 553 }
 554
 555 static bool getUserNameImpl(oslSecurity Security, rtl_uString **strName,  bool bIncludeDomain)
 556 {
 557     if (!Security)
 558         return false;
 559
 560     oslSecurityImpl *pSecImpl = static_cast<oslSecurityImpl*>(Security);
 561
 562     HANDLE hAccessToken = pSecImpl->m_hToken;
 563
 564     if (hAccessToken == nullptr)
 565         OpenProcessToken(GetCurrentProcess(), TOKEN_DUP_QUERY, &hAccessToken);
 566
 567     if (hAccessToken)
 568     {
 569         DWORD  nInfoBuffer = 512;
 570         UCHAR* pInfoBuffer = static_cast<UCHAR *>(malloc(nInfoBuffer));
 571
 572         while (!GetTokenInformation(hAccessToken, TokenUser,
 573                                        pInfoBuffer, nInfoBuffer, &nInfoBuffer))
 574         {
 575             if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 576             {
 577                 if (auto p = static_cast<UCHAR *>(realloc(pInfoBuffer, nInfoBuffer)))
 578                     pInfoBuffer = p;
 579                 else
 580                 {
 581                     free(pInfoBuffer);
 582                     pInfoBuffer = nullptr;
 583                     break;
 584                 }
 585             }
 586             else
 587             {
 588                 free(pInfoBuffer);
 589                 pInfoBuffer = nullptr;
 590                 break;
 591             }
 592         }
 593
 594         if (pSecImpl->m_hToken == nullptr)
 595             CloseHandle(hAccessToken);
 596
 597         if (pInfoBuffer)
 598         {
 599             sal_Unicode  UserName[128];
 600             sal_Unicode  DomainName[128];
 601             sal_Unicode  Name[257];
 602             DWORD nUserName   = SAL_N_ELEMENTS(UserName);
 603             DWORD nDomainName = SAL_N_ELEMENTS(DomainName);
 604             SID_NAME_USE sUse;
 605
 606             if (LookupAccountSidW(nullptr, reinterpret_cast<PTOKEN_USER>(pInfoBuffer)->User.Sid,
 607                                     o3tl::toW(UserName), &nUserName,
 608                                     o3tl::toW(DomainName), &nDomainName, &sUse))
 609             {
 610                 if (bIncludeDomain)
 611                 {
 612                     wcscpy(o3tl::toW(Name), o3tl::toW(DomainName));
 613                     wcscat(o3tl::toW(Name), L"/");
 614                     wcscat(o3tl::toW(Name), o3tl::toW(UserName));
 615                 }
 616                 else
 617                 {
 618                     wcscpy(o3tl::toW(Name), o3tl::toW(UserName));
 619                 }
 620
 621                 rtl_uString_newFromStr(strName, Name);
 622                 free(pInfoBuffer);
 623                 return true;
 624             }
 625         }
 626     }
 627     else
 628     {
 629         DWORD needed=0;
 630         sal_Unicode *pNameW=nullptr;
 631
 632         WNetGetUserW(nullptr, nullptr, &needed);
 633         pNameW = static_cast<sal_Unicode *>(malloc (needed*sizeof(sal_Unicode)));
 634         assert(pNameW); // Don't handle OOM conditions
 635
 636         if (WNetGetUserW(nullptr, o3tl::toW(pNameW), &needed) == NO_ERROR)
 637         {
 638             rtl_uString_newFromStr( strName, pNameW);
 639
 640             if (pNameW)
 641                 free(pNameW);
 642             return true;
 643         }
 644         else if (pSecImpl->m_User[0] != '\0')
 645         {
 646             rtl_uString_newFromStr(strName, o3tl::toU(pSecImpl->m_pNetResource->lpRemoteName));
 647
 648             if (pNameW)
 649                 free(pNameW);
 650
 651             return true;
 652         }
 653
 654         if (pNameW)
 655             free(pNameW);
 656     }
 657
 658     return false;
 659 }
 660
 661 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */