/*!
@brief ユーザフルネームの取得 (Unicode)
*/
BOOL CUserInfoDlg::GetFullNameW(wchar_t *UserName, wchar_t *, wchar_t *dest)
{
LPBYTE ComputerName = 0;
struct _USER_INFO_2 *ui; // User structure
BOOL bFoundDC = TRUE;
DWORD nRet = NetGetDCName(NULL, NULL, &ComputerName );
// Get the computer name of a DC for the specified domain.
if (nRet != NERR_Success) {
printf("Error getting user information.\n" );
bFoundDC = FALSE;
}
// Look up the user on the DC.
nRet = NetUserGetInfo((LPWSTR) ComputerName,
(LPWSTR) UserName, 2, (LPBYTE *) &ui);
if (nRet != NERR_Success) {
if (bFoundDC == TRUE) {
NetApiBufferFree(ComputerName);
}
printf("Error getting user information.\n" );
return(FALSE );
}
if (bFoundDC == TRUE) {
NetApiBufferFree(ComputerName);
}
wcsncpy_s(dest, 256, ui->usri2_full_name, _TRUNCATE);
return(TRUE );
}
NET_API_STATUS
NetUserGetProfilePath( LPCWSTR Domain, LPCWSTR UserName, char * profilePath,
DWORD profilePathLen )
{
NET_API_STATUS code;
LPWSTR ServerName = NULL;
LPUSER_INFO_3 p3 = NULL;
NetGetAnyDCName(NULL, Domain, (LPBYTE *)&ServerName);
/* if NetGetAnyDCName fails, ServerName == NULL
* NetUserGetInfo will obtain local user information
*/
code = NetUserGetInfo(ServerName, UserName, 3, (LPBYTE *)&p3);
if (code == NERR_Success)
{
code = NERR_UserNotFound;
if (p3) {
if (p3->usri3_profile) {
DWORD len = lstrlenW(p3->usri3_profile);
if (len > 0) {
/* Convert From Unicode to ANSI (UTF-8 for future) */
len = len < profilePathLen ? len : profilePathLen - 1;
WideCharToMultiByte(CP_UTF8, 0, p3->usri3_profile, len, profilePath, len, NULL, NULL);
profilePath[len] = '\0';
code = NERR_Success;
}
}
NetApiBufferFree(p3);
}
}
if (ServerName)
NetApiBufferFree(ServerName);
return code;
}
/* InitName - initialize name translation
*
* pszServer machine name for symref daemon
*/
void InitName (IN PSZ pszServer)
{
PSERVICE_INFO_0 psi;
PWKSTA_INFO_100 pwi;
//
// Set up daemon server name
//
strcpy (szServer, pszServer);
//
// See if our own server is started
//
if (NetServiceGetInfo (NULL, "SERVER", 0, (LPBYTE *) &psi) == 0) {
fServerStarted = TRUE;
NetApiBufferFree (psi);
}
//
// Set up workstation name
//
NetWkstaGetInfo (NULL, 100, (LPBYTE *) &pwi);
strcpy (szWksta, pwi->wki100_computername);
NetApiBufferFree (pwi);
}
static
NET_API_STATUS
EnumerateUsers(VOID)
{
PUSER_INFO_0 pBuffer = NULL;
PSERVER_INFO_100 pServer = NULL;
DWORD dwRead = 0, dwTotal = 0;
DWORD i;
DWORD_PTR ResumeHandle = 0;
NET_API_STATUS Status;
Status = NetServerGetInfo(NULL,
100,
(LPBYTE*)&pServer);
if (Status != NERR_Success)
return Status;
ConPuts(StdOut, L"\n");
ConResPrintf(StdOut, IDS_USER_ACCOUNTS, pServer->sv100_name);
ConPuts(StdOut, L"\n\n");
PrintPadding(L'-', 79);
ConPuts(StdOut, L"\n");
NetApiBufferFree(pServer);
do
{
Status = NetUserEnum(NULL,
0,
0,
(LPBYTE*)&pBuffer,
MAX_PREFERRED_LENGTH,
&dwRead,
&dwTotal,
&ResumeHandle);
if ((Status != NERR_Success) && (Status != ERROR_MORE_DATA))
return Status;
qsort(pBuffer,
dwRead,
sizeof(PUSER_INFO_0),
CompareInfo);
for (i = 0; i < dwRead; i++)
{
if (pBuffer[i].usri0_name)
ConPrintf(StdOut, L"%s\n", pBuffer[i].usri0_name);
}
NetApiBufferFree(pBuffer);
pBuffer = NULL;
}
while (Status == ERROR_MORE_DATA);
return NERR_Success;
}
bool CWfpNET::PasswordPolicy_get(void)
{
USER_MODALS_INFO_0 *pBuf0 = NULL;
USER_MODALS_INFO_3 *pBuf3 = NULL;
NET_API_STATUS nStatus = NULL;
CString tmp;
if((nStatus = NetUserModalsGet(node.szComputerW, 0,(LPBYTE *)&pBuf0)) != NERR_Success)
ErrorHandler("NetUserModalsGet", nStatus);
else
{
//m_output.operator +=(_T("Password Policy:\n"));
if (pBuf0 != NULL)
{
tmp.Format("\tMinimum password length: %d\n", pBuf0->usrmod0_min_passwd_len);
Users.Add(tmp);
if(pBuf0->usrmod0_max_passwd_age == TIMEQ_FOREVER)
tmp.Format("\tMaximum password age: Forever\n");
else
tmp.Format("\tMaximum password age : %d days\n", pBuf0->usrmod0_max_passwd_age/86400);
Users.Add(tmp);
tmp.Format("\tMinimum password age : %d days\n", pBuf0->usrmod0_min_passwd_age/86400);
Users.Add(tmp);
if(pBuf0->usrmod0_force_logoff == TIMEQ_FOREVER)
tmp.Format("\tForced log off time : Never\n");
else
tmp.Format("\tForced log off time : %d seconds\n", pBuf0->usrmod0_force_logoff);
Users.Add(tmp);
tmp.Format("\tPassword history length: %d\n", pBuf0->usrmod0_password_hist_len);
Users.Add(tmp);
}
}
if (pBuf0 != NULL)
NetApiBufferFree(pBuf0);
if((nStatus = NetUserModalsGet(node.szComputerW, 3,(LPBYTE *)&pBuf3)) != NERR_Success)
ErrorHandler("NetUserModalsGet", nStatus);
else
{
if(pBuf3 != NULL)
{
tmp.Format("\tAttempts before Lockout: %d\n",pBuf3->usrmod3_lockout_threshold);
Users.Add(tmp);
tmp.Format("\tTime between two failed login attempts: %d seconds\n",pBuf3->usrmod3_lockout_duration);
Users.Add(tmp);
tmp.Format("\tLockout Duration: %d minutes\n",pBuf3->usrmod3_lockout_duration/60);
Users.Add(tmp);
}
}
if (pBuf3 != NULL)
NetApiBufferFree(pBuf3);
return true;
}
/*!
@brief ユーザグループの取得 (MBCS)
*/
BOOL CUserInfoDlg::GetGroupNameA(char *UserName, char *dest)
{
WCHAR wszUserName[256]; // Unicode user name
LPBYTE ComputerName = 0;
// Convert ASCII user name and domain to Unicode.
MultiByteToWideChar(CP_ACP, 0, UserName, strlen(UserName) + 1, wszUserName, sizeof(wszUserName) / sizeof(WCHAR));
// Get the computer name of a DC for the specified domain.
BOOL bFoundDC = TRUE;
DWORD nRet = NetGetDCName(NULL, NULL, &ComputerName );
if (nRet != NERR_Success) {
printf("Error getting group information.\n" );
bFoundDC = FALSE;
}
LPLOCALGROUP_USERS_INFO_0 pBuf = NULL;
DWORD dwEntriesRead = 0;
DWORD dwTotalEntries = 0; // Look up the user on the DC.
nRet = NetUserGetLocalGroups((LPWSTR) ComputerName,
(LPWSTR) wszUserName, 0, LG_INCLUDE_INDIRECT, (LPBYTE *) &pBuf, MAX_PREFERRED_LENGTH, &dwEntriesRead, &dwTotalEntries);
if (nRet != NERR_Success) {
if (bFoundDC == TRUE) {
NetApiBufferFree(ComputerName);
}
printf("Error getting group information.\n" );
return(FALSE );
}
if (bFoundDC == TRUE) {
NetApiBufferFree(ComputerName);
}
LPLOCALGROUP_USERS_INFO_0 pTmpBuf = pBuf;
for (unsigned int i = 0; i < dwEntriesRead; i++) {
if (pTmpBuf == NULL) {
fprintf(stderr, "An access violation has occurred\n");
break;
}
strcat_s(dest, (GNLEN + 1) * 5, ",");
char szGroupName[GNLEN + 1];
// Convert the Unicode full name to ASCII.
WideCharToMultiByte(CP_ACP, 0, pTmpBuf->lgrui0_name, -1, szGroupName, GNLEN, NULL, NULL );
strcat_s(dest, (GNLEN + 1) * 5, szGroupName);
pTmpBuf++;
}
NetApiBufferFree(pBuf);
return (TRUE);
}
NS_IMETHODIMP
nsUserInfo::GetFullname(PRUnichar **aFullname)
{
NS_ENSURE_ARG_POINTER(aFullname);
*aFullname = nullptr;
PRUnichar fullName[512];
DWORD size = mozilla::ArrayLength(fullName);
if (GetUserNameExW(NameDisplay, fullName, &size)) {
*aFullname = ToNewUnicode(nsDependentString(fullName));
} else {
DWORD getUsernameError = GetLastError();
// Try to use the net APIs regardless of the error because it may be
// able to obtain the information.
PRUnichar username[UNLEN + 1];
size = mozilla::ArrayLength(username);
if (!GetUserNameW(username, &size)) {
// ERROR_NONE_MAPPED means the user info is not filled out on this computer
return getUsernameError == ERROR_NONE_MAPPED ?
NS_ERROR_NOT_AVAILABLE : NS_ERROR_FAILURE;
}
const DWORD level = 2;
LPBYTE info;
// If the NetUserGetInfo function has no full name info it will return
// success with an empty string.
NET_API_STATUS status = NetUserGetInfo(nullptr, username, level, &info);
if (status != NERR_Success) {
// We have an error with NetUserGetInfo but we know the info is not
// filled in because GetUserNameExW returned ERROR_NONE_MAPPED.
return getUsernameError == ERROR_NONE_MAPPED ?
NS_ERROR_NOT_AVAILABLE : NS_ERROR_FAILURE;
}
nsDependentString fullName =
nsDependentString(reinterpret_cast<USER_INFO_2 *>(info)->usri2_full_name);
// NetUserGetInfo returns an empty string if the full name is not filled out
if (fullName.Length() == 0) {
NetApiBufferFree(info);
return NS_ERROR_NOT_AVAILABLE;
}
*aFullname = ToNewUnicode(fullName);
NetApiBufferFree(info);
}
return (*aFullname) ? NS_OK : NS_ERROR_FAILURE;
}
USHORT find_rts(TCHAR FAR * buf, USHORT buflen)
{
USHORT err; /* API return status */
struct server_info_0 FAR * si;
USHORT2ULONG eread;
UNREFERENCED_PARAMETER(buflen) ;
/* find a reliable time server */
err = MNetServerEnum(NULL,0,(LPBYTE*)&si, &eread,
(ULONG) SV_TYPE_TIME_SOURCE, NULL);
/* there are none -- bag it */
if (err != NERR_Success || eread == 0)
return APE_TIME_RtsNotFound;
/* copy over name into buffer */
_tcscpy(buf,TEXT("\\\\"));
_tcscat(buf,si->sv0_name);
NetApiBufferFree((TCHAR FAR *) si);
return 0;
}
virtual void GetLoggedInUsers(const std::wstring& ComputerName, OBJ_LIST& loggedInUsers, OBJ_LIST& domains)
{
LPWKSTA_USER_INFO_1 pBuf = NULL;
LPWKSTA_USER_INFO_1 pTmpBuf;
DWORD dwLevel = 1;
DWORD dwPrefMaxLen = -1;
DWORD dwEntriesRead = 0;
DWORD dwTotalEntries = 0;
DWORD dwResumeHandle = 0;
NET_API_STATUS nStatus;
do
{
nStatus = NetWkstaUserEnum((wchar_t*)ComputerName.c_str(), dwLevel, (LPBYTE*)&pBuf, dwPrefMaxLen, &dwEntriesRead, &dwTotalEntries, &dwResumeHandle);
if ((nStatus == NERR_Success) || (nStatus == ERROR_MORE_DATA))
{
pTmpBuf = pBuf;
// Loop through the entries.
for (DWORD i = 0; (i < dwEntriesRead); i++)
{
loggedInUsers.push_back(pTmpBuf->wkui1_username);
domains.push_back(pTmpBuf->wkui1_logon_domain);
pTmpBuf++;
}
NetApiBufferFree(pBuf);
}
else
KLSTD_THROW_LASTERROR_CODE(nStatus);
}
while (nStatus == ERROR_MORE_DATA);
}
JSBool netgetjoinableous(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{
LPWSTR domain, account, password;
JS_BeginRequest(cx);
if(!JS_ConvertArguments(cx, argc, argv, "W W W", &domain, &account, &password))
{
JS_ReportError(cx, "Error parsing arguments in NetGetJoinableOUs");
JS_EndRequest(cx);
}
JS_YieldRequest(cx);
DWORD ouCount = 0;
LPWSTR * ous = NULL;
DWORD status = NetGetJoinableOUs(NULL, domain, (JSVAL_IS_NULL(argv[1]) ? NULL : account), (JSVAL_IS_NULL(argv[2]) ? NULL : password), &ouCount, &ous);
if(status != NERR_Success)
{
JS_NewNumberValue(cx, status, rval);
JS_EndRequest(cx);
return JS_TRUE;
}
JSObject * arrayObj = JS_NewArrayObject(cx, 0, NULL);
*rval = OBJECT_TO_JSVAL(arrayObj);
for(DWORD i = 0; i < ouCount; i++)
{
JSString * curOu = JS_NewUCStringCopyZ(cx, (jschar*)ous[i]);
JS_DefineElement(cx, arrayObj, i, STRING_TO_JSVAL(curOu), NULL, NULL, 0);
}
NetApiBufferFree(ous);
JS_EndRequest(cx);
return JS_TRUE;
}
QString SystemInfo::getJoinInformation(bool *isJoinedToDomain, const QString &serverName){
qDebug()<<"--SystemInfo::getJoinInformation()";
QString workgroupName = "";
NET_API_STATUS err;
LPWSTR lpNameBuffer = new wchar_t[256];
NETSETUP_JOIN_STATUS bufferType;
LPCWSTR lpServer = NULL; // The server is the default local computer.
if(!serverName.trimmed().isEmpty()){
lpServer = serverName.toStdWString().c_str();
}
err = NetGetJoinInformation(lpServer, &lpNameBuffer, &bufferType);
if(err == NERR_Success){
workgroupName = QString::fromWCharArray(lpNameBuffer);
}else{
QMessageBox::critical(this, tr("Error"), tr("Can not get join status information!"));
}
NetApiBufferFree(lpNameBuffer);
if(isJoinedToDomain){
*isJoinedToDomain = (bufferType == NetSetupDomainName)?true:false;
}
return workgroupName;
}
static int get_user_local_groups(WCHAR *user, struct oscap_list *list)
{
NET_API_STATUS status;
LOCALGROUP_USERS_INFO_0 *buffer = NULL;
DWORD preffered_max_len = MAX_PREFERRED_LENGTH;
DWORD entries_read = 0;
DWORD total_entries = 0;
/*
* LG_INCLUDE_INDIRECT means the function also returns the names of
* the local groups in which the user is indirectly a member (that is,
* the user has membership in a global group that is itself a member
* of one or more local groups).
*/
status = NetUserGetLocalGroups(NULL, user, 0, LG_INCLUDE_INDIRECT, (LPBYTE *)&buffer, preffered_max_len, &entries_read, &total_entries);
if (status != NERR_Success) {
dD("NetUserGetLocalGroups failed: %d", status);
return 1;
}
for (DWORD i = 0; i < entries_read; i++) {
WCHAR *group_name = buffer[i].lgrui0_name;
oscap_list_add(list, wcsdup(group_name));
}
NetApiBufferFree(buffer);
return 0;
}
USHORT MNetAccessGetInfo (
const CHAR FAR * pszServer,
CHAR FAR * pszResource,
SHORT Level,
CHAR FAR ** ppBuffer ) {
USHORT usReturnCode,
cbTotalAvail;
// get a small buffer
*ppBuffer = MGetBuffer(LITTLE_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetAccessGetInfo(pszServer, pszResource, Level, *ppBuffer,
LITTLE_BUFFER_SIZE, & cbTotalAvail);
// If we're returning an error that's not moredata, free the buffer first
if (usReturnCode && usReturnCode != ERROR_MORE_DATA &&
usReturnCode != NERR_BufTooSmall) {
NetApiBufferFree(*ppBuffer);
}
return (usReturnCode);
}
/**
* Lookup a user based on a user ID. Calling functions should
* free the result with authz_free_buffer().
*
* @param userid user name to lookup
*
* @return a user info structure or NULL on error
*/
userinfo_t *authz_lookup_user(const char *userid)
{
struct USER_INFO_23 *buf = NULL;
userinfo_t *result = NULL;
NET_API_STATUS status;
pthread_mutex_lock(&_ctxmtx);
if (!userid || !_netapictx) {
pthread_mutex_unlock(&_ctxmtx);
return NULL;
}
status = NetUserGetInfo(_host, userid, 23, (uint8_t **)&buf);
if (status != NET_API_STATUS_SUCCESS) {
log_warn("NetApi lookup for user %s failed (%d)", userid, status);
pthread_mutex_unlock(&_ctxmtx);
return NULL;
}
result = (userinfo_t *)malloc(sizeof(userinfo_t));
bzero(result, sizeof(userinfo_t));
result->logon_name = strdup(userid);
result->display_name = strdup(buf->usri23_full_name);
ConvertSidToStringSid(buf->usri23_user_sid, &result->sid);
NetApiBufferFree(buf);
pthread_mutex_unlock(&_ctxmtx);
log_debug("found user %s with SID %s", userid, result->sid);
return result;
}
std::vector<Group*> UserUtilities::GetUserGroupList(CString strUserName)
{
std::vector<Group*> lstUserGroups;
LOCALGROUP_USERS_INFO_0 *grpInfo = NULL;
LOCALGROUP_USERS_INFO_0 *tempgrpInfo = NULL;
DWORD entriesRead = 0;
DWORD totalEntries = 0;
int res = NetUserGetLocalGroups(NULL, strUserName, 0, 0, (LPBYTE*)&grpInfo, MAX_PREFERRED_LENGTH, &entriesRead, &totalEntries);
if(entriesRead > 0)
{
tempgrpInfo = grpInfo;
for(int i = 0;i < entriesRead;i++)
{
Group* grp = new Group();
grp->m_StrGroupName = tempgrpInfo->lgrui0_name;
lstUserGroups.push_back(grp);
tempgrpInfo++;
}
}
if(grpInfo)
{
NetApiBufferFree(grpInfo);
grpInfo = NULL;
}
return lstUserGroups;
}
void SystemUserMappingWindows::GetUserCredentialsForCurrentUser(
xtreemfs::pbrpc::UserCredentials* user_credentials) {
LPWKSTA_USER_INFO_1 user_info = NULL;
NET_API_STATUS result = NetWkstaUserGetInfo(
NULL,
1,
reinterpret_cast<LPBYTE*>(&user_info));
if (result == NERR_Success) {
if (user_info != NULL) {
string username = ConvertWindowsToUTF8(user_info->wkui1_username);
string groupname = ConvertWindowsToUTF8(user_info->wkui1_logon_domain);
NetApiBufferFree(user_info);
if (additional_user_mapping_.get()) {
string local_username(username);
string local_groupname(groupname);
additional_user_mapping_->LocalToGlobalUsername(local_username,
&username);
additional_user_mapping_->LocalToGlobalGroupname(local_groupname,
&groupname);
}
user_credentials->set_username(username);
user_credentials->add_groups(groupname);
}
} else {
Logging::log->getLog(LEVEL_ERROR) <<
"Failed to retrieve the current username and domain name, error"
" code: " << result << endl;
}
}
UINT initializeAfsAdminGroup(void) {
PSID psidAdmin = NULL;
SID_IDENTIFIER_AUTHORITY auth = SECURITY_NT_AUTHORITY;
NET_API_STATUS status;
LOCALGROUP_MEMBERS_INFO_0 *gmAdmins = NULL;
DWORD dwNEntries, dwTEntries;
WCHAR AdminGroupName[UNLEN+1];
DWORD cchName = UNLEN;
if (!LookupAliasFromRid( NULL, DOMAIN_ALIAS_RID_ADMINS, AdminGroupName, &cchName ))
{
/* if we fail, we will try the English string "Administrators" */
wcsncpy(AdminGroupName, L"Administrators", UNLEN+1);
AdminGroupName[UNLEN] = 0;
}
status = NetLocalGroupGetMembers(NULL, AdminGroupName, 0, (LPBYTE *) &gmAdmins, MAX_PREFERRED_LENGTH, &dwNEntries, &dwTEntries, NULL);
if(status)
return status;
status = NetLocalGroupAddMembers(NULL, AFSCLIENT_ADMIN_GROUPNAMEW, 0, (LPBYTE) gmAdmins, dwNEntries);
NetApiBufferFree( gmAdmins );
return status;
}
~Private()
{
if (userInfo)
NetApiBufferFree(userInfo);
delete[] sid;
}
virtual std::wstring DistDomainNameToNT4Name(const std::wstring& domain)
{
KLSTD_CHKINPTR(m_fnDsGetDcName);
std::wstring wstrDNSDomain(domain.begin() + 3, domain.end());
size_t nPos = wstrDNSDomain.find(L",DC=");
while(nPos != std::wstring::npos)
{
wstrDNSDomain.replace(nPos, 4, L".");
nPos = wstrDNSDomain.find(L",DC=", nPos + 1);
}
PDOMAIN_CONTROLLER_INFO pDomainControllerInfo = NULL;
DWORD dwResult = m_fnDsGetDcName(NULL, KLSTD_W2T2(wstrDNSDomain.c_str()), NULL, NULL,
DS_DIRECTORY_SERVICE_REQUIRED | DS_IS_DNS_NAME | DS_RETURN_FLAT_NAME,
&pDomainControllerInfo);
if (dwResult != NO_ERROR)
{
KLSTD_TRACE3(1, L"DistDomainNameToNT4Name(DN:'%ls', DNS:'%ls')::DsGetDcName - Error '%u'\n", domain.c_str(), wstrDNSDomain.c_str(), dwResult);
KLSTD_THROW(KLSTD::STDE_FAULT);
}
std::wstring rc = KLSTD_T2W2(pDomainControllerInfo->DomainName);
NetApiBufferFree(pDomainControllerInfo);
return rc;
}
static VOID
UpdateGroupProperties(HWND hwndDlg)
{
TCHAR szGroupName[UNLEN];
INT iItem;
HWND hwndLV;
PLOCALGROUP_INFO_1 pGroupInfo = NULL;
hwndLV = GetDlgItem(hwndDlg, IDC_GROUPS_LIST);
iItem = ListView_GetNextItem(hwndLV, -1, LVNI_SELECTED);
if (iItem == -1)
return;
/* Get the group name */
ListView_GetItemText(hwndLV,
iItem, 0,
szGroupName,
UNLEN);
NetLocalGroupGetInfo(NULL, szGroupName, 1, (LPBYTE*)&pGroupInfo);
ListView_SetItemText(hwndLV, iItem, 1,
pGroupInfo->lgrpi1_comment);
NetApiBufferFree(pGroupInfo);
}
WORD
MFreeMem(
LPBYTE Buffer
)
{
return(LOWORD(NetApiBufferFree(Buffer)));
}
std::vector<Group*> UserUtilities::GetGroupList()
{
std::vector<Group*> lstGroups;
LOCALGROUP_INFO_1* grpInfo = NULL;
LOCALGROUP_INFO_1* tempgrpInfo;
DWORD entriesRead = 0;
DWORD totalEntries = 0;
DWORD resume = 0;
int res = NetLocalGroupEnum(NULL, 1, (LPBYTE*)&grpInfo, -1, &entriesRead, &totalEntries, &resume);
if(entriesRead > 0)
{
tempgrpInfo = grpInfo;
for(int i = 0;i < entriesRead;i++)
{
Group* grp = new Group();
grp->m_StrGroupName = tempgrpInfo->lgrpi1_name;
grp->m_StrDescription = tempgrpInfo->lgrpi1_comment;
lstGroups.push_back(grp);
tempgrpInfo++;
}
}
if(grpInfo)
{
NetApiBufferFree(grpInfo);
grpInfo = NULL;
}
return lstGroups;
}
USHORT MNetServiceControl (
const CHAR FAR * pszServer,
const CHAR FAR * pszService,
CHAR wpOpCode,
CHAR wpArg,
CHAR FAR ** ppBuffer ) {
USHORT usReturnCode;
// get a small buffer
*ppBuffer = MGetBuffer(LITTLE_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetServiceControl(pszServer, pszService, wpOpCode, wpArg,
*ppBuffer, LITTLE_BUFFER_SIZE);
// If we're returning an error that's not moredata, free the buffer first
if (usReturnCode && usReturnCode != ERROR_MORE_DATA &&
usReturnCode != NERR_BufTooSmall) {
NetApiBufferFree(*ppBuffer);
}
return (usReturnCode);
}
enum System::userlevel System::userPermissions(void)
{
LPUSER_INFO_1 buf = NULL;
wchar_t userbuf[UNLEN];
DWORD usersize = UNLEN;
BOOL status;
enum userlevel result = ERR;
status = GetUserNameW(userbuf, &usersize);
if(!status)
return ERR;
if(NetUserGetInfo(NULL, userbuf, (DWORD)1, (LPBYTE*)&buf) == NERR_Success) {
switch(buf->usri1_priv) {
case USER_PRIV_GUEST:
result = GUEST;
break;
case USER_PRIV_USER:
result = USER;
break;
case USER_PRIV_ADMIN:
result = ADMIN;
break;
default:
result = ERR;
break;
}
}
if(buf != NULL)
NetApiBufferFree(buf);
return result;
}
bool LdapUtils::getDcName(const char* domain, StringBuffer& dc)
{
bool ret = false;
#ifdef _WIN32
PDOMAIN_CONTROLLER_INFO psInfo = NULL;
DWORD dwErr = DsGetDcName(NULL, domain, NULL, NULL, DS_FORCE_REDISCOVERY | DS_DIRECTORY_SERVICE_REQUIRED, &psInfo);
if( dwErr == NO_ERROR)
{
const char* dcname = psInfo->DomainControllerName;
if(dcname != NULL)
{
while(*dcname == '\\')
dcname++;
dc.append(dcname);
ret = true;
}
NetApiBufferFree(psInfo);
}
else
{
DBGLOG("Error getting domain controller, error = %d", dwErr);
ret = false;
}
#endif
return ret;
}
bool CWfpNET::Time_get(void) // Obtain Date and Time
{
LPTIME_OF_DAY_INFO pTOD = NULL;
NET_API_STATUS nStatus = NULL;
DWORD mindiff = 0, hourdiff = 0;
CString tmp;
// The NetRemoteTOD function returns the time of day information from
// a specified server.
// No special group membership is required to successfully execute the
// NetRemoteTOD function.
nStatus = NetRemoteTOD(node.szComputerW, (LPBYTE *)&pTOD);
if(nStatus == NERR_Success)
{
if(pTOD != NULL)
{
tmp.Format(_T("Date and Time:\n\t[%d/%d/%d] "),pTOD->tod_month, pTOD->tod_day, pTOD->tod_year);
Time.Add(tmp);
tmp.Format(_T(" -- %02lu:%02lu:%02lu.%02lu\n"), pTOD->tod_hours - (pTOD->tod_timezone / 60), pTOD->tod_mins, pTOD->tod_secs, pTOD->tod_hunds);
Time.Add(tmp);
}
}
else
{
ErrorHandler("NetRemoteTOD", nStatus);
return false;
}
if(pTOD != NULL)
NetApiBufferFree(pTOD);
return true;
}
// Fetches the MAC address and prints it
static void GetMACaddress(void)
{
unsigned char MACData[8]; // Allocate data structure for MAC (6 bytes needed)
WKSTA_TRANSPORT_INFO_0 *pwkti; // Allocate data structure for Netbios
DWORD dwEntriesRead;
DWORD dwTotalEntries;
BYTE *pbBuffer;
// Get MAC address via NetBios's enumerate function
NET_API_STATUS dwStatus = NetWkstaTransportEnum(
NULL, // [in] server name
0, // [in] data structure to return
&pbBuffer, // [out] pointer to buffer
MAX_PREFERRED_LENGTH, // [in] maximum length
&dwEntriesRead, // [out] counter of elements actually enumerated
&dwTotalEntries, // [out] total number of elements that could be enumerated
NULL); // [in/out] resume handle
assert(dwStatus == NERR_Success);
pwkti = (WKSTA_TRANSPORT_INFO_0 *)pbBuffer; // type cast the buffer
for (DWORD i = 0; i< dwEntriesRead; i++) // first address is 00000000, skip it
{ // enumerate MACs and print
swscanf((wchar_t *)pwkti[i].wkti0_transport_address, L"%2hx%2hx%2hx%2hx%2hx%2hx",
&MACData[0], &MACData[1], &MACData[2], &MACData[3], &MACData[4], &MACData[5]);
PrintMACaddress(MACData);
}
// Release pbBuffer allocated by above function
dwStatus = NetApiBufferFree(pbBuffer);
assert(dwStatus == NERR_Success);
}
/***
* check_max_uses()
*
* Check if a share has a /USERS:n switch or a /UNLIMITED
* switch. If not, set max_users to the value of num_admin.
*
* Currently used only on the ADMIN$ share.
*
* Args:
* none
*
* Returns:
* nothing - success
* exit(2) - command failed
*/
VOID NEAR check_max_uses(VOID)
{
USHORT err; /* API return status */
int i;
struct server_info_2 FAR * server_entry;
TCHAR FAR * ptr;
USHORT2ULONG swlen1, swlen2 ;
static TCHAR users_switch[20] ;
_tcscpy(users_switch,swtxt_SW_SHARE_USERS);
swlen1 = _tcslen(users_switch);
swlen2 = _tcslen(swtxt_SW_SHARE_UNLIMITED);
for (i = 0; SwitchList[i]; i++)
{
if ( (strncmpf(SwitchList[i], users_switch, swlen1) == 0) ||
(strncmpf(SwitchList[i], swtxt_SW_SHARE_UNLIMITED, swlen2) == 0)
)
{
return; // A specific switch exists; return without
// further action.
}
}
if (err = MNetServerGetInfo(NULL,
2,
(LPBYTE*)&server_entry))
ErrorExit (err);
ptr = _tcschr(users_switch, NULLC);
nsprintf(ptr, TEXT(":%u"), server_entry->sv2_numadmin);
SwitchList[i] = users_switch;
NetApiBufferFree((TCHAR FAR *) server_entry);
}
USHORT MNetAccessEnum (
const CHAR FAR * pszServer,
CHAR FAR * pszBasePath,
USHORT fsRecursive,
SHORT Level,
CHAR FAR ** ppBuffer,
USHORT FAR * pcEntriesRead ) {
USHORT usReturnCode,
cbTotalAvail;
SEL sel;
// get a 4K buffer
*ppBuffer = MGetBuffer(BIG_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetAccessEnum(pszServer, pszBasePath, fsRecursive, Level,
*ppBuffer, BIG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
// is there more data? if so, allocate a big enough buffer to get it
if(usReturnCode == ERROR_MORE_DATA || usReturnCode == NERR_BufTooSmall)
{
NetApiBufferFree(*ppBuffer);
if (DEBUGALLOC(FULL_SEG_BUFFER_SIZE, & sel, SEG_NONSHARED))
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
*ppBuffer = MAKEP(sel, 0);
usReturnCode = NetAccessEnum(pszServer, pszBasePath, fsRecursive, Level,
*ppBuffer, FULL_SEG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
}
// If we're returning an error that's not moredata, or there are no
// entries to return, free the buffer first
if ((usReturnCode && usReturnCode != ERROR_MORE_DATA &&
usReturnCode != NERR_BufTooSmall) || *pcEntriesRead == 0) {
NetApiBufferFree(*ppBuffer);
}
return (usReturnCode);
}
static BOOL
SetUserGeneralData(HWND hwndDlg,
PGENERAL_USER_DATA pUserData)
{
PUSER_INFO_3 pUserInfo = NULL;
LPTSTR pszFullName = NULL;
LPTSTR pszComment = NULL;
NET_API_STATUS status;
DWORD dwIndex;
INT nLength;
NetUserGetInfo(NULL, pUserData->szUserName, 3, (LPBYTE*)&pUserInfo);
pUserInfo->usri3_flags =
(pUserData->dwFlags & VALID_GENERAL_FLAGS) |
(pUserInfo->usri3_flags & ~VALID_GENERAL_FLAGS);
pUserInfo->usri3_password_expired = pUserData->dwPasswordExpired;
nLength = GetWindowTextLength(GetDlgItem(hwndDlg, IDC_USER_GENERAL_FULL_NAME));
if (nLength == 0)
{
pUserInfo->usri3_full_name = NULL;
}
else
{
pszFullName = HeapAlloc(GetProcessHeap(), 0, (nLength + 1) * sizeof(TCHAR));
GetDlgItemText(hwndDlg, IDC_USER_GENERAL_FULL_NAME, pszFullName, nLength + 1);
pUserInfo->usri3_full_name = pszFullName;
}
nLength = GetWindowTextLength(GetDlgItem(hwndDlg, IDC_USER_GENERAL_DESCRIPTION));
if (nLength == 0)
{
pUserInfo->usri3_full_name = NULL;
}
else
{
pszComment = HeapAlloc(GetProcessHeap(), 0, (nLength + 1) * sizeof(TCHAR));
GetDlgItemText(hwndDlg, IDC_USER_GENERAL_DESCRIPTION, pszComment, nLength + 1);
pUserInfo->usri3_comment = pszComment;
}
status = NetUserSetInfo(NULL, pUserData->szUserName, 3, (LPBYTE)pUserInfo, &dwIndex);
if (status != NERR_Success)
{
DebugPrintf(_T("Status: %lu Index: %lu"), status, dwIndex);
}
if (pszFullName)
HeapFree(GetProcessHeap(), 0, pszFullName);
if (pszComment)
HeapFree(GetProcessHeap(), 0, pszComment);
NetApiBufferFree(pUserInfo);
return (status == NERR_Success);
}
