diff --git a/src/bin/Jamfile b/src/bin/Jamfile index 32323e3e86..48a68d1f53 100644 --- a/src/bin/Jamfile +++ b/src/bin/Jamfile @@ -141,6 +141,7 @@ SubInclude OBOS_TOP src bin rcs ; SubInclude OBOS_TOP src bin arp ; SubInclude OBOS_TOP src bin ifconfig ; SubInclude OBOS_TOP src bin pppconfig ; +SubInclude OBOS_TOP src bin ppp_up ; SubInclude OBOS_TOP src bin ping ; SubInclude OBOS_TOP src bin route ; SubInclude OBOS_TOP src bin traceroute ; diff --git a/src/bin/ppp_up/ConnectionView.cpp b/src/bin/ppp_up/ConnectionView.cpp new file mode 100644 index 0000000000..8e033141de --- /dev/null +++ b/src/bin/ppp_up/ConnectionView.cpp @@ -0,0 +1,373 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "ConnectionView.h" +#include "PPPDeskbarReplicant.h" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + // for 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) +{ + SetViewColor(ui_color(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)); + Window()->SetDefaultButton(fConnectButton); + + 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())); + + 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, ¶meter, ¶meterIndex) + && parameter.FindString(MDSU_VALUES, &username) == B_OK) + fHasUsername = true; + + parameterIndex = 0; + if(FindMessageParameter(PPP_PASSWORD_KEY, fSettings, ¶meter, ¶meterIndex) + && 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, ¶meter, &index)) + fSettings.RemoveData(MDSU_PARAMETERS, index); + parameter.MakeEmpty(); + parameter.AddString(MDSU_NAME, PPP_USERNAME_KEY); + parameter.AddString(MDSU_VALUES, Username()); + fSettings.AddMessage(MDSU_PARAMETERS, ¶meter); + + index = 0; + if(FindMessageParameter(PPP_PASSWORD_KEY, fSettings, ¶meter, &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, ¶meter); + } + + 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(&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; +} diff --git a/src/bin/ppp_up/ConnectionView.h b/src/bin/ppp_up/ConnectionView.h new file mode 100644 index 0000000000..41cb10fdff --- /dev/null +++ b/src/bin/ppp_up/ConnectionView.h @@ -0,0 +1,61 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef CONNECTION_VIEW__H +#define CONNECTION_VIEW__H + +#include +#include +#include + +#include + +class BButton; +class BStringView; + + +class ConnectionView : public BView { + friend class ConnectionWindow; + + public: + ConnectionView(BRect rect, const BString& interfaceName); + + virtual void AttachedToWindow(); + virtual void MessageReceived(BMessage *message); + + const char *Username() const + { return fUsername->Text(); } + const char *Password() const + { return fPassword->Text(); } + bool DoesSavePassword() const + { return fSavePassword->Value(); } + + private: + void Reload(); + + void Connect(); + void Cancel(); + void CleanUp(); + + BString AttemptString() const; + void HandleReportMessage(BMessage *message); + void UpdateStatus(int32 code); + void WatchInterface(ppp_interface_id ID); + + private: + PPPInterfaceListener fListener; + BString fInterfaceName; + + BTextControl *fUsername, *fPassword; + BCheckBox *fSavePassword; + BStringView *fAttemptView, *fStatusView; + BButton *fConnectButton, *fCancelButton; + + BMessage fSettings; + bool fKeepLabel, fHasUsername, fHasPassword, fAskBeforeConnecting; +}; + + +#endif diff --git a/src/bin/ppp_up/ConnectionWindow.cpp b/src/bin/ppp_up/ConnectionWindow.cpp new file mode 100644 index 0000000000..d58183a465 --- /dev/null +++ b/src/bin/ppp_up/ConnectionWindow.cpp @@ -0,0 +1,31 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "ConnectionWindow.h" + +#include +#include + + +ConnectionWindow::ConnectionWindow(BRect frame, const BString& interfaceName) + : BWindow(frame, "", B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE, + B_ALL_WORKSPACES) +{ + BString title("Connecting to "); + title << "\"" << interfaceName << "\"..."; + SetTitle(title.String()); + fConnectionView = new ConnectionView(Bounds(), interfaceName); + AddChild(fConnectionView); +} + + +bool +ConnectionWindow::QuitRequested() +{ + fConnectionView->CleanUp(); + be_app->PostMessage(B_QUIT_REQUESTED); + + return true; +} diff --git a/src/bin/ppp_up/ConnectionWindow.h b/src/bin/ppp_up/ConnectionWindow.h new file mode 100644 index 0000000000..2cd1d1b818 --- /dev/null +++ b/src/bin/ppp_up/ConnectionWindow.h @@ -0,0 +1,24 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef CONNECTION_WINDOW__H +#define CONNECTION_WINDOW__H + +#include +#include "ConnectionView.h" + + +class ConnectionWindow : public BWindow { + public: + ConnectionWindow(BRect frame, const BString& interfaceName); + + virtual bool QuitRequested(); + + private: + ConnectionView *fConnectionView; +}; + + +#endif diff --git a/src/bin/ppp_up/Jamfile b/src/bin/ppp_up/Jamfile new file mode 100644 index 0000000000..c34f9f1234 --- /dev/null +++ b/src/bin/ppp_up/Jamfile @@ -0,0 +1,27 @@ +SubDir OBOS_TOP src bin ppp_up ; + +UsePrivateHeaders net ; +UseHeaders [ FDirName $(OBOS_TOP) src add-ons kernel network ppp shared libppp headers ] ; +UseHeaders [ FDirName $(OBOS_TOP) src add-ons kernel network ppp shared libkernelppp headers ] ; + +AddResources ppp_up : ppp_up.rdef ; + +BinCommand ppp_up : + ConnectionView.cpp + ConnectionWindow.cpp + PPPDeskbarReplicant.cpp + PPPStatusView.cpp + PPPStatusWindow.cpp + PPPUpApplication.cpp +; + +LinkSharedOSLibs ppp_up : libppp.a be ; + +# Installation +OBOSInstall install-networking + : /boot/beos/bin + : ppp_up ; + +Package haiku-networkingkit-cvs : + ppp_up : + boot beos bin ; diff --git a/src/bin/ppp_up/PPPDeskbarReplicant.cpp b/src/bin/ppp_up/PPPDeskbarReplicant.cpp new file mode 100644 index 0000000000..48b071efd2 --- /dev/null +++ b/src/bin/ppp_up/PPPDeskbarReplicant.cpp @@ -0,0 +1,155 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "PPPDeskbarReplicant.h" + +#include "PPPUpApplication.h" +#include "PPPStatusWindow.h" +#include + +#include +#include +#include +#include + + +// message constants +static const uint32 kMsgDisconnect = 'DISC'; +static const uint32 kMsgStatus = 'STAT'; + +// labels +static const char *kLabelDisconnect = "Disconnect"; +static const char *kLabelStatus = "Status"; + + +PPPDeskbarReplicant::PPPDeskbarReplicant(ppp_interface_id id) + : BView(BRect(0, 0, 15, 15), "PPPDeskbarReplicant", B_FOLLOW_NONE, 0), + fID(id) +{ + Init(); +} + + +PPPDeskbarReplicant::PPPDeskbarReplicant(BMessage *message) + : BView(BRect(0, 0, 15, 15), "PPPDeskbarReplicant", B_FOLLOW_NONE, 0) +{ + message->FindInt32("interface", reinterpret_cast(&fID)); + Init(); +} + + +PPPDeskbarReplicant::~PPPDeskbarReplicant() +{ + delete fContextMenu; + + fWindow->LockLooper(); + fWindow->Quit(); +} + + +PPPDeskbarReplicant* +PPPDeskbarReplicant::Instantiate(BMessage *data) +{ + if(!validate_instantiation(data, "PPPDeskbarReplicant")) + return NULL; + + return new PPPDeskbarReplicant(data); +} + + +status_t +PPPDeskbarReplicant::Archive(BMessage *data, bool deep = true) const +{ + BView::Archive(data, deep); + + data->AddString("add_on", APP_SIGNATURE); + data->AddInt32("interface", fID); + return B_NO_ERROR; +} + + +void +PPPDeskbarReplicant::AttachedToWindow() +{ + BMenuItem *item = new BMenuItem(kLabelDisconnect, new BMessage(kMsgDisconnect)); + item->SetTarget(fWindow->StatusView()); + fContextMenu->AddItem(item); + fContextMenu->AddSeparatorItem(); + item = new BMenuItem(kLabelStatus, new BMessage(kMsgStatus)); + item->SetTarget(this); + fContextMenu->AddItem(item); +} + + +void +PPPDeskbarReplicant::MessageReceived(BMessage *message) +{ + switch(message->what) { + case PPP_REPORT_MESSAGE: { + int32 type; + message->FindInt32("type", &type); + if(type == PPP_DESTRUCTION_REPORT) + BDeskbar().RemoveItem(Name()); + } break; + + case kMsgStatus: + fWindow->Show(); + break; + + default: + BView::MessageReceived(message); + } +} + + +void +PPPDeskbarReplicant::MouseDown(BPoint point) +{ + Looper()->CurrentMessage()->FindInt32("buttons", &fLastButtons); + + if(fLastButtons & B_SECONDARY_MOUSE_BUTTON) { + ConvertToScreen(&point); + fContextMenu->Go(point, true, true, true); + } +} + + +void +PPPDeskbarReplicant::MouseUp(BPoint point) +{ + if(fLastButtons & B_PRIMARY_MOUSE_BUTTON) { + // TODO: center on screen +// fWindow->MoveTo(center_on_screen(fWindow->Frame(), fWindow)); + fWindow->Show(); + } +} + + +void +PPPDeskbarReplicant::Draw(BRect updateRect) +{ + // TODO: I want a nice blinking icon! + MovePenTo(4, 12); + DrawString("P"); +} + + +void +PPPDeskbarReplicant::Init() +{ + BString name("PPPDeskbarReplicant"); + name << fID; + SetName(name.String()); + + BRect rect(50,50,380,150); + fWindow = new PPPStatusWindow(rect, fID); + + fContextMenu = new BPopUpMenu("PPPContextMenu", false); + + // watch interface destruction + PPPInterface interface(fID); + if(interface.InitCheck() != B_OK) + return; +} diff --git a/src/bin/ppp_up/PPPDeskbarReplicant.h b/src/bin/ppp_up/PPPDeskbarReplicant.h new file mode 100644 index 0000000000..2c6cb27245 --- /dev/null +++ b/src/bin/ppp_up/PPPDeskbarReplicant.h @@ -0,0 +1,44 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef PPP_DESKBAR_REPLICANT__H +#define PPP_DESKBAR_REPLICANT__H + +#include +#include + +class BPopUpMenu; +class PPPStatusWindow; + + +class PPPDeskbarReplicant : public BView { + public: + PPPDeskbarReplicant(ppp_interface_id id); + PPPDeskbarReplicant(BMessage *message); + virtual ~PPPDeskbarReplicant(); + + static PPPDeskbarReplicant *Instantiate(BMessage *data); + virtual status_t Archive(BMessage *data, bool deep = true) const; + + virtual void AttachedToWindow(); + virtual void MessageReceived(BMessage *message); + + virtual void MouseDown(BPoint point); + virtual void MouseUp(BPoint point); + + virtual void Draw(BRect updateRect); + + private: + void Init(); + + private: + PPPStatusWindow *fWindow; + BPopUpMenu *fContextMenu; + ppp_interface_id fID; + int32 fLastButtons; +}; + + +#endif diff --git a/src/bin/ppp_up/PPPStatusView.cpp b/src/bin/ppp_up/PPPStatusView.cpp new file mode 100644 index 0000000000..9be30d0e15 --- /dev/null +++ b/src/bin/ppp_up/PPPStatusView.cpp @@ -0,0 +1,176 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "PPPStatusView.h" + +#include +#include +#include +#include + +#include +#include + +#include + + +// message constants +static const uint32 kMsgDisconnect = 'DISC'; + +// labels +static const char *kLabelDisconnect = "Disconnect"; +static const char *kLabelConnectedSince = "Connected Since: "; +static const char *kLabelReceived = "Received"; +static const char *kLabelSent = "Sent"; + +// strings +static const char *kTextBytes = "Bytes"; +static const char *kTextPackets = "Packets"; + + +PPPStatusView::PPPStatusView(BRect rect, ppp_interface_id id) + : BView(rect, "PPPStatusView", B_FOLLOW_NONE, B_PULSE_NEEDED), + fInterface(id) +{ + SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); + + rect = Bounds(); + rect.InsetBy(5, 5); + rect.left = rect.right - 80; + rect.bottom = rect.top + 25; + fButton = new BButton(rect, "DisconnectButton", kLabelDisconnect, + new BMessage(kMsgDisconnect)); + + rect.right = rect.left - 10; + rect.left = rect.right - 80; + rect.top += 5; + rect.bottom = rect.top + 15; + fTime = new BStringView(rect, "Time", ""); + fTime->SetAlignment(B_ALIGN_RIGHT); + fTime->SetFont(be_fixed_font); + rect.right = rect.left - 10; + rect.left = 5; + BStringView *connectedSince = new BStringView(rect, "ConnectedSince", + kLabelConnectedSince); + connectedSince->SetFont(be_fixed_font); + + rect = Bounds(); + rect.InsetBy(5, 5); + rect.top += 35; + rect.right = rect.left + (rect.Width() - 5) / 2; + BBox *received = new BBox(rect, "Received"); + received->SetLabel(kLabelReceived); + rect = received->Bounds(); + rect.InsetBy(10, 15); + rect.bottom = rect.top + 15; + fBytesReceived = new BStringView(rect, "BytesReceived", ""); + fBytesReceived->SetAlignment(B_ALIGN_RIGHT); + fBytesReceived->SetFont(be_fixed_font); + rect.top = rect.bottom + 5; + rect.bottom = rect.top + 15; + fPacketsReceived = new BStringView(rect, "PacketsReceived", ""); + fPacketsReceived->SetAlignment(B_ALIGN_RIGHT); + fPacketsReceived->SetFont(be_fixed_font); + + rect = received->Frame(); + rect.OffsetBy(rect.Width() + 5, 0); + BBox *sent = new BBox(rect, "sent"); + sent->SetLabel(kLabelSent); + rect = received->Bounds(); + rect.InsetBy(10, 15); + rect.bottom = rect.top + 15; + fBytesSent = new BStringView(rect, "BytesSent", ""); + fBytesSent->SetAlignment(B_ALIGN_RIGHT); + fBytesSent->SetFont(be_fixed_font); + rect.top = rect.bottom + 5; + rect.bottom = rect.top + 15; + fPacketsSent = new BStringView(rect, "PacketsSent", ""); + fPacketsSent->SetAlignment(B_ALIGN_RIGHT); + fPacketsSent->SetFont(be_fixed_font); + + received->AddChild(fBytesReceived); + received->AddChild(fPacketsReceived); + sent->AddChild(fBytesSent); + sent->AddChild(fPacketsSent); + + AddChild(fButton); + AddChild(fTime); + AddChild(connectedSince); + AddChild(received); + AddChild(sent); + + ppp_interface_info_t info; + fInterface.GetInterfaceInfo(&info); + fConnectedSince = info.info.connectedSince; +} + + +void +PPPStatusView::AttachedToWindow() +{ + fButton->SetTarget(this); + Window()->SetTitle(fInterface.Name()); +} + + +void +PPPStatusView::MessageReceived(BMessage *message) +{ + switch(message->what) { + case kMsgDisconnect: + fInterface.Down(); + Window()->Hide(); + break; + + default: + BView::MessageReceived(message); + } +} + + +void +PPPStatusView::Pulse() +{ + // update status + ppp_statistics statistics; + if(!fInterface.GetStatistics(&statistics)) { + fBytesReceived->SetText(""); + fPacketsReceived->SetText(""); + fBytesSent->SetText(""); + fPacketsSent->SetText(""); + return; + } + + BString text; + bigtime_t time = system_time() - fConnectedSince; + time /= 1000000; + int32 seconds = time % 60; + time /= 60; + int32 minutes = time % 60; + int32 hours = time / 60; + char minsec[7]; + if(hours) { + sprintf(minsec, ":%02ld:%02ld", minutes, seconds); + text << hours << minsec; + } else if(minutes) { + sprintf(minsec, "%ld:%02ld", minutes, seconds); + text << minsec; + } else + text << seconds; + fTime->SetText(text.String()); + + text = ""; + text << statistics.bytesReceived << ' ' << kTextBytes; + fBytesReceived->SetText(text.String()); + text = ""; + text << statistics.packetsReceived << ' ' << kTextPackets; + fPacketsReceived->SetText(text.String()); + text = ""; + text << statistics.bytesSent << ' ' << kTextBytes; + fBytesSent->SetText(text.String()); + text = ""; + text << statistics.packetsSent << ' ' << kTextPackets; + fPacketsSent->SetText(text.String()); +} diff --git a/src/bin/ppp_up/PPPStatusView.h b/src/bin/ppp_up/PPPStatusView.h new file mode 100644 index 0000000000..8463f5c244 --- /dev/null +++ b/src/bin/ppp_up/PPPStatusView.h @@ -0,0 +1,30 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef STATUS_VIEW__H +#define STATUS_VIEW__H + +#include +#include + + +class PPPStatusView : public BView { + public: + PPPStatusView(BRect rect, ppp_interface_id id); + + virtual void AttachedToWindow(); + virtual void MessageReceived(BMessage *message); + virtual void Pulse(); + + private: + BButton *fButton; + BStringView *fTime; + BStringView *fBytesReceived, *fBytesSent, *fPacketsReceived, *fPacketsSent; + bigtime_t fConnectedSince; + PPPInterface fInterface; +}; + + +#endif diff --git a/src/bin/ppp_up/PPPStatusWindow.cpp b/src/bin/ppp_up/PPPStatusWindow.cpp new file mode 100644 index 0000000000..d5c730b0ce --- /dev/null +++ b/src/bin/ppp_up/PPPStatusWindow.cpp @@ -0,0 +1,26 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "PPPStatusWindow.h" + + +PPPStatusWindow::PPPStatusWindow(BRect frame, ppp_interface_id id) + : BWindow(frame, "", B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE, + B_ALL_WORKSPACES) +{ + SetPulseRate(1000000); + + fStatusView = new PPPStatusView(Bounds(), id); + AddChild(fStatusView); +} + + +bool +PPPStatusWindow::QuitRequested() +{ + // only the replicant may delete this window! + Hide(); + return false; +} diff --git a/src/bin/ppp_up/PPPStatusWindow.h b/src/bin/ppp_up/PPPStatusWindow.h new file mode 100644 index 0000000000..121204a56f --- /dev/null +++ b/src/bin/ppp_up/PPPStatusWindow.h @@ -0,0 +1,27 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef STATUS_WINDOW__H +#define STATUS_WINDOW__H + +#include +#include "PPPStatusView.h" + + +class PPPStatusWindow : public BWindow { + public: + PPPStatusWindow(BRect frame, ppp_interface_id id); + + PPPStatusView *StatusView() + { return fStatusView; } + + virtual bool QuitRequested(); + + private: + PPPStatusView *fStatusView; +}; + + +#endif diff --git a/src/bin/ppp_up/PPPUpApplication.cpp b/src/bin/ppp_up/PPPUpApplication.cpp new file mode 100644 index 0000000000..006ab1be75 --- /dev/null +++ b/src/bin/ppp_up/PPPUpApplication.cpp @@ -0,0 +1,42 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#include "PPPUpApplication.h" +#include "ConnectionWindow.h" + +#include +#include + + +int +main(int argc, const char *argv[]) +{ + if(argc != 2) + return -1; + + const char *interfaceName = argv[1]; + + new PPPUpApplication(interfaceName); + be_app->Run(); + delete be_app; + + return 0; +} + + +PPPUpApplication::PPPUpApplication(const char *interfaceName) + : BApplication(APP_SIGNATURE), + fInterfaceName(interfaceName) +{ +} + + +void +PPPUpApplication::ReadyToRun() +{ + BRect rect(150, 50, 450, 435); + // TODO: center rect on screen + (new ConnectionWindow(rect, fInterfaceName))->Run(); +} diff --git a/src/bin/ppp_up/PPPUpApplication.h b/src/bin/ppp_up/PPPUpApplication.h new file mode 100644 index 0000000000..1972affec8 --- /dev/null +++ b/src/bin/ppp_up/PPPUpApplication.h @@ -0,0 +1,29 @@ +/* + * Copyright 2005, Waldemar Kornewald + * Distributed under the terms of the MIT License. + */ + +#ifndef PPP_UP_APPLICATION__H +#define PPP_UP_APPLICATION__H + +#include +#include +#include + +class ConnectionWindow; + +#define APP_SIGNATURE "application/x-vnd.haiku.ppp_up" + + +class PPPUpApplication : public BApplication { + public: + PPPUpApplication(const char *interfaceName); + + virtual void ReadyToRun(); + + private: + BString fInterfaceName; +}; + + +#endif diff --git a/src/bin/ppp_up/ppp_up.rdef b/src/bin/ppp_up/ppp_up.rdef new file mode 100644 index 0000000000..61654e33c8 --- /dev/null +++ b/src/bin/ppp_up/ppp_up.rdef @@ -0,0 +1,37 @@ +/* + ppp_up.rdef +*/ + +resource app_signature "application/x-vnd.haiku.ppp_up"; + +/* BEOS:APP_FLAGS : + 00000000 = SINGLE LAUNCH + 00000001 = MULTIPLE LAUNCH + 00000002 = EXCLUSIVE LAUNCH + 00000004 = BACKGROUND APP + SINGLE LAUNCH + 00000005 = BACKGROUND APP + MULTIPLE LAUNCH + 00000006 = BACKGROUND APP + EXCLUSIVE LAUNCH + 00000008 = ARGV_ONLY + SINGLE LAUNCH + 00000009 = ARGV_ONLY + MULTIPLE LAUNCH + 0000000A = ARGV_ONLY + EXCLUSIVE LAUNCH + 0000000C = ARGV_ONLY + BACKGROUND APP + SINGLE LAUNCH + 0000000D = ARGV_ONLY + BACKGROUND APP + MULTIPLE LAUNCH + 0000000E = ARGV_ONLY + BACKGROUND APP + EXCLUSIVE LAUNCH +*/ + +resource app_flags 0x00000005; + +resource app_version { + major = 0, + middle = 1, + minor = 0, + + /* 0 = development 1 = alpha 2 = beta + 3 = gamma 4 = golden master 5 = final */ + variety = 0, + + internal = 0, + + short_info = "ppp_up", + long_info = "PPP interface GUI initialization app." +};