void MyFrame::OnHostname( wxCommandEvent& WXUNUSED(event) )
{
if (GetHostname()->GetStringSelection() == wxT("..."))
{
wxString s = wxGetTextFromUser(wxT("Specify the name of the host (ignored under DDE)"),
wxT("Host Name"), wxEmptyString, this);
if (!s.IsEmpty() && s != IPC_HOST)
{
GetHostname()->Insert(s, 0);
GetHostname()->SetSelection(0);
}
}
}
/****************************************************************************
*
* Function: GetUniqueName(char * iface)
*
* Purpose: To return a string that has a high probability of being unique
* for a given sensor.
*
* Arguments: char * iface - The network interface you are sniffing
*
* Returns: A char * -- its a static char * so you should not free it
*
***************************************************************************/
char *GetUniqueName(char * iface)
{
char * rptr;
#ifdef WIN32
rptr = GetHostname();
#else
rptr = GetIP(iface);
if(rptr == NULL)
{
rptr = GetHostname();
}
#endif
return rptr;
}
void PrintInfo()
{
std::cout << "system information" << std::endl;
log::Indenter indenter;
if (*CVAR(logHost))
{
try
{
std::string
user(GetUsername()),
host(GetHostname());
std::cout << "host is " << user << " on " << host << std::endl;
}
catch (...) {}
}
try
{
std::string platform(GetOs());
std::cout << "platform is " << platform << std::endl;
}
catch (...) {}
try
{
std::string machine(GetCpu());
std::cout << "machine is " << machine << std::endl;
}
catch (...) {}
}
nsCString
nsSmtpServer::GetServerURIInternal(const bool aIncludeUsername)
{
nsCString uri(NS_LITERAL_CSTRING("smtp://"));
nsresult rv;
if (aIncludeUsername)
{
nsCString username;
rv = GetUsername(username);
if (NS_SUCCEEDED(rv) && !username.IsEmpty()) {
nsCString escapedUsername;
MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
// not all servers have a username
uri.Append(escapedUsername);
uri.AppendLiteral("@");
}
}
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
MsgEscapeString(hostname, nsINetUtil::ESCAPE_URL_PATH, escapedHostname);
// not all servers have a hostname
uri.Append(escapedHostname);
}
return uri;
}
NS_IMETHODIMP
nsSmtpServer::GetServerURI(nsACString &aResult)
{
nsCAutoString uri(NS_LITERAL_CSTRING("smtp://"));
nsCString username;
nsresult rv = GetUsername(username);
if (NS_SUCCEEDED(rv) && !username.IsEmpty()) {
nsCString escapedUsername;
MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
// not all servers have a username
uri.Append(escapedUsername);
uri.AppendLiteral("@");
}
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
*((char **)getter_Copies(escapedHostname)) =
nsEscape(hostname.get(), url_Path);
// not all servers have a hostname
uri.Append(escapedHostname);
}
aResult = uri;
return NS_OK;
}
const char *localHostname(void)
{
if(!gotLocalHostname)
{
GetHostname(localHostbuf, sizeof(localHostbuf) - 1);
gotLocalHostname = 1;
}
return localHostbuf;
}
NS_IMETHODIMP
nsSmtpServer::ForgetPassword()
{
nsresult rv;
nsCOMPtr<nsILoginManager> loginMgr =
do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Get the current server URI without the username
nsCAutoString serverUri(NS_LITERAL_CSTRING("smtp://"));
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
*((char **)getter_Copies(escapedHostname)) =
nsEscape(hostname.get(), url_Path);
// not all servers have a hostname
serverUri.Append(escapedHostname);
}
PRUint32 count;
nsILoginInfo** logins;
NS_ConvertUTF8toUTF16 currServer(serverUri);
nsCString serverCUsername;
rv = GetUsername(serverCUsername);
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertUTF8toUTF16 serverUsername(serverCUsername);
rv = loginMgr->FindLogins(&count, currServer, EmptyString(),
currServer, &logins);
NS_ENSURE_SUCCESS(rv, rv);
// There should only be one-login stored for this url, however just in case
// there isn't.
nsString username;
for (PRUint32 i = 0; i < count; ++i)
{
if (NS_SUCCEEDED(logins[i]->GetUsername(username)) &&
username.Equals(serverUsername))
{
// If this fails, just continue, we'll still want to remove the password
// from our local cache.
loginMgr->RemoveLogin(logins[i]);
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins);
rv = SetPassword(EmptyCString());
m_logonFailed = PR_TRUE;
return rv;
}
void MyFrame::EnableControls()
{
GetStart()->Enable(m_client == NULL);
GetServername()->Enable(m_client == NULL);
GetHostname()->Enable(m_client == NULL);
GetTopic()->Enable(m_client == NULL);
const bool isConnected = (m_client != NULL && m_client->IsConnected());
GetDisconnect()->Enable(m_client != NULL && isConnected);
GetStartAdvise()->Enable(m_client != NULL && isConnected);
GetStopAdvise()->Enable(m_client != NULL && isConnected);
GetExecute()->Enable(m_client != NULL && isConnected);
GetPoke()->Enable(m_client != NULL && isConnected);
GetRequest()->Enable(m_client != NULL && isConnected);
}
bool LoginSession::Recieve(XMLPacket *Packet)
{
if (!Packet) {
return false;
}
if (strncmp(Packet->m_Path, g_STS_Ping, sizeof(Packet->m_Path)) == 0) {
printf("%s -> Ping!\n", m_Client->m_ClientIP);
}
else if (strncmp(Packet->m_Path, g_STS_Connect, sizeof(Packet->m_Path)) == 0) {
Init(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_StartTLS, sizeof(Packet->m_Path)) == 0) {
StartTLS(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_GetHost, sizeof(Packet->m_Path)) == 0) {
GetHostname(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_StartSsoLogin, sizeof(Packet->m_Path)) == 0) {
StartSsoLogin(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_ListGameAcc, sizeof(Packet->m_Path)) == 0) {
ListGameAccounts(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_Resume, sizeof(Packet->m_Path)) == 0) {
ResumeAuthentication(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_RequestGameToken, sizeof(Packet->m_Path)) == 0) {
RequestGameToken(Packet);
}
else if (strncmp(Packet->m_Path, g_AUTH_Logout, sizeof(Packet->m_Path)) == 0) {
Logout(Packet);
}
else {
printf("Unknown command: %s\n", Packet->m_Path);
}
return true;
}
void MyFrame::OnStart(wxCommandEvent& WXUNUSED(event))
{
// Connect to the client
wxString servername = GetServername()->GetStringSelection();
wxString hostname = GetHostname()->GetStringSelection();
wxString topic = GetTopic()->GetStringSelection();
m_client = new MyClient;
bool retval = m_client->Connect(hostname, servername, topic);
wxLogMessage(wxT("Client host=\"%s\" port=\"%s\" topic=\"%s\" %s"),
hostname.c_str(), servername.c_str(), topic.c_str(),
retval ? wxT("connected") : wxT("failed to connect"));
if (!retval)
{
wxDELETE(m_client);
}
EnableControls();
}
// Define my frame constructor
MyFrame::MyFrame(wxFrame *frame, const wxString& title)
: wxFrame(frame, wxID_ANY, title, wxDefaultPosition, wxSize(400, 300))
{
// Give it an icon
SetIcon(wxICON(sample));
// Make a menubar
wxMenu *file_menu = new wxMenu;
file_menu->Append(wxID_EXIT, wxT("&Quit\tCtrl-Q"));
wxMenuBar *menu_bar = new wxMenuBar;
menu_bar->Append(file_menu, wxT("&File"));
// Associate the menu bar with the frame
SetMenuBar(menu_bar);
// set a dialog background
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
// add the controls to the frame
wxString strs4[] =
{
IPC_SERVICE, wxT("...")
};
wxString strs5[] =
{
IPC_HOST, wxT("...")
};
wxString strs6[] =
{
IPC_TOPIC, wxT("...")
};
wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
wxBoxSizer *item1 = new wxBoxSizer( wxHORIZONTAL );
wxGridSizer *item2 = new wxGridSizer( 4, 0, 0 );
wxButton *item3 = new wxButton( this, ID_START, wxT("Connect to server"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item3, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
wxChoice *item5 = new wxChoice( this, ID_HOSTNAME, wxDefaultPosition, wxSize(100,-1), 2, strs5, 0 );
item2->Add( item5, 0, wxALIGN_CENTER|wxALL, 5 );
wxChoice *item4 = new wxChoice( this, ID_SERVERNAME, wxDefaultPosition, wxSize(100,-1), 2, strs4, 0 );
item2->Add( item4, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
wxChoice *item6 = new wxChoice( this, ID_TOPIC, wxDefaultPosition, wxSize(100,-1), 2, strs6, 0 );
item2->Add( item6, 0, wxALIGN_CENTER|wxALL, 5 );
wxButton *item7 = new wxButton( this, ID_DISCONNECT, wxT("Disconnect "), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item7, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
wxButton *item8 = new wxButton( this, ID_STARTADVISE, wxT("StartAdvise"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item8, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
wxButton *item9 = new wxButton( this, ID_STOPADVISE, wxT("StopAdvise"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item9, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
wxButton *item10 = new wxButton( this, ID_EXECUTE, wxT("Execute"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item10, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
wxButton *item11 = new wxButton( this, ID_POKE, wxT("Poke"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item11, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
wxButton *item12 = new wxButton( this, ID_REQUEST, wxT("Request"), wxDefaultPosition, wxDefaultSize, 0 );
item2->Add( item12, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item2->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
item1->Add( item2, 1, wxALIGN_CENTER|wxALL, 5 );
item0->Add( item1, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
wxStaticBox *item14 = new wxStaticBox( this, -1, wxT("Client log") );
wxStaticBoxSizer *item13 = new wxStaticBoxSizer( item14, wxVERTICAL );
wxTextCtrl *item15 = new wxTextCtrl( this, ID_LOG, wxEmptyString, wxDefaultPosition, wxSize(500,140), wxTE_MULTILINE );
item13->Add( item15, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
item0->Add( item13, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
this->SetSizer( item0 );
item0->SetSizeHints( this );
// status
m_client = NULL;
GetServername()->SetSelection(0);
GetHostname()->SetSelection(0);
GetTopic()->SetSelection(0);
wxLogTextCtrl *logWindow = new wxLogTextCtrl(GetLog());
delete wxLog::SetActiveTarget(logWindow);
wxLogMessage(wxT("Click on Connect to connect to the server"));
EnableControls();
}
TEST(HostNameTest, HostNameNotEmptySmallVector) {
SmallVector<char, 256> name;
ASSERT_NE(GetHostname(name), "");
}
TEST(HostNameTest, HostNameEq) {
SmallVector<char, 256> nameBuf;
ASSERT_EQ(GetHostname(nameBuf), GetHostname());
}
void ifconfig(){
Printf("Configuration réseau de la machine : \n");
Printf("Nom de la machine : %d \n",GetHostname());
}
NS_IMETHODIMP
nsSmtpServer::GetPassword(nsACString& aPassword)
{
if (m_password.IsEmpty() && !m_logonFailed)
{
// try to avoid prompting the user for another password. If the user has set
// the appropriate pref, we'll use the password from an incoming server, if
// the user has already logged onto that server.
// if this is set, we'll only use this, and not the other prefs
// user_pref("mail.smtpserver.smtp1.incomingAccount", "server1");
// if this is set, we'll accept an exact match of user name and server
// user_pref("mail.smtp.useMatchingHostNameServer", true);
// if this is set, and we don't find an exact match of user and host name,
// we'll accept a match of username and domain, where domain
// is everything after the first '.'
// user_pref("mail.smtp.useMatchingDomainServer", true);
nsCString accountKey;
bool useMatchingHostNameServer = false;
bool useMatchingDomainServer = false;
mPrefBranch->GetCharPref("incomingAccount", getter_Copies(accountKey));
nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID);
nsCOMPtr<nsIMsgIncomingServer> incomingServerToUse;
if (accountManager)
{
if (!accountKey.IsEmpty())
accountManager->GetIncomingServer(accountKey, getter_AddRefs(incomingServerToUse));
else
{
nsresult rv;
nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv,rv);
prefBranch->GetBoolPref("mail.smtp.useMatchingHostNameServer", &useMatchingHostNameServer);
prefBranch->GetBoolPref("mail.smtp.useMatchingDomainServer", &useMatchingDomainServer);
if (useMatchingHostNameServer || useMatchingDomainServer)
{
nsCString userName;
nsCString hostName;
GetHostname(hostName);
GetUsername(userName);
if (useMatchingHostNameServer)
// pass in empty type and port=0, to match imap and pop3.
accountManager->FindRealServer(userName, hostName, EmptyCString(), 0, getter_AddRefs(incomingServerToUse));
int32_t dotPos = -1;
if (!incomingServerToUse && useMatchingDomainServer
&& (dotPos = hostName.FindChar('.')) != kNotFound)
{
hostName.Cut(0, dotPos);
nsCOMPtr<nsISupportsArray> allServers;
accountManager->GetAllServers(getter_AddRefs(allServers));
if (allServers)
{
uint32_t count = 0;
allServers->Count(&count);
uint32_t i;
for (i = 0; i < count; i++)
{
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(allServers, i);
if (server)
{
nsCString serverUserName;
nsCString serverHostName;
server->GetRealUsername(serverUserName);
server->GetRealHostName(serverHostName);
if (serverUserName.Equals(userName))
{
int32_t serverDotPos = serverHostName.FindChar('.');
if (serverDotPos != kNotFound)
{
serverHostName.Cut(0, serverDotPos);
if (serverHostName.Equals(hostName))
{
incomingServerToUse = server;
break;
}
}
}
}
}
}
}
}
}
}
if (incomingServerToUse)
return incomingServerToUse->GetPassword(aPassword);
}
aPassword = m_password;
return NS_OK;
}
XrmDatabase XtScreenDatabase(
Screen *screen)
{
int scrno;
Bool doing_def;
XrmDatabase db, olddb;
XtPerDisplay pd;
Status do_fallback;
char *scr_resources;
Display *dpy = DisplayOfScreen(screen);
DPY_TO_APPCON(dpy);
LOCK_APP(app);
LOCK_PROCESS;
if (screen == DefaultScreenOfDisplay(dpy)) {
scrno = DefaultScreen(dpy);
doing_def = True;
} else {
scrno = XScreenNumberOfScreen(screen);
doing_def = False;
}
pd = _XtGetPerDisplay(dpy);
if ((db = pd->per_screen_db[scrno])) {
UNLOCK_PROCESS;
UNLOCK_APP(app);
return (doing_def ? XrmGetDatabase(dpy) : db);
}
scr_resources = XScreenResourceString(screen);
if (ScreenCount(dpy) == 1) {
db = pd->cmd_db;
pd->cmd_db = NULL;
} else {
db = CopyDB(pd->cmd_db);
}
{ /* Environment defaults */
char filenamebuf[PATH_MAX];
char *filename;
if (!(filename = getenv("XENVIRONMENT"))) {
int len;
#ifdef __MINGW32__
const char *slashDotXdefaultsDash = "/Xdefaults-";
#else
const char *slashDotXdefaultsDash = "/.Xdefaults-";
#endif
(void) GetRootDirName(filename = filenamebuf,
PATH_MAX - strlen (slashDotXdefaultsDash) - 1);
(void) strcat(filename, slashDotXdefaultsDash);
len = strlen(filename);
GetHostname (filename+len, PATH_MAX-len);
}
(void)XrmCombineFileDatabase(filename, &db, False);
}
if (scr_resources)
{ /* Screen defaults */
XrmCombineDatabase(XrmGetStringDatabase(scr_resources), &db, False);
XFree(scr_resources);
}
/* Server or host defaults */
if (!pd->server_db)
CombineUserDefaults(dpy, &db);
else {
(void) XrmCombineDatabase(pd->server_db, &db, False);
pd->server_db = NULL;
}
if (!db)
db = XrmGetStringDatabase("");
pd->per_screen_db[scrno] = db;
olddb = XrmGetDatabase(dpy);
/* set database now, for XtResolvePathname to use */
XrmSetDatabase(dpy, db);
CombineAppUserDefaults(dpy, &db);
do_fallback = 1;
{ /* System app-defaults */
char *filename;
if ((filename = XtResolvePathname(dpy, "app-defaults",
NULL, NULL, NULL, NULL, 0, NULL))) {
do_fallback = !XrmCombineFileDatabase(filename, &db, False);
XtFree(filename);
}
}
/* now restore old database, if need be */
if (!doing_def)
XrmSetDatabase(dpy, olddb);
if (do_fallback && pd->appContext->fallback_resources)
{ /* Fallback defaults */
XrmDatabase fdb = NULL;
String *res;
for (res = pd->appContext->fallback_resources; *res; res++)
XrmPutLineResource(&fdb, *res);
(void)XrmCombineDatabase(fdb, &db, False);
}
UNLOCK_PROCESS;
UNLOCK_APP(app);
return db;
}
static
DWORD
ParseJoinArgs(
IN int argc,
IN const char *argv[],
OUT PJOIN_ARGS pArgs
)
{
DWORD dwError = 0;
PCSTR programName = NULL;
PCSTR option = NULL;
LW_ARGV_CURSOR cursor;
SHOW_USAGE_CALLBACK ShowUsageHelp = ShowJoinUsageHelp;
SHOW_USAGE_CALLBACK ShowUsageError = ShowJoinUsageError;
memset(pArgs, 0, sizeof(*pArgs));
LwArgvCursorInit(&cursor, argc, argv);
programName = LwArgvCursorPop(&cursor);
// Process options:
for (;;)
{
option = PopNextOption(&cursor);
if (!option)
{
break;
}
else if (IsHelpOption(option))
{
ShowUsageHelp(programName);
}
else if (!strcmp("--name", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszMachineName);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--dnssuffix", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszDnsSuffix);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--ou", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszOu);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--osname", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszOsName);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--osversion", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszOsVersion);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--osservicepack", option))
{
dwError = GetOptionValue(programName, ShowUsageError, &cursor, option,
&pArgs->pszOsServicePack);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
else if (!strcmp("--notimesync", option))
{
SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_NOTIMESYNC);
}
else if (!strcmp("--multiple", option))
{
SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_NOTIMESYNC);
SetFlag(pArgs->JoinFlags, LSA_NET_JOIN_DOMAIN_MULTIPLE);
}
else
{
fprintf(stderr, "Unrecognized option: %s\n", option);
ShowUsageError(programName);
}
}
// Process arguments:
dwError = GetArgumentValue(programName, ShowUsageError, &cursor, "DOMAIN",
&pArgs->pszDomain);
GOTO_CLEANUP_ON_WINERROR(dwError);
LwStrToUpper(pArgs->pszDomain);
dwError = GetArgumentValue(programName, ShowUsageError, &cursor, "USERNAME",
&pArgs->pszUsername);
GOTO_CLEANUP_ON_WINERROR(dwError);
// Optional argument
dwError = GetArgumentValue(programName, ShowUsageError, &cursor, NULL,
&pArgs->pszPassword);
assert(!dwError);
if (LwArgvCursorRemaining(&cursor))
{
fprintf(stderr, "Too many arguments.\n");
ShowUsageError(programName);
}
// Initialize missing options as needed
if (!pArgs->pszDnsSuffix)
{
dwError = LwAllocateString(pArgs->pszDomain, &pArgs->pszDnsSuffix);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
LwStrToLower(pArgs->pszDnsSuffix);
if (!pArgs->pszMachineName)
{
dwError = GetHostname(&pArgs->pszMachineName);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
if (!pArgs->pszOsName ||
!pArgs->pszOsVersion ||
!pArgs->pszOsServicePack)
{
dwError = GetOsInfo(
pArgs->pszOsName ? NULL : &pArgs->pszOsName,
pArgs->pszOsVersion ? NULL : &pArgs->pszOsVersion,
pArgs->pszOsServicePack ? NULL : &pArgs->pszOsServicePack);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
dwError = CleanupUsername(pArgs->pszDomain, &pArgs->pszUsername);
GOTO_CLEANUP_ON_WINERROR(dwError);
if (!pArgs->pszPassword)
{
dwError = PromptPassword(pArgs->pszUsername, &pArgs->pszPassword);
GOTO_CLEANUP_ON_WINERROR(dwError);
}
cleanup:
if (dwError)
{
FreeJoinArgsContents(pArgs);
}
return dwError;
}
TEST(HostNameTest, HostNameNotEmpty) { ASSERT_NE(GetHostname(), ""); }
