haiku.git

/*
 * Copyright 2005, Waldemar Kornewald <wkornew@gmx.net>
 * Distributed under the terms of the MIT License.
 */

#include "ConnectionView.h"
#include "PPPDeskbarReplicant.h"
#include <MessageDriverSettingsUtils.h>

#include <Application.h>
#include <Box.h>
#include <Button.h>
#include <Deskbar.h>
#include <Entry.h>
#include <File.h>
#include <String.h>
#include <StringView.h>
#include <TextControl.h>
#include <Window.h>

#include <PPPInterface.h>
#include <settings_tools.h>
#include <algorithm>
	// for max()

using std::max;

// GUI constants
static const uint32 kDefaultButtonWidth = 80;

// message constants
static const uint32 kMsgCancel = 'CANC';
static const uint32 kMsgConnect = 'CONN';
static const uint32 kMsgUpdate = 'MUPD';

// labels
static const char *kLabelSavePassword = "Save password";
static const char *kLabelName = "Username: ";
static const char *kLabelPassword = "Password: ";
static const char *kLabelConnect = "Connect";
static const char *kLabelCancel = "Cancel";
static const char *kLabelAuthentication = "Authentication";

// connection status strings
static const char *kTextConnecting = "Connecting...";
static const char *kTextConnectionEstablished = "Connection established.";
static const char *kTextNotConnected = "Not connected.";
static const char *kTextDeviceUpFailed = "Failed to connect.";
static const char *kTextAuthenticating = "Authenticating...";
static const char *kTextAuthenticationFailed = "Authentication failed!";
static const char *kTextConnectionLost = "Connection lost!";


ConnectionView::ConnectionView(BRect rect, const BString& interfaceName)
	: BView(rect, "ConnectionView", B_FOLLOW_NONE, 0),
	fListener(this),
	fInterfaceName(interfaceName),
	fKeepLabel(false)
{
	SetViewUIColor(B_PANEL_BACKGROUND_COLOR);
	
	rect = Bounds();
	rect.InsetBy(5, 5);
	rect.bottom = rect.top
		+ 25 // space for topmost control
		+ 3 * 20 // size of controls
		+ 3 * 5; // space beween controls and bottom of box
	BBox *authenticationBox = new BBox(rect, "Authentication");
	authenticationBox->SetLabel(kLabelAuthentication);
	rect = authenticationBox->Bounds();
	rect.InsetBy(10, 20);
	rect.bottom = rect.top + 20;
	fUsername = new BTextControl(rect, "username", kLabelName, NULL, NULL);
	rect.top = rect.bottom + 5;
	rect.bottom = rect.top + 20;
	fPassword = new BTextControl(rect, "password", kLabelPassword, NULL, NULL);
	fPassword->TextView()->HideTyping(true);
	
	// set dividers
	float width = max(StringWidth(fUsername->Label()),
		StringWidth(fPassword->Label()));
	fUsername->SetDivider(width + 5);
	fPassword->SetDivider(width + 5);
	
	rect.top = rect.bottom + 5;
	rect.bottom = rect.top + 20;
	fSavePassword = new BCheckBox(rect, "SavePassword", kLabelSavePassword, NULL);
	
	authenticationBox->AddChild(fUsername);
	authenticationBox->AddChild(fPassword);
	authenticationBox->AddChild(fSavePassword);
	AddChild(authenticationBox);
	
	rect = authenticationBox->Frame();
	rect.top = rect.bottom + 10;
	rect.bottom = rect.top + 15;
	fAttemptView = new BStringView(rect, "AttemptView", "");
	AddChild(fAttemptView);
	
	// add status view
	rect.top = rect.bottom + 5;
	rect.bottom = rect.top + 15;
	fStatusView = new BStringView(rect, "StatusView", "");
	AddChild(fStatusView);
	
	// add "Connect" and "Cancel" buttons
	rect.top = rect.bottom + 10;
	rect.bottom = rect.top + 25;
	rect.right = rect.left + kDefaultButtonWidth;
	fConnectButton = new BButton(rect, "ConnectButton", kLabelConnect,
		new BMessage(kMsgConnect));
	
	rect.left = rect.right + 10;
	rect.right = rect.left + kDefaultButtonWidth;
	fCancelButton = new BButton(rect, "CancelButton", kLabelCancel,
		new BMessage(kMsgCancel));
	
	AddChild(fConnectButton);
	AddChild(fCancelButton);
}


void
ConnectionView::AttachedToWindow()
{
	Reload();
	fListener.WatchManager();
	WatchInterface(fListener.Manager().InterfaceWithName(fInterfaceName.String()));
	
	Window()->SetDefaultButton(fConnectButton);
	fConnectButton->SetTarget(this);
	fCancelButton->SetTarget(this);
}


void
ConnectionView::MessageReceived(BMessage *message)
{
	switch(message->what) {
		case PPP_REPORT_MESSAGE:
			HandleReportMessage(message);
		break;
		
		case kMsgConnect:
			Connect();
		break;
		
		case kMsgCancel:
			Cancel();
		break;
		
		default:
			BView::MessageReceived(message);
	}
}


// update authentication UI
void
ConnectionView::Reload()
{
	// load username and password
	BString path("ptpnet/");
	path << fInterfaceName;
	fSettings.MakeEmpty();
	ReadMessageDriverSettings(path.String(), &fSettings);
	
	fHasUsername = fHasPassword = false;
	BString username, password;
	
	BMessage parameter;
	int32 parameterIndex = 0;
	if(FindMessageParameter(PPP_USERNAME_KEY, fSettings, &parameter, &parameterIndex)
			&& parameter.FindString(MDSU_VALUES, &username) == B_OK)
		fHasUsername = true;
	
	parameterIndex = 0;
	if(FindMessageParameter(PPP_PASSWORD_KEY, fSettings, &parameter, &parameterIndex)
			&& parameter.FindString(MDSU_VALUES, &password) == B_OK)
		fHasPassword = true;
	
	fUsername->SetText(username.String());
	fPassword->SetText(password.String());
	fSavePassword->SetValue(fHasPassword);
	
	fUsername->SetEnabled(fHasUsername);
	fPassword->SetEnabled(fHasUsername);
	fSavePassword->SetEnabled(fHasUsername);
}


void
ConnectionView::Connect()
{
	PPPInterface interface(PPPManager().CreateInterfaceWithName(
		fInterfaceName.String()));
	interface.SetUsername(Username());
	interface.SetPassword(Password());
	interface.SetAskBeforeConnecting(false);
	interface.Up();
	
	// save settings
	if(fHasUsername) {
		BMessage parameter;
		int32 index = 0;
		if(FindMessageParameter(PPP_USERNAME_KEY, fSettings, &parameter, &index))
			fSettings.RemoveData(MDSU_PARAMETERS, index);
		parameter.MakeEmpty();
		parameter.AddString(MDSU_NAME, PPP_USERNAME_KEY);
		parameter.AddString(MDSU_VALUES, Username());
		fSettings.AddMessage(MDSU_PARAMETERS, &parameter);
		
		index = 0;
		if(FindMessageParameter(PPP_PASSWORD_KEY, fSettings, &parameter, &index))
			fSettings.RemoveData(MDSU_PARAMETERS, index);
		if(DoesSavePassword()) {
			parameter.MakeEmpty();
			parameter.AddString(MDSU_NAME, PPP_PASSWORD_KEY);
			parameter.AddString(MDSU_VALUES, Password());
			fSettings.AddMessage(MDSU_PARAMETERS, &parameter);
		}
		
		BEntry entry;
		if(interface.GetSettingsEntry(&entry) == B_OK) {
			BFile file(&entry, B_WRITE_ONLY);
			WriteMessageDriverSettings(file, fSettings);
		}
	}
	
	Reload();
}


void
ConnectionView::Cancel()
{
	PPPInterface interface(fListener.Interface());
	bool quit = false;
	ppp_interface_info_t info;
	if(interface.GetInterfaceInfo(&info) && info.info.phase < PPP_ESTABLISHMENT_PHASE)
		quit = true;
	interface.Down();
	if(quit)
		Window()->Quit();
}


// Clean up before our window quits (called by ConnectionWindow).
void
ConnectionView::CleanUp()
{
	fListener.StopWatchingInterface();
	fListener.StopWatchingManager();
}


BString
ConnectionView::AttemptString() const
{
	PPPInterface interface(fListener.Interface());
	ppp_interface_info_t info;
	if(!interface.GetInterfaceInfo(&info))
		return BString("");
	BString attempt;
	attempt << "Attempt " << info.info.connectAttempt << " of " <<
		info.info.connectRetriesLimit + 1;
	
	return attempt;
}


void
ConnectionView::HandleReportMessage(BMessage *message)
{
	ppp_interface_id id;
	if(message->FindInt32("interface", reinterpret_cast<int32*>(&id)) != B_OK
			|| (fListener.Interface() != PPP_UNDEFINED_INTERFACE_ID
				&& id != fListener.Interface()))
		return;
	
	int32 type, code;
	message->FindInt32("type", &type);
	message->FindInt32("code", &code);
	
	if(type == PPP_MANAGER_REPORT && code == PPP_REPORT_INTERFACE_CREATED) {
		PPPInterface interface(id);
		if(interface.InitCheck() != B_OK || fInterfaceName != interface.Name())
			return;
		
		WatchInterface(id);
		
		if(((fHasUsername && !fHasPassword) || fAskBeforeConnecting)
				&& Window()->IsHidden())
			Window()->Show();
	} else if(type == PPP_CONNECTION_REPORT)
		UpdateStatus(code);
	else if(type == PPP_DESTRUCTION_REPORT)
		fListener.StopWatchingInterface();
}


void
ConnectionView::UpdateStatus(int32 code)
{
	BString attemptString = AttemptString();
	fAttemptView->SetText(attemptString.String());
	
	if(code == PPP_REPORT_UP_SUCCESSFUL) {
		fStatusView->SetText(kTextConnectionEstablished);
		PPPDeskbarReplicant *item = new PPPDeskbarReplicant(fListener.Interface());
		BDeskbar().AddItem(item);
		delete item;
		Window()->Quit();
		return;
	}
	
	// maybe the status string must not be changed (codes that set fKeepLabel to false
	// should still be handled)
	if(fKeepLabel && code != PPP_REPORT_GOING_UP && code != PPP_REPORT_UP_SUCCESSFUL)
		return;
	
	if(fListener.InitCheck() != B_OK) {
		fStatusView->SetText(kTextConnectionLost);
		return;
	}
	
	// only errors should set fKeepLabel to true
	switch(code) {
		case PPP_REPORT_GOING_UP:
			fKeepLabel = false;
			fStatusView->SetText(kTextConnecting);
		break;
		
		case PPP_REPORT_DOWN_SUCCESSFUL:
			fStatusView->SetText(kTextNotConnected);
		break;
		
		case PPP_REPORT_DEVICE_UP_FAILED:
			fKeepLabel = true;
			fStatusView->SetText(kTextDeviceUpFailed);
		break;
		
		case PPP_REPORT_AUTHENTICATION_REQUESTED:
			fStatusView->SetText(kTextAuthenticating);
		break;
		
		case PPP_REPORT_AUTHENTICATION_FAILED:
			fKeepLabel = true;
			fStatusView->SetText(kTextAuthenticationFailed);
		break;
		
		case PPP_REPORT_CONNECTION_LOST:
			fKeepLabel = true;
			fStatusView->SetText(kTextConnectionLost);
		break;
	}
}


void
ConnectionView::WatchInterface(ppp_interface_id ID)
{
	fListener.WatchInterface(ID);
	
	// update status
	Reload();
	PPPInterface interface(fListener.Interface());
	ppp_interface_info_t info;
	if(!interface.GetInterfaceInfo(&info)) {
		UpdateStatus(PPP_REPORT_DOWN_SUCCESSFUL);
		fAskBeforeConnecting = false;
	} else
		fAskBeforeConnecting = info.info.askBeforeConnecting;
}