DWORD
FlushDirectoryServiceCache(
)
{
DWORD dwError = MAC_AD_ERROR_SUCCESS;
BOOLEAN exists = FALSE;
dwError = LwCheckFileTypeExists("/usr/sbin/lookupd", LWFILE_REGULAR, &exists);
BAIL_ON_MAC_ERROR(dwError);
if (!exists)
{
system("/usr/sbin/lookupd -flushcache");
}
dwError = LwCheckFileTypeExists("/usr/bin/dscacheutil", LWFILE_REGULAR, &exists);
BAIL_ON_MAC_ERROR(dwError);
if (exists)
{
system("/usr/bin/dscacheutil -flushcache");
}
error:
return dwError;
}
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
LwCreateDirectory(
PCSTR pszPath,
mode_t dwFileMode
)
{
DWORD dwError = 0;
PSTR pszCopy = NULL;
// Do not free
PSTR pszSlashPos = NULL;
// Do not free
PSTR pszCopyEnd = NULL;
BOOLEAN bExists = FALSE;
if (LW_IS_NULL_OR_EMPTY_STR(pszPath))
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_LW_ERROR(dwError);
}
dwError = LwAllocateString(pszPath, &pszCopy);
BAIL_ON_LW_ERROR(dwError);
pszCopyEnd = pszCopy + strlen(pszCopy);
// Find the first path component. This skips the leading slash if one
// exists.
pszSlashPos = strchr(pszCopy + 1, '/');
if (pszSlashPos == NULL)
{
pszSlashPos = pszCopyEnd;
}
while (1)
{
*pszSlashPos = 0;
dwError = LwCheckFileTypeExists(
pszCopy,
LWFILE_DIRECTORY,
&bExists);
BAIL_ON_LW_ERROR(dwError);
if (!bExists)
{
// This path component does not exist. Create this path component
// and all components underneath it.
while (1)
{
*pszSlashPos = 0;
if (mkdir(pszCopy, dwFileMode) < 0) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LW_ERROR(dwError);
}
// Find the next path component, or exit the loop if there are
// no more.
if (pszSlashPos == pszCopyEnd)
{
break;
}
*pszSlashPos = '/';
pszSlashPos = strchr(pszSlashPos + 1, '/');
if (pszSlashPos == NULL)
{
pszSlashPos = pszCopyEnd;
}
}
}
if (pszSlashPos == pszCopyEnd)
{
break;
}
*pszSlashPos = '/';
pszSlashPos = strchr(pszSlashPos + 1, '/');
if (pszSlashPos == NULL)
{
pszSlashPos = pszCopyEnd;
}
}
cleanup:
LW_SAFE_FREE_STRING(pszCopy);
return dwError;
error:
goto cleanup;
}
DWORD
LwFindFilesInPaths(
IN PCSTR pszName,
IN LWFILE_TYPE type,
IN const PCSTR* ppszSearchPaths,
OUT PDWORD pdwFoundCount,
OUT PSTR** pppszFoundPaths
)
{
DWORD dwError = 0;
DWORD dwIndex = 0;
PSTR pszTestPath = NULL;
DWORD dwFoundCount = 0;
PSTR* ppszFoundPaths = NULL;
PSTR* ppszNewFoundPaths = NULL;
BOOLEAN bExists = FALSE;
for (dwIndex = 0; ppszSearchPaths[dwIndex]; dwIndex++)
{
LW_SAFE_FREE_STRING(pszTestPath);
dwError = LwAllocateStringPrintf(
&pszTestPath,
"%s/%s",
ppszSearchPaths[dwIndex],
pszName);
BAIL_ON_LW_ERROR(dwError);
dwError = LwCheckFileTypeExists(
pszTestPath,
type,
&bExists);
BAIL_ON_LW_ERROR(dwError);
if (bExists)
{
dwError = LwReallocMemory(
ppszFoundPaths,
OUT_PPVOID(&ppszNewFoundPaths),
(dwFoundCount + 1) * sizeof(ppszFoundPaths[0]));
BAIL_ON_LW_ERROR(dwError);
ppszFoundPaths = ppszNewFoundPaths;
ppszFoundPaths[dwFoundCount] = pszTestPath;
pszTestPath = NULL;
dwFoundCount++;
}
}
*pdwFoundCount = dwFoundCount;
*pppszFoundPaths = ppszFoundPaths;
cleanup:
return dwError;
error:
*pdwFoundCount = 0;
*pppszFoundPaths = NULL;
if (ppszFoundPaths)
{
LwFreeStringArray(
ppszFoundPaths,
dwFoundCount);
}
goto cleanup;
}
DWORD
CacheUserLoginMessage(
PSTR pszHomeDirPath,
PSTR pszMessage
)
{
DWORD dwError = MAC_AD_ERROR_SUCCESS;
PSTR pszFileDir = NULL;
PSTR pszFilePath = NULL;
BOOLEAN bDirExists = FALSE;
FILE * fp = NULL;
int len = 0;
if (!pszMessage || strlen(pszMessage) == 0)
{
goto error;
}
if (!pszHomeDirPath || strlen(pszHomeDirPath) == 0)
{
goto error;
}
LOG("Saving user login message to [homedir: %s]", pszHomeDirPath);
dwError = LwAllocateStringPrintf(&pszFileDir, "%s/Library/Preferences", pszHomeDirPath);
BAIL_ON_MAC_ERROR(dwError);
dwError = LwAllocateStringPrintf(&pszFilePath, "%s/login-message", pszFileDir);
BAIL_ON_MAC_ERROR(dwError);
dwError = LwCheckFileTypeExists(pszFileDir, LWFILE_DIRECTORY, &bDirExists);
BAIL_ON_MAC_ERROR(dwError);
if (bDirExists == FALSE)
{
dwError = LwCreateDirectory(pszFileDir, S_IRUSR|S_IRGRP|S_IROTH);
BAIL_ON_MAC_ERROR(dwError);
}
fp = fopen(pszFilePath, "w");
if (fp)
{
len = fwrite(pszMessage, sizeof(char), strlen(pszMessage), fp);
if (len < strlen(pszMessage))
{
dwError = ENOMEM;
BAIL_ON_MAC_ERROR(dwError);
}
}
error:
LW_SAFE_FREE_STRING(pszFilePath);
LW_SAFE_FREE_STRING(pszFileDir);
if (fp)
{
fclose(fp);
}
return dwError;
}
DWORD
CacheUserAttributes(
uid_t uid,
PGPUSER_AD_ATTRS pUserADAttrs
)
{
DWORD dwError = MAC_AD_ERROR_SUCCESS;
PSTR pszFileDir = NULL;
PSTR pszFilePath = NULL;
PCFGSECTION pUserSettingsList = NULL;
PCFGSECTION pADSection_Name = NULL;
PCFGSECTION pADSection_EMail = NULL;
PCFGSECTION pADSection_Phone = NULL;
PCFGSECTION pADSection_Address = NULL;
PCFGSECTION pADSection_Work = NULL;
PCFGSECTION pADSection_Network = NULL;
BOOLEAN bDirExists = FALSE;
LOG("Saving user attributes to user logon cache [uid: %ld, display name: %s]",
(long)uid,
pUserADAttrs->pszDisplayName ? pUserADAttrs->pszDisplayName : "<null>");
dwError = LwAllocateStringPrintf(&pszFileDir, "/var/lib/pbis/lwedsplugin/user-cache/%ld", (long) uid);
BAIL_ON_MAC_ERROR(dwError);
dwError = LwAllocateStringPrintf(&pszFilePath, "/var/lib/pbis/lwedsplugin/user-cache/%ld/ad-user-attrs", (long) uid);
BAIL_ON_MAC_ERROR(dwError);
dwError = LwCheckFileTypeExists(pszFileDir, LWFILE_DIRECTORY, &bDirExists);
BAIL_ON_MAC_ERROR(dwError);
if (bDirExists == FALSE)
{
dwError = LwCreateDirectory(pszFileDir, S_IRUSR|S_IRGRP|S_IROTH);
BAIL_ON_MAC_ERROR(dwError);
}
dwError = LWCreateConfigSection(&pUserSettingsList,
&pADSection_Name,
"User AD Name Attributes");
BAIL_ON_MAC_ERROR(dwError);
dwError = LWCreateConfigSection(&pADSection_EMail,
&pADSection_EMail,
"User AD EMail Attributes");
BAIL_ON_MAC_ERROR(dwError);
dwError = LWCreateConfigSection(&pADSection_Phone,
&pADSection_Phone,
"User AD Phone Attributes");
BAIL_ON_MAC_ERROR(dwError);
dwError = LWCreateConfigSection(&pADSection_Address,
&pADSection_Address,
"User AD Address Attributes");
BAIL_ON_MAC_ERROR(dwError);
dwError = LWCreateConfigSection(&pADSection_Work,
&pADSection_Work,
"User AD Work Attributes");
BAIL_ON_MAC_ERROR(dwError);
dwError = LWCreateConfigSection(&pADSection_Network,
&pADSection_Network,
"User AD Network Settings Attributes");
BAIL_ON_MAC_ERROR(dwError);
pADSection_Name->pNext = pADSection_EMail;
pADSection_EMail->pNext = pADSection_Phone;
pADSection_Phone->pNext = pADSection_Address;
pADSection_Address->pNext = pADSection_Work;
pADSection_Work->pNext = pADSection_Network;
if (pUserADAttrs->pszDisplayName)
{
dwError = LWSetConfigValueBySection(pUserSettingsList,
"displayName",
pUserADAttrs->pszDisplayName);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszFirstName)
{
dwError = LWSetConfigValueBySection(pADSection_Name,
"givenName",
pUserADAttrs->pszFirstName);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszLastName)
{
dwError = LWSetConfigValueBySection(pADSection_Name,
"sn",
pUserADAttrs->pszLastName);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszADDomain)
{
dwError = LWSetConfigValueBySection(pADSection_Name,
"userDomain",
pUserADAttrs->pszADDomain);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszKerberosPrincipal)
{
dwError = LWSetConfigValueBySection(pADSection_Name,
"userPrincipalName",
pUserADAttrs->pszKerberosPrincipal);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszEMailAddress)
{
dwError = LWSetConfigValueBySection(pADSection_EMail,
"mail",
pUserADAttrs->pszEMailAddress);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMSExchHomeServerName)
{
dwError = LWSetConfigValueBySection(pADSection_EMail,
"msExchHomeServerName",
pUserADAttrs->pszMSExchHomeServerName);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMSExchHomeMDB)
{
dwError = LWSetConfigValueBySection(pADSection_EMail,
"homeMDB",
pUserADAttrs->pszMSExchHomeMDB);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszTelephoneNumber)
{
dwError = LWSetConfigValueBySection(pADSection_Phone,
"telephoneNumber",
pUserADAttrs->pszTelephoneNumber);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszFaxTelephoneNumber)
{
dwError = LWSetConfigValueBySection(pADSection_Phone,
"facsimileTelephoneNumber",
pUserADAttrs->pszFaxTelephoneNumber);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMobileTelephoneNumber)
{
dwError = LWSetConfigValueBySection(pADSection_Phone,
"mobile",
pUserADAttrs->pszMobileTelephoneNumber);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszStreetAddress)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"streetAddress",
pUserADAttrs->pszStreetAddress);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszPostOfficeBox)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"postOfficeBox",
pUserADAttrs->pszPostOfficeBox);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszCity)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"l",
pUserADAttrs->pszCity);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszState)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"st",
pUserADAttrs->pszState);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszPostalCode)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"postalCode",
pUserADAttrs->pszPostalCode);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszCountry)
{
dwError = LWSetConfigValueBySection(pADSection_Address,
"co",
pUserADAttrs->pszCountry);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszTitle)
{
dwError = LWSetConfigValueBySection(pADSection_Work,
"title",
pUserADAttrs->pszTitle);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszCompany)
{
dwError = LWSetConfigValueBySection(pADSection_Work,
"company",
pUserADAttrs->pszCompany);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszDepartment)
{
dwError = LWSetConfigValueBySection(pADSection_Work,
"department",
pUserADAttrs->pszDepartment);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszHomeDirectory)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"homeDirectory",
pUserADAttrs->pszHomeDirectory);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszHomeDrive)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"homeDrive",
pUserADAttrs->pszHomeDrive);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszPasswordLastSet)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"pwdLastSet",
pUserADAttrs->pszPasswordLastSet);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszUserAccountControl)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"userAccountControl",
pUserADAttrs->pszUserAccountControl);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMaxMinutesUntilChangePassword)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"maxPwdAge",
pUserADAttrs->pszMaxMinutesUntilChangePassword);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMinMinutesUntilChangePassword)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"minPwdAge",
pUserADAttrs->pszMinMinutesUntilChangePassword);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMaxFailedLoginAttempts)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"lockoutThreshhold",
pUserADAttrs->pszMaxFailedLoginAttempts);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszAllowedPasswordHistory)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"pwdHistoryLength",
pUserADAttrs->pszAllowedPasswordHistory);
BAIL_ON_MAC_ERROR(dwError);
}
if (pUserADAttrs->pszMinCharsAllowedInPassword)
{
dwError = LWSetConfigValueBySection(pADSection_Network,
"minPwdLength",
pUserADAttrs->pszMinCharsAllowedInPassword);
BAIL_ON_MAC_ERROR(dwError);
}
dwError = LWSaveConfigSectionList(pszFilePath, pUserSettingsList);
BAIL_ON_MAC_ERROR(dwError);
error:
LW_SAFE_FREE_STRING(pszFilePath);
LW_SAFE_FREE_STRING(pszFileDir);
LWFreeConfigSectionList(pUserSettingsList);
pUserSettingsList = NULL;
return dwError;
}
DWORD
LWNetSrvStartListenThread(
void
)
{
PSTR pszCachePath = NULL;
PSTR pszCommPath = NULL;
BOOLEAN bDirExists = FALSE;
DWORD dwError = 0;
dwError = LWNetSrvGetCachePath(&pszCachePath);
BAIL_ON_LWNET_ERROR(dwError);
dwError = LwCheckFileTypeExists(
pszCachePath,
LWFILE_DIRECTORY,
&bDirExists);
BAIL_ON_LWNET_ERROR(dwError);
if (!bDirExists)
{
// Directory should be RWX for root and accessible to all
// (so they can see the socket.
mode_t mode = S_IRWXU | S_IRGRP| S_IXGRP | S_IROTH | S_IXOTH;
dwError = LwCreateDirectory(pszCachePath, mode);
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LwAllocateStringPrintf(&pszCommPath, "%s/%s",
pszCachePath, LWNET_SERVER_FILENAME);
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_context_new(NULL, &gpContext));
BAIL_ON_LWNET_ERROR(dwError);
lwmsg_context_set_log_function(gpContext, LWNetSrvLogIpc, NULL);
/* Set up IPC protocol object */
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_new(gpContext, &gpProtocol));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_protocol_add_protocol_spec(
gpProtocol,
LWNetIPCGetProtocolSpec()));
BAIL_ON_LWNET_ERROR(dwError);
/* Set up IPC server object */
dwError = MAP_LWMSG_ERROR(lwmsg_peer_new(gpContext, gpProtocol, &gpServer));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_dispatch_spec(
gpServer,
LWNetSrvGetDispatchSpec()));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_DIRECT,
"netlogon",
0));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_add_listen_endpoint(
gpServer,
LWMSG_ENDPOINT_LOCAL,
pszCommPath,
0666));
BAIL_ON_LWNET_ERROR(dwError);
dwError = MAP_LWMSG_ERROR(lwmsg_peer_start_listen(gpServer));
error:
LWNET_SAFE_FREE_STRING(pszCachePath);
LWNET_SAFE_FREE_STRING(pszCommPath);
if (dwError)
{
if (gpServer)
{
lwmsg_peer_stop_listen(gpServer);
lwmsg_peer_delete(gpServer);
gpServer = NULL;
}
}
return dwError;
}
DWORD
GetWbclientDir(
PCSTR pSmbdPath,
PSTR* ppDir
)
{
PCSTR ppBackupPaths[] = {
"/usr/lib",
"/usr/lib64",
NULL,
};
DWORD index = 0;
DWORD error = 0;
BOOLEAN exists = 0;
PSTR pFoundPath = NULL;
PSTR pCommandLine = NULL;
PCSTR ppArgs[] = {
"/bin/sh",
"-c",
NULL,
NULL
};
PSTR pSambaLibdir = NULL;
*ppDir = NULL;
// First see if libwbclient.so.0 is in Samba's libdir. There may be two
// copies of libwbclient.so.0 because of different architectures. This will
// identify which one is the primary one.
error = LwAllocateStringPrintf(
&pCommandLine,
"%s -b | grep LIBDIR:",
pSmbdPath
);
BAIL_ON_LSA_ERROR(error);
ppArgs[2] = pCommandLine;
error = CaptureOutputWithStderr(
"/bin/sh",
ppArgs,
&pSambaLibdir,
NULL);
BAIL_ON_LSA_ERROR(error);
LwStripWhitespace(
pSambaLibdir,
TRUE,
TRUE);
if (strstr(pSambaLibdir, ": "))
{
char *pValueStart = strstr(pSambaLibdir, ": ") + 2;
memmove(
pSambaLibdir,
pValueStart,
strlen(pSambaLibdir) - (pValueStart - pSambaLibdir) + 1);
}
error = FindFileInPath(
WBCLIENT_FILENAME,
pSambaLibdir,
&pFoundPath);
if (error == ERROR_FILE_NOT_FOUND)
{
// Fall back to trying the two standard system paths
error = FindFileInPath(
WBCLIENT_FILENAME,
"/usr/lib:/usr/lib64",
&pFoundPath);
if (error == ERROR_FILE_NOT_FOUND)
{
error = 0;
}
}
BAIL_ON_LSA_ERROR(error);
if (pFoundPath)
{
pFoundPath[strlen(pFoundPath) - (sizeof(WBCLIENT_FILENAME) -1) - 1] = 0;
*ppDir = pFoundPath;
pFoundPath = NULL;
goto cleanup;
}
// Could not find an existing libwbclient.so.0. This could be a Samba 3.0.x
// build. Just stick the file in a system path.
for (index = 0; ppBackupPaths[index]; index++)
{
error = LwCheckFileTypeExists(
ppBackupPaths[index],
LWFILE_DIRECTORY,
&exists);
BAIL_ON_LSA_ERROR(error);
if (exists)
{
error = LwAllocateString(ppBackupPaths[index], ppDir);
BAIL_ON_LSA_ERROR(error);
goto cleanup;
}
}
// Could not find the system library paths.
error = ERROR_FILE_NOT_FOUND;
BAIL_ON_LSA_ERROR(error);
cleanup:
LW_SAFE_FREE_STRING(pFoundPath);
LW_SAFE_FREE_STRING(pCommandLine);
LW_SAFE_FREE_STRING(pSambaLibdir);
return error;
}
int
main(
int argc,
char *argv[]
)
{
enum
{
UNSET,
SHOW_HELP,
CHECK_VERSION,
INSTALL,
UNINSTALL
} mode = UNSET;
PCSTR pSmbdPath = NULL;
PSTR pFoundSmbdPath = NULL;
DWORD error = 0;
DWORD argIndex = 0;
LW_RTL_LOG_LEVEL logLevel = LW_RTL_LOG_LEVEL_ERROR;
PCSTR pErrorSymbol = NULL;
PSTR pVersion = NULL;
BOOLEAN smbdExists = FALSE;
BOOLEAN force = FALSE;
for (argIndex = 1; argIndex < argc; argIndex++)
{
if (!strcmp(argv[argIndex], "--check-version"))
{
if (mode == UNSET)
{
mode = CHECK_VERSION;
}
else
{
mode = SHOW_HELP;
}
}
else if (!strcmp(argv[argIndex], "--install"))
{
if (mode == UNSET)
{
mode = INSTALL;
}
else
{
mode = SHOW_HELP;
}
}
else if (!strcmp(argv[argIndex], "--uninstall"))
{
if (mode == UNSET)
{
mode = UNINSTALL;
}
else
{
mode = SHOW_HELP;
}
}
else if (!strcmp(argv[argIndex], "--force"))
{
if (mode == INSTALL || mode== UNINSTALL)
{
force = TRUE;
}
else
{
mode = SHOW_HELP;
}
}
else if (!strcmp(argv[argIndex], "--loglevel"))
{
argIndex++;
if (argIndex >= argc)
{
error = ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(error);
}
if (!strcmp(argv[argIndex], "error"))
{
logLevel = LW_RTL_LOG_LEVEL_ERROR;
}
else if (!strcmp(argv[argIndex], "warning"))
{
logLevel = LW_RTL_LOG_LEVEL_WARNING;
}
else if (!strcmp(argv[argIndex], "info"))
{
logLevel = LW_RTL_LOG_LEVEL_INFO;
}
else if (!strcmp(argv[argIndex], "verbose"))
{
logLevel = LW_RTL_LOG_LEVEL_VERBOSE;
}
else if (!strcmp(argv[argIndex], "debug"))
{
logLevel = LW_RTL_LOG_LEVEL_DEBUG;
}
else
{
error = ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(error);
}
}
else if (argIndex == argc - 1)
{
pSmbdPath = argv[argIndex];
}
else
{
mode = SHOW_HELP;
}
}
if (mode == UNSET || mode == SHOW_HELP)
{
ShowUsage(argv[0]);
goto cleanup;
}
LwRtlLogSetCallback(LogCallback, NULL);
LwRtlLogSetLevel(logLevel);
if (pSmbdPath == NULL)
{
PCSTR pSearchPath = "/usr/sbin:/usr/local/sbin:/usr/local/samba/sbin:/opt/csw/samba/sbin:/opt/sfw/samba/sbin:/opt/csw/bin:/usr/local/bin";
error = FindFileInPath(
"smbd",
pSearchPath,
&pFoundSmbdPath);
if (error == ERROR_FILE_NOT_FOUND)
{
LW_RTL_LOG_ERROR("The smbd file could not be automatically found on your system. The search path was '%s'. Pass the correct location as the last argument to this program.", pSearchPath);
}
BAIL_ON_LSA_ERROR(error);
pSmbdPath = pFoundSmbdPath;
}
error = LwCheckFileTypeExists(
pSmbdPath,
LWFILE_REGULAR,
&smbdExists);
BAIL_ON_LSA_ERROR(error);
if (!smbdExists)
{
error = LwCheckFileTypeExists(
pSmbdPath,
LWFILE_SYMLINK,
&smbdExists);
BAIL_ON_LSA_ERROR(error);
}
if (!smbdExists)
{
LW_RTL_LOG_ERROR("Smbd file not found at path '%s'", pSmbdPath);
}
error = CheckSambaVersion(pSmbdPath, &pVersion);
if (force == FALSE)
{
BAIL_ON_LSA_ERROR(error);
}
if (mode == CHECK_VERSION)
{
fprintf(stderr, "Samba version supported\n");
}
else if (mode == INSTALL)
{
if (geteuid() != 0)
{
fprintf(stderr, "Please use the root account to install the Samba interop libraries\n");
goto cleanup;
}
error = InstallWbclient(pSmbdPath);
BAIL_ON_LSA_ERROR(error);
if (pVersion && strncmp(pVersion, "3.0.", sizeof("3.0.") - 1) == 0)
{
// Only Samba 3.0.x needs this
error = InstallLwiCompat(pSmbdPath);
BAIL_ON_LSA_ERROR(error);
}
error = SynchronizePassword(
pSmbdPath);
BAIL_ON_LSA_ERROR(error);
fprintf(stderr, "Install successful\n");
}
else if (mode == UNINSTALL)
{
if (geteuid() != 0)
{
fprintf(stderr, "Please use the root account to uninstall the Samba interop libraries\n");
goto cleanup;
}
error = UninstallWbclient(pSmbdPath);
BAIL_ON_LSA_ERROR(error);
error = UninstallLwiCompat(pSmbdPath);
BAIL_ON_LSA_ERROR(error);
error = DeletePassword(
pSmbdPath);
BAIL_ON_LSA_ERROR(error);
fprintf(stderr, "Uninstall successful\n");
}
else
{
fprintf(stderr, "Uninstall mode not implemented\n");
error = ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(error);
}
cleanup:
LW_SAFE_FREE_STRING(pFoundSmbdPath);
LW_SAFE_FREE_STRING(pVersion);
if (error)
{
pErrorSymbol = LwWin32ErrorToName(error);
if (pErrorSymbol != NULL)
{
fprintf(stderr, "Error: %s\n", pErrorSymbol);
}
else
{
fprintf(stderr, "Unknown error\n");
}
}
return error;
}
DWORD
FindFileInPath(
PCSTR pFilename,
PCSTR pSearchPath,
PSTR* ppFoundPath
)
{
DWORD error = ERROR_SUCCESS;
//Copy the search path so that strtok can be run on it
PSTR pMySearchPath = NULL;
PSTR pStrtokSavePtr = NULL;
PSTR pCurrentDir = NULL;
PSTR pTestPath = NULL;
BOOLEAN exists = FALSE;
if (ppFoundPath != NULL)
{
*ppFoundPath = NULL;
}
error = LwAllocateString(pSearchPath, &pMySearchPath);
BAIL_ON_LSA_ERROR(error);
pCurrentDir = strtok_r(pMySearchPath, ":", &pStrtokSavePtr);
while (TRUE)
{
LW_SAFE_FREE_STRING(pTestPath);
error = LwAllocateStringPrintf(
&pTestPath,
"%s/%s",
pCurrentDir,
pFilename);
error = LwCheckFileTypeExists(
pTestPath,
LWFILE_REGULAR,
&exists);
BAIL_ON_LSA_ERROR(error);
if (!exists)
{
error = LwCheckFileTypeExists(
pTestPath,
LWFILE_SYMLINK,
&exists);
BAIL_ON_LSA_ERROR(error);
}
if (!exists)
{
error = LwCheckFileTypeExists(
pTestPath,
LWFILE_DIRECTORY,
&exists);
BAIL_ON_LSA_ERROR(error);
}
if (exists)
{
if (ppFoundPath != NULL)
{
*ppFoundPath = pTestPath;
pTestPath = NULL;
}
break;
}
pCurrentDir = strtok_r(NULL, ":", &pStrtokSavePtr);
if(pCurrentDir == NULL)
{
error = ERROR_FILE_NOT_FOUND;
BAIL_ON_LSA_ERROR(error);
}
}
cleanup:
LW_SAFE_FREE_STRING(pMySearchPath);
LW_SAFE_FREE_STRING(pTestPath);
return error;
}
DWORD
LWNetDnsGetNameServerList(
OUT PSTR** pppszNameServerList,
OUT PDWORD pdwNumServers
)
// Call LWNET_SAFE_FREE_STRING_ARRAY on returned server list
{
DWORD dwError = 0;
PSTR* ppszNameServerList = NULL;
DWORD dwNumServers = 0;
FILE* fp = NULL;
BOOLEAN bFileExists = FALSE;
PCSTR pszConfigFilePath = "/etc/resolv.conf";
const DWORD dwMaxLineLen = 1024;
CHAR szBuf[dwMaxLineLen + 1];
regex_t rx;
PDLINKEDLIST pNameServerList = NULL;
PSTR pszNameServer = NULL;
memset(&rx, 0, sizeof(rx));
if (regcomp(&rx, "^nameserver[[:space:]].*$", REG_EXTENDED) < 0) {
dwError = ERROR_BAD_FORMAT;
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LwCheckFileTypeExists(
pszConfigFilePath,
LWFILE_REGULAR,
&bFileExists);
BAIL_ON_LWNET_ERROR(dwError);
if (!bFileExists) {
*pppszNameServerList = NULL;
*pdwNumServers = 0;
goto cleanup;
}
if ((fp = fopen(pszConfigFilePath, "r")) == NULL) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LWNET_ERROR(dwError);
}
while (1)
{
if (fgets(szBuf, dwMaxLineLen, fp) == NULL) {
if (!feof(fp)) {
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LWNET_ERROR(dwError);
} else {
break;
}
}
LwStripWhitespace(szBuf, TRUE, TRUE);
if (!LWNetDnsConfigLineIsComment(szBuf) &&
!regexec(&rx, szBuf, (size_t)0, NULL, 0))
{
PSTR pszLocation = NULL;
PCSTR pszSearchString = "nameserver";
if ((pszLocation = strstr(szBuf, pszSearchString))) {
pszLocation += strlen(pszSearchString);
if (!IsNullOrEmptyString(pszLocation)) {
dwError = LWNetAllocateString(pszLocation, &pszNameServer);
BAIL_ON_LWNET_ERROR(dwError);
}
dwError = LWNetDLinkedListAppend(
&pNameServerList,
pszNameServer);
BAIL_ON_LWNET_ERROR(dwError);
pszNameServer = NULL;
dwNumServers++;
}
}
}
if (dwNumServers)
{
PDLINKEDLIST pListMember = NULL;
DWORD iMember = 0;
dwError = LWNetAllocateMemory(dwNumServers * sizeof(PSTR), (PVOID*)&ppszNameServerList);
BAIL_ON_LWNET_ERROR(dwError);
pListMember = pNameServerList;
while (pListMember)
{
ppszNameServerList[iMember++] = (PSTR)pListMember->pItem;
pListMember->pItem = NULL;
pListMember = pListMember->pNext;
}
}
*pppszNameServerList = ppszNameServerList;
*pdwNumServers = dwNumServers;
cleanup:
regfree(&rx);
LWNetDLinkedListFree(pNameServerList);
LWNET_SAFE_FREE_STRING(pszNameServer);
if (fp) {
fclose(fp);
}
return dwError;
error:
*pppszNameServerList = NULL;
*pdwNumServers = 0;
if (ppszNameServerList) {
LWNetFreeStringArray(ppszNameServerList, dwNumServers);
}
goto cleanup;
}
DWORD LwTaskRepositoryInit(VOID)
{
DWORD dwError = 0;
PCSTR pszDbDirPath = LW_TASK_DB_DIR;
PCSTR pszDbPath = LW_TASK_DB;
BOOLEAN bExists = FALSE;
BOOLEAN bCleanupDb = FALSE;
PLW_TASK_DB_CONTEXT pDbContext = NULL;
pthread_rwlock_init(&gLwTaskDbGlobals.mutex, NULL);
gLwTaskDbGlobals.pMutex = &gLwTaskDbGlobals.mutex;
dwError = LwCheckFileTypeExists(
pszDbDirPath,
LWFILE_DIRECTORY,
&bExists);
BAIL_ON_LW_TASK_ERROR(dwError);
if (!bExists)
{
mode_t mode = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
/* Allow go+rx to the base folder */
dwError = LwCreateDirectory(pszDbDirPath, mode);
BAIL_ON_LW_TASK_ERROR(dwError);
}
/* restrict access to u+rwx to the db folder */
dwError = LwChangeOwnerAndPermissions(
pszDbDirPath,
0, /* uid: root */
0, /* gid: root */
S_IRWXU);
BAIL_ON_LW_TASK_ERROR(dwError);
dwError = LwCheckFileTypeExists(pszDbPath, LWFILE_REGULAR, &bExists);
BAIL_ON_LW_TASK_ERROR(dwError);
if (!bExists)
{
dwError = LwTaskDbOpen(&pDbContext);
BAIL_ON_LW_TASK_ERROR(dwError);
bCleanupDb = TRUE;
dwError = LwTaskDbCreateTables(pDbContext);
BAIL_ON_LW_TASK_ERROR(dwError);
dwError = LwTaskDbAddDefaultEntries(pDbContext);
BAIL_ON_LW_TASK_ERROR(dwError);
dwError = LwChangeOwnerAndPermissions(
pszDbPath,
0, /* uid: root */
0, /* gid: root */
S_IRWXU);
BAIL_ON_LW_TASK_ERROR(dwError);
}
cleanup:
if (pDbContext)
{
LwTaskDbClose(pDbContext);
}
return dwError;
error:
if (bCleanupDb)
{
LwRemoveFile(pszDbPath);
}
goto cleanup;
}
