DWORD
WkssSrvConfigGetLsaLpcSocketPath(
PSTR *ppszLsaLpcSocketPath
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszLpcSocketPath = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gWkssSrvConfig.pszLsaLpcSocketPath)) {
goto cleanup;
}
dwError = LwAllocateString(gWkssSrvConfig.pszLsaLpcSocketPath,
&pszLpcSocketPath);
BAIL_ON_LSA_ERROR(dwError);
*ppszLsaLpcSocketPath = pszLpcSocketPath;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
static
NSS_STATUS
LsaNssPushNetgroup(
PLSA_NSS_NETGROUP_LIST* ppList,
PCSTR pszGroup
)
{
NSS_STATUS status = NSS_STATUS_SUCCESS;
PLSA_NSS_NETGROUP_LIST pLink = NULL;
status = MAP_LSA_ERROR(NULL,
LwAllocateMemory(
sizeof(*pLink),
(void**) &pLink));
BAIL_ON_NSS_ERROR(status);
status = MAP_LSA_ERROR(NULL,
LwAllocateString(
pszGroup,
&pLink->pszGroup));
BAIL_ON_NSS_ERROR(status);
pLink->pNext = *ppList;
*ppList = pLink;
error:
return status;
}
DWORD
AD_GetUnprovisionedModeRemoteHomeDirTemplate(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszUnprovisionedModeHomeDirTemplate
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszUnprovisionedModeHomeDirTemplate = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszRemoteHomeDirTemplate))
{
dwError = LwAllocateString(
pState->config.pszRemoteHomeDirTemplate,
&pszUnprovisionedModeHomeDirTemplate
);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszUnprovisionedModeHomeDirTemplate = pszUnprovisionedModeHomeDirTemplate;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszUnprovisionedModeHomeDirTemplate = NULL;
goto cleanup;
}
DWORD
AD_GetHomedirPrefixPath(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszPath
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszHomedirPrefixPath = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszHomedirPrefix))
{
dwError = LwAllocateString(
pState->config.pszHomedirPrefix,
&pszHomedirPrefixPath
);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszPath = pszHomedirPrefixPath;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszPath = NULL;
goto cleanup;
}
DWORD
LsaGetCurrentDirectoryPath(
PSTR* ppszPath
)
{
DWORD dwError = 0;
CHAR szBuf[PATH_MAX+1];
PSTR pszPath = NULL;
if (getcwd(szBuf, PATH_MAX) == NULL) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateString(szBuf, &pszPath);
BAIL_ON_LSA_ERROR(dwError);
*ppszPath = pszPath;
return dwError;
error:
if (pszPath) {
LwFreeString(pszPath);
}
return dwError;
}
static
DWORD
LocalCfgSetSkeletonDirs(
PLOCAL_CONFIG pConfig,
PCSTR pszName,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszSkelDirs = NULL;
if (!LW_IS_NULL_OR_EMPTY_STR(pszValue))
{
dwError = LwAllocateString(
pszValue,
&pszSkelDirs);
BAIL_ON_UP_ERROR(dwError);
}
LW_SAFE_FREE_STRING(pConfig->pszSkelDirs);
pConfig->pszSkelDirs = pszSkelDirs;
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszSkelDirs);
goto cleanup;
}
DWORD
LsaSrvGetPrefixPath(
PSTR* ppszPath
)
{
DWORD dwError = 0;
PSTR pszPath = NULL;
BOOLEAN bInLock = FALSE;
LSA_LOCK_SERVERINFO(bInLock);
if (LW_IS_NULL_OR_EMPTY_STR(gpServerInfo->szPrefixPath)) {
dwError = LW_ERROR_INVALID_PREFIX_PATH;
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateString(gpServerInfo->szPrefixPath, &pszPath);
BAIL_ON_LSA_ERROR(dwError);
*ppszPath = pszPath;
cleanup:
LSA_UNLOCK_SERVERINFO(bInLock);
return dwError;
error:
LW_SAFE_FREE_STRING(pszPath);
*ppszPath = NULL;
goto cleanup;
}
DWORD
SamrSrvConfigGetDefaultLoginShell(
PSTR *ppszDefaultLoginShell
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszDefaultLoginShell = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gSamrSrvConfig.pszDefaultLoginShell)) {
goto cleanup;
}
dwError = LwAllocateString(gSamrSrvConfig.pszDefaultLoginShell,
&pszDefaultLoginShell);
BAIL_ON_LSA_ERROR(dwError);
*ppszDefaultLoginShell = pszDefaultLoginShell;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
DWORD
NtlmServerSetCredDomainNameAttribute(
IN NTLM_CRED_HANDLE hCred,
IN PSecPkgCred_DomainName pDomainName
)
{
DWORD dwError = LW_ERROR_SUCCESS;
PNTLM_CREDENTIALS pNtlmCreds = (PNTLM_CREDENTIALS)hCred;
if (!hCred || !pDomainName || !pDomainName->pName)
{
dwError = LW_ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(dwError);
}
LW_SAFE_FREE_STRING(pNtlmCreds->pszDomainName);
dwError = LwAllocateString(
pDomainName->pName,
&pNtlmCreds->pszDomainName);
BAIL_ON_LSA_ERROR(dwError);
error:
return dwError;
}
static
DWORD
LsaPam_SetConfig_UserNotAllowedError(
PLSA_PAM_CONFIG pConfig,
PCSTR pszName,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszMessage = NULL;
if (!LW_IS_NULL_OR_EMPTY_STR(pszValue))
{
dwError = LwAllocateString(
pszValue,
&pszMessage);
BAIL_ON_UP_ERROR(dwError);
LW_SAFE_FREE_STRING(pConfig->pszAccessDeniedMessage);
pConfig->pszAccessDeniedMessage = pszMessage;
}
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszMessage);
goto cleanup;
}
DWORD
ADUKrb5GetSystemCachePath(
PSTR* ppszCachePath
)
{
DWORD dwError = 0;
PSTR pszCachePath = NULL;
BOOLEAN bDirExists = FALSE;
dwError = LwCheckFileTypeExists(LWDS_ADMIN_CACHE_DIR, LWFILE_DIRECTORY, &bDirExists);
BAIL_ON_MAC_ERROR(dwError);
if (!bDirExists)
{
dwError = LwCreateDirectory(LWDS_ADMIN_CACHE_DIR, S_IRUSR|S_IRGRP|S_IROTH);
BAIL_ON_MAC_ERROR(dwError);
}
dwError = LwAllocateString(
"FILE:" MACADUTIL_KRB5_CACHEPATH,
&pszCachePath);
BAIL_ON_MAC_ERROR(dwError);
*ppszCachePath = pszCachePath;
cleanup:
return dwError;
error:
*ppszCachePath = NULL;
goto cleanup;
}
DWORD
LocalCfgGetSkeletonDirs(
PSTR* ppszSkelDirs
)
{
DWORD dwError = 0;
PSTR pszSkelDirs = NULL;
BOOLEAN bInLock = FALSE;
LOCAL_LOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
dwError = LwAllocateString(
gLPGlobals.cfg.pszSkelDirs,
&pszSkelDirs);
BAIL_ON_LSA_ERROR(dwError);
*ppszSkelDirs = pszSkelDirs;
cleanup:
LOCAL_UNLOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
return dwError;
error:
*ppszSkelDirs = NULL;
LW_SAFE_FREE_STRING(pszSkelDirs);
goto cleanup;
}
DWORD
LocalCfgGetHomedirTemplate(
PSTR* ppszHomedirTemplate
)
{
DWORD dwError = 0;
PSTR pszHomedirTemplate = NULL;
BOOLEAN bInLock = FALSE;
LOCAL_LOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
dwError = LwAllocateString(
gLPGlobals.cfg.pszHomedirTemplate,
&pszHomedirTemplate);
BAIL_ON_LSA_ERROR(dwError);
*ppszHomedirTemplate = pszHomedirTemplate;
cleanup:
LOCAL_UNLOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
return dwError;
error:
*ppszHomedirTemplate = NULL;
LW_SAFE_FREE_STRING(pszHomedirTemplate);
goto cleanup;
}
DWORD
LwLdapGetString(
HANDLE hDirectory,
LDAPMessage* pMessage,
PCSTR pszFieldName,
PSTR* ppszValue
)
{
DWORD dwError = LW_ERROR_SUCCESS;
PLW_LDAP_DIRECTORY_CONTEXT pDirectory = NULL;
PSTR *ppszValues = NULL;
PSTR pszValue = NULL;
pDirectory = (PLW_LDAP_DIRECTORY_CONTEXT)hDirectory;
ppszValues = (PSTR*)ldap_get_values(pDirectory->ld, pMessage, pszFieldName);
if (ppszValues && ppszValues[0]) {
dwError = LwAllocateString(ppszValues[0], &pszValue);
BAIL_ON_LW_ERROR(dwError);
}
*ppszValue = pszValue;
cleanup:
if (ppszValues) {
ldap_value_free(ppszValues);
}
return dwError;
error:
*ppszValue = NULL;
LW_SAFE_FREE_STRING(pszValue);
goto cleanup;
}
DWORD
SamrSrvConfigGetHomedirTemplate(
PSTR *ppszHomedirTemplate
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszHomedirTemplate = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gSamrSrvConfig.pszHomedirTemplate)) {
goto cleanup;
}
dwError = LwAllocateString(gSamrSrvConfig.pszHomedirTemplate,
&pszHomedirTemplate);
BAIL_ON_LSA_ERROR(dwError);
*ppszHomedirTemplate = pszHomedirTemplate;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
DWORD
LocalCfgGetDefaultShell(
PSTR* ppszLoginShell
)
{
DWORD dwError = 0;
PSTR pszLoginShell = NULL;
BOOLEAN bInLock = FALSE;
LOCAL_LOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
dwError = LwAllocateString(
gLPGlobals.cfg.pszLoginShell,
&pszLoginShell);
BAIL_ON_LSA_ERROR(dwError);
*ppszLoginShell = pszLoginShell;
cleanup:
LOCAL_UNLOCK_MUTEX(bInLock, &gLPGlobals.cfgMutex);
return dwError;
error:
*ppszLoginShell = NULL;
LW_SAFE_FREE_STRING(pszLoginShell);
goto cleanup;
}
DWORD
LADSGetGUID(
PSTR* ppszGUID
)
{
DWORD dwError = 0;
PSTR pszGUID = NULL;
uuid_t uuid = {0};
CHAR szUUID[37] = "";
uuid_generate(uuid);
uuid_unparse(uuid, szUUID);
dwError = LwAllocateString(
szUUID,
&pszGUID);
BAIL_ON_LSA_ERROR(dwError);
*ppszGUID = pszGUID;
cleanup:
return dwError;
error:
*ppszGUID = NULL;
LW_SAFE_FREE_STRING(pszGUID);
goto cleanup;
}
DWORD
AD_GetUserDomainPrefix(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszPath
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszValue = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszUserDomainPrefix))
{
dwError = LwAllocateString(
pState->config.pszUserDomainPrefix,
&pszValue
);
BAIL_ON_LSA_ERROR(dwError);
}
else if (pState->pProviderData &&
!LW_IS_NULL_OR_EMPTY_STR(pState->pProviderData->szShortDomain))
{
dwError = LwAllocateString(
pState->pProviderData->szShortDomain,
&pszValue
);
BAIL_ON_LSA_ERROR(dwError);
}
LwStrToUpper(pszValue);
*ppszPath = pszValue;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszPath = NULL;
goto cleanup;
}
static
DWORD
CTGetPListVersion(
PSTR* ppVersion
)
{
return LwAllocateString("Unknown", ppVersion);
}
DWORD
ADUKrb5GetPrincipalName(
PCSTR pszCachePath,
PSTR* ppszPrincipalName
)
{
DWORD dwError = 0;
krb5_error_code ret = 0;
krb5_context ctx = NULL;
krb5_ccache cc = NULL;
krb5_principal pKrb5Principal = NULL;
PSTR pszKrb5PrincipalName = NULL;
PSTR pszPrincipalName = NULL;
ret = krb5_init_context(&ctx);
BAIL_ON_KRB_ERROR(ctx, ret);
ret = krb5_cc_resolve(ctx, pszCachePath, &cc);
BAIL_ON_KRB_ERROR(ctx, ret);
ret = krb5_cc_get_principal(ctx, cc, &pKrb5Principal);
BAIL_ON_KRB_ERROR(ctx, ret);
ret = krb5_unparse_name(ctx, pKrb5Principal, &pszKrb5PrincipalName);
BAIL_ON_KRB_ERROR(ctx, ret);
dwError = LwAllocateString(pszKrb5PrincipalName, &pszPrincipalName);
BAIL_ON_MAC_ERROR(dwError);
*ppszPrincipalName = pszPrincipalName;
cleanup:
if (ctx)
{
if (pszKrb5PrincipalName)
{
krb5_free_unparsed_name(ctx, pszKrb5PrincipalName);
}
if (pKrb5Principal)
{
krb5_free_principal(ctx, pKrb5Principal);
}
if (cc)
{
krb5_cc_close(ctx, cc);
}
krb5_free_context(ctx);
}
return dwError;
error:
*ppszPrincipalName = NULL;
goto cleanup;
}
static
DWORD
LsaAdBatchMarshalUserInfoFixLocalWindowsHomeFolder(
IN PLSA_AD_PROVIDER_STATE pState,
IN OUT PSTR* ppszLocalWindowsHomeFolder,
IN PCSTR pszNetbiosDomainName,
IN PCSTR pszSamAccountName
)
{
DWORD dwError = 0;
PSTR pszLocalWindowsHomeFolder = *ppszLocalWindowsHomeFolder;
PSTR pszNewLocalWindowsHomeFolder = NULL;
if (LW_IS_NULL_OR_EMPTY_STR(pszLocalWindowsHomeFolder))
{
dwError = AD_GetUnprovisionedModeRemoteHomeDirTemplate(
pState,
&pszLocalWindowsHomeFolder);
BAIL_ON_LSA_ERROR(dwError);
}
if (pszLocalWindowsHomeFolder == NULL)
{
dwError = LwAllocateString("", &pszLocalWindowsHomeFolder);
BAIL_ON_LSA_ERROR(dwError);
}
else if (strstr(pszLocalWindowsHomeFolder, "%"))
{
dwError = AD_BuildHomeDirFromTemplate(
pState,
pszLocalWindowsHomeFolder,
pszNetbiosDomainName,
pszSamAccountName,
&pszNewLocalWindowsHomeFolder);
if (dwError)
{
// If we encounter a problem with fixing up the shell, leave the user object with the actual
// value stored in AD and log the problem.
LSA_LOG_INFO("While processing information for user (%s), an invalid remote homedir value was detected (homedir: '%s')",
LSA_SAFE_LOG_STRING(pszSamAccountName),
LSA_SAFE_LOG_STRING(pszLocalWindowsHomeFolder));
dwError = 0;
goto cleanup;
}
LW_SAFE_FREE_STRING(pszLocalWindowsHomeFolder);
LSA_XFER_STRING(pszNewLocalWindowsHomeFolder, pszLocalWindowsHomeFolder);
}
LwStrCharReplace(pszLocalWindowsHomeFolder, ' ', '_');
cleanup:
*ppszLocalWindowsHomeFolder = pszLocalWindowsHomeFolder;
return dwError;
error:
goto cleanup;
}
long
GetDnsHostName(
char ** hostname
)
{
long macError = eDSNoErr;
char buffer[256];
char * szLocal = NULL;
char * szDot = NULL;
uint len = 0;
PSTR pszHostName = NULL;
if ( gethostname(buffer, sizeof(buffer)) != 0 )
{
macError = ePlugInInitError;
if (macError)
{
goto cleanup;
}
}
len = strlen(buffer);
if ( len > strlen(".local") )
{
szLocal = &buffer[len - strlen(".local")];
if ( !strcasecmp( szLocal, ".local" ) )
{
szLocal[0] = '\0';
}
}
/* Test to see if the name is still dotted. If so we will chop it down to
just the hostname field. */
szDot = strchr(buffer, '.');
if ( szDot )
{
szDot[0] = '\0';
}
macError = LwAllocateString(buffer, &pszHostName);
if (macError)
{
goto cleanup;
}
if ( hostname ) {
*hostname = pszHostName;
pszHostName = NULL;
}
// return below so that we free the unrequested out parameters.
cleanup:
LW_SAFE_FREE_STRING(pszHostName);
return macError;
}
static
DWORD
AD_ConvertMultiStringToStringArray(
IN PCSTR pszMultiString,
OUT PSTR** pppszStringArray,
OUT PDWORD pdwCount
)
{
DWORD dwError = 0;
PSTR* ppszStringArray = NULL;
DWORD dwCount = 0;
PCSTR pszIter = NULL;
DWORD dwIndex = 0;
dwCount = 0;
for (pszIter = pszMultiString;
pszIter && *pszIter;
pszIter += strlen(pszIter) + 1)
{
dwCount++;
}
if (dwCount)
{
dwError = LwAllocateMemory(
dwCount * sizeof(*ppszStringArray),
OUT_PPVOID(&ppszStringArray));
BAIL_ON_LSA_ERROR(dwError);
}
dwIndex = 0;
for (pszIter = pszMultiString;
pszIter && *pszIter;
pszIter += strlen(pszIter) + 1)
{
dwError = LwAllocateString(pszIter, &ppszStringArray[dwIndex]);
BAIL_ON_LSA_ERROR(dwError);
dwIndex++;
}
LSA_ASSERT(dwIndex == dwCount);
cleanup:
*pppszStringArray = ppszStringArray;
*pdwCount = dwCount;
return dwError;
error:
LwFreeStringArray(ppszStringArray, dwCount);
ppszStringArray = NULL;
dwCount = 0;
goto cleanup;
}
DWORD
UpLocalCfgInitialize(
PLOCAL_CONFIG pConfig
)
{
DWORD dwError = 0;
PCSTR pszDefaultLoginShell = LOCAL_CFG_DEFAULT_LOGIN_SHELL;
PCSTR pszDefaultHomedirPrefix = LOCAL_CFG_DEFAULT_HOMEDIR_PREFIX;
PCSTR pszDefaultHomedirTemplate = LOCAL_CFG_DEFAULT_HOMEDIR_TEMPLATE;
PCSTR pszDefaultSkelDirs = LOCAL_CFG_DEFAULT_SKELETON_DIRS;
memset(pConfig, 0, sizeof(LOCAL_CONFIG));
pConfig->bEnableEventLog = FALSE;
pConfig->dwMaxGroupNestingLevel = LOCAL_CFG_MAX_GROUP_NESTING_LEVEL_DEFAULT;
dwError = LwAllocateString(
pszDefaultLoginShell,
&pConfig->pszLoginShell);
BAIL_ON_UP_ERROR(dwError);
dwError = LwAllocateString(
pszDefaultHomedirPrefix,
&pConfig->pszHomedirPrefix);
BAIL_ON_UP_ERROR(dwError);
dwError = LwAllocateString(
pszDefaultHomedirTemplate,
&pConfig->pszHomedirTemplate);
BAIL_ON_UP_ERROR(dwError);
pConfig->bCreateHomedir = LOCAL_CFG_DEFAULT_CREATE_HOMEDIR;
dwError = LwAllocateString(LOCAL_CFG_DEFAULT_HOMEDIR_UMASK, &pConfig->pszUmask);
BAIL_ON_UP_ERROR(dwError);
dwError = LwAllocateString(
pszDefaultSkelDirs,
&pConfig->pszSkelDirs);
BAIL_ON_UP_ERROR(dwError);
error:
return dwError;
}
static
DWORD
LsaAllocateGroupInfo_0(
PLSA_GROUP_INFO_0 *ppDstGroupInfo,
DWORD dwLevel,
PLSA_GROUP_INFO_0 pSrcGroupInfo
)
{
DWORD dwError = 0;
PLSA_GROUP_INFO_0 pGroupInfo = NULL;
dwError = LwAllocateMemory(sizeof(*pGroupInfo),
(PVOID*)&pGroupInfo);
BAIL_ON_LSA_ERROR(dwError);
if (pSrcGroupInfo) {
pGroupInfo->gid = pSrcGroupInfo->gid;
if (pSrcGroupInfo->pszName) {
dwError = LwAllocateString(pSrcGroupInfo->pszName,
&pGroupInfo->pszName);
BAIL_ON_LSA_ERROR(dwError);
}
if (pSrcGroupInfo->pszSid) {
dwError = LwAllocateString(pSrcGroupInfo->pszSid,
&pGroupInfo->pszSid);
BAIL_ON_LSA_ERROR(dwError);
}
}
*ppDstGroupInfo = pGroupInfo;
cleanup:
return dwError;
error:
if (pGroupInfo) {
LsaFreeGroupInfo(dwLevel, pGroupInfo);
}
*ppDstGroupInfo = NULL;
goto cleanup;
}
PVOID
LsaNssOpen(
PCSTR pszName,
PCSTR pszDomain,
int mode,
PSTR pszOptions
)
{
DWORD dwError = LW_ERROR_SUCCESS;
PLSA_PAM_CONFIG pConfig = NULL;
dwError = LsaPamGetConfig(&pConfig);
BAIL_ON_LSA_ERROR(dwError);
LsaPamSetLogLevel(pConfig->dwLogLevel);
LSA_LOG_PAM_DEBUG(
"Open called for '%s' with options '%s'",
pszName,
pszOptions);
LsaNssClearState(&gNssState);
dwError = LwAllocateString(
pszName,
&gNssState.pszRegistryName);
BAIL_ON_LSA_ERROR(dwError);
if (!strcasecmp(pszOptions, "debug"))
{
LsaPamSetLogLevel(LSA_PAM_LOG_LEVEL_DEBUG);
}
cleanup:
LSA_LOG_PAM_DEBUG("Open finishing with code %u", dwError);
if (pConfig)
{
LsaPamFreeConfig(pConfig);
}
if (dwError != LW_ERROR_SUCCESS)
{
LsaNssMapErrorCode(dwError, &errno);
return NULL;
}
else
{
return &gNssState;
}
error:
goto cleanup;
}
DWORD
ProcessSystemAccessRight(
const DWORD Argc,
PCSTR* Argv
)
{
DWORD err = ERROR_SUCCESS;
DWORD i = 0;
PCSTR pszArg = NULL;
RPC_PARAMETERS Params = {0};
PRIVILEGE_COMMAND Command = PrivilegeDoNothing;
PSTR pszAccountName = NULL;
err = ProcessRpcParameters(Argc, Argv, &Params);
BAIL_ON_LSA_ERROR(err);
for (i = 0; i < Argc; i++)
{
pszArg = Argv[i];
if (((strcmp(pszArg, "-g") == 0) ||
(strcmp(pszArg, "--get") == 0)) &&
(i + 1 < Argc))
{
pszArg = Argv[++i];
err = LwAllocateString(pszArg, &pszAccountName);
BAIL_ON_LSA_ERROR(err);
Command = SystemAccessRightGetAccount;
}
}
switch (Command)
{
case SystemAccessRightGetAccount:
err = ProcessGetAccountSystemAccessRights(
&Params,
pszAccountName);
BAIL_ON_LSA_ERROR(err);
break;
default:
ShowUsageSystemAccessRights(Argv[0]);
break;
}
error:
LW_SAFE_FREE_MEMORY(pszAccountName);
return err;
}
DWORD
SamrSrvInitialiseConfig(
PSAMR_SRV_CONFIG pConfig
)
{
DWORD dwError = 0;
memset(pConfig, 0, sizeof(*pConfig));
dwError = LwAllocateString(
SAMR_RPC_CFG_DEFAULT_LPC_SOCKET_PATH,
&pConfig->pszLpcSocketPath);
BAIL_ON_LSA_ERROR(dwError);
dwError = LwAllocateString(
SAMR_RPC_CFG_DEFAULT_LOGIN_SHELL,
&pConfig->pszDefaultLoginShell);
BAIL_ON_LSA_ERROR(dwError);
dwError = LwAllocateString(
SAMR_RPC_CFG_DEFAULT_HOMEDIR_PREFIX,
&pConfig->pszHomedirPrefix);
BAIL_ON_LSA_ERROR(dwError);
dwError = LwAllocateString(
SAMR_RPC_CFG_DEFAULT_HOMEDIR_TEMPLATE,
&pConfig->pszHomedirTemplate);
BAIL_ON_LSA_ERROR(dwError);
pConfig->bRegisterTcpIp = FALSE;
cleanup:
return dwError;
error:
SamrSrvFreeConfigContents(pConfig);
goto cleanup;
}
DWORD
LwDuplicateStringArray(
PSTR** pppNewStringArray,
PDWORD pdwNewCount,
PSTR* ppStringArray,
DWORD dwCount
)
{
DWORD dwError = 0;
PSTR* ppNewStringArray = NULL;
DWORD dwNewCount = 0;
if (dwCount)
{
DWORD i = 0;
dwError = LwAllocateMemory(
dwCount * sizeof(*ppNewStringArray),
OUT_PPVOID(&ppNewStringArray));
BAIL_ON_LW_ERROR(dwError);
dwNewCount = dwCount;
for (i = 0; i < dwCount; i++)
{
dwError = LwAllocateString(
ppStringArray[i],
&ppNewStringArray[i]);
BAIL_ON_LW_ERROR(dwError);
}
}
cleanup:
*pppNewStringArray = ppNewStringArray;
if (pdwNewCount)
{
*pdwNewCount = dwNewCount;
}
return dwError;
error:
LwFreeStringArray(ppNewStringArray, dwNewCount);
ppNewStringArray = NULL;
dwNewCount = 0;
goto cleanup;
}
static
DWORD
LsaSrvAllocateProvider(
PCSTR pszId,
PCSTR pszPath,
PLSA_AUTH_PROVIDER *ppProvider
)
{
DWORD dwError = 0;
PLSA_AUTH_PROVIDER pProvider = NULL;
dwError = LwAllocateMemory(
sizeof(LSA_AUTH_PROVIDER),
(PVOID*)&pProvider);
BAIL_ON_LSA_ERROR(dwError);
dwError = LwAllocateString(pszPath, &(pProvider->pszProviderLibpath));
BAIL_ON_LSA_ERROR(dwError);
dwError = LwAllocateString(pszId, &(pProvider->pszId));
BAIL_ON_LSA_ERROR(dwError);
cleanup:
*ppProvider = pProvider;
return dwError;
error:
if (pProvider)
{
LsaSrvFreeAuthProvider(pProvider);
pProvider = NULL;
}
goto cleanup;
}
