OPKG-Manager: add opkg manager feature

Signed-off-by: Markus Volk <f_l_k@gmx.net>
Signed-off-by: Thilo Graf <dbt@novatux.de>

Opkg is a lightweight package management system based on Ipkg.

For usage with Neutrino, installed opkg programms opkg-cl and opkg-key
are required and can be find in service update menu,
otherwise this feature is not available.

With this feature it is possible to select packages for install and remove
via gui-menu.

See also:
OPKG-Website
- http://bitbucket.org/opkg/opkg for more details.

Tuxbox:
- http://wiki.tuxbox.org/Neutrino-MP Entwicklungsumgebung#OPKG-Pakete
- http://wiki.tuxbox.org.Neutrino-HD Entwicklungsumgebung:OPKG-SystemInstall

Buildsystems with opkg support:
- http://gitorious.org/neutrino-hd/buildsystem-cs
- http://sourceforge.net/p/bstuff/bs4cs/
- Yocto

OPKG-Manager Neutrino:
- picked from http://gitorious.org/neutrino-mp/martiis-neutrino-mp include shellwindow feature by martii
- update License text
- add missing icon
- use macros to get opkg binaries
- use matching buttons in footer, menu button is already reserved to left menu

src/gui/Makefile.am

@@ -81,6 +81,7 @@ libneutrino_gui_a_SOURCES = \
 	network_service.cpp \
 	network_setup.cpp \
 	nfs.cpp \
+	opkg_manager.cpp \
 	osd_progressbar_setup.cpp \
 	osd_setup.cpp \
 	osdlang_setup.cpp \

src/gui/opkg_manager.cpp

@@ -0,0 +1,380 @@
+/*
+	Based up Neutrino-GUI - Tuxbox-Project
+	Copyright (C) 2001 by Steffen Hehn 'McClean'
+
+	OPKG-Manager Class for Neutrino-GUI
+
+	Implementation:
+	Copyright (C) 2012 T. Graf 'dbt'
+	www.dbox2-tuning.net
+
+	Adaptions:
+	Copyright (C) 2013 martii
+	gitorious.org/neutrino-mp/martiis-neutrino-mp
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public
+	License as published by the Free Software Foundation; either
+	version 2 of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gui/opkg_manager.h>
+
+#include <global.h>
+#include <neutrino.h>
+#include <neutrino_menue.h>
+
+#include <gui/widget/icons.h>
+#include <gui/widget/messagebox.h>
+#include <gui/widget/shellwindow.h>
+#include <driver/screen_max.h>
+
+#include <system/debug.h>
+#include <system/helpers.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <alloca.h>
+
+#define OPKG_CL find_executable("opkg-cl")
+#define OPKG_KEY find_executable("opkg-key")
+
+enum
+{
+	OM_LIST,
+	OM_LIST_INSTALLED,
+	OM_LIST_UPGRADEABLE,
+	OM_UPDATE,
+	OM_UPGRADE,
+	OM_REMOVE,
+	OM_INFO,
+	OM_INSTALL,
+	OM_MAX
+};
+
+static const std::string pkg_types[OM_MAX] =
+{
+	OPKG_CL + " list",
+	OPKG_CL + " list-installed",
+	OPKG_CL + " list-upgradable",
+	OPKG_CL + " update",
+	OPKG_CL + " upgrade ",
+	OPKG_CL + " remove ",
+	OPKG_CL + " info ",
+	OPKG_CL + " install "
+};
+
+COPKGManager::COPKGManager()
+{
+	width = w_max (40, 10); //%
+	frameBuffer = CFrameBuffer::getInstance();
+	pkg_map.clear();
+	list_installed_done = false;
+	list_upgradeable_done = false;
+	expert_mode = false;
+}
+
+COPKGManager::~COPKGManager()
+{
+}
+
+int COPKGManager::exec(CMenuTarget* parent, const std::string &actionKey)
+{
+	int res = menu_return::RETURN_REPAINT;
+
+	if (actionKey == "") {
+		if (parent)
+			parent->hide();
+		return showMenu();
+	}
+	int selected = menu->getSelected() - menu_offset;
+
+	if (expert_mode && actionKey == "rc_blue") {
+		if (selected < 0 || selected >= (int) pkg_vec.size() || !pkg_vec[selected]->installed)
+			return menu_return::RETURN_NONE;
+
+		char loc[200];
+		snprintf(loc, sizeof(loc), g_Locale->getText(LOCALE_OPKG_MESSAGEBOX_REMOVE), pkg_vec[selected]->name.c_str());
+		if (ShowMsg(LOCALE_OPKG_TITLE, loc, CMessageBox::mbrCancel, CMessageBox::mbYes | CMessageBox::mbCancel) != CMessageBox::mbrCancel) {
+			if (parent)
+				parent->hide();
+			execCmd(pkg_types[OM_REMOVE] + pkg_vec[selected]->name, true, true);
+			refreshMenu();
+		}
+		return res;
+	}
+	if (actionKey == "rc_info") {
+		if (selected < 0 || selected >= (int) pkg_vec.size())
+			return menu_return::RETURN_NONE;
+		if (parent)
+			parent->hide();
+		execCmd(pkg_types[OM_INFO] + pkg_vec[selected]->name, true, true);
+		return res;
+	}
+	if (actionKey == "rc_red") {
+		expert_mode = !expert_mode;
+		updateMenu();
+		return res;
+	}
+	if(actionKey == pkg_types[OM_UPGRADE]) {
+		if (parent)
+			parent->hide();
+		int r = execCmd(actionKey, true, true);
+		if (r) {
+			std::string loc = g_Locale->getText(LOCALE_OPKG_FAILURE_UPGRADE);
+			char rs[strlen(loc.c_str()) + 20];
+			snprintf(rs, sizeof(rs), loc.c_str(), r);
+			DisplayInfoMessage(rs);
+		} else
+			installed = true;
+		refreshMenu();
+		g_RCInput->postMsg((neutrino_msg_t) CRCInput::RC_up, 0);
+		return res;
+	}
+
+	std::map<string, struct pkg>::iterator it = pkg_map.find(actionKey);
+	if (it != pkg_map.end()) {
+		if (parent)
+			parent->hide();
+		std::string force = "";
+		if (it->second.installed && !it->second.upgradable) {
+			char l[200];
+			snprintf(l, sizeof(l), g_Locale->getText(LOCALE_OPKG_MESSAGEBOX_REINSTALL), actionKey.c_str());
+			l[sizeof(l) - 1] = 0;
+			if (ShowMsg(LOCALE_OPKG_TITLE, l, CMessageBox::mbrCancel, CMessageBox::mbYes | CMessageBox::mbCancel) == CMessageBox::mbrCancel)
+				return res;
+			force = "--force-reinstall ";
+		}
+		int r = execCmd(pkg_types[OM_INSTALL] + force + actionKey, true, true);
+		if (r) {
+			std::string err = g_Locale->getText(LOCALE_OPKG_FAILURE_INSTALL);
+			char rs[strlen(err.c_str()) + 20];
+			snprintf(rs, sizeof(rs), err.c_str(), r);
+			DisplayInfoMessage(rs);
+		} else
+				installed = true;
+		refreshMenu();
+	}
+	return res;
+}
+
+#define COPKGManagerFooterButtonCount 3
+static const struct button_label COPKGManagerFooterButtons[COPKGManagerFooterButtonCount] = {
+	{ NEUTRINO_ICON_BUTTON_RED, LOCALE_OPKG_BUTTON_EXPERT_ON },
+	{ NEUTRINO_ICON_BUTTON_INFO_SMALL, LOCALE_OPKG_BUTTON_INFO },
+	{ NEUTRINO_ICON_BUTTON_OKAY,	   LOCALE_OPKG_BUTTON_INSTALL }
+};
+#define COPKGManagerFooterButtonCountExpert 4
+static const struct button_label COPKGManagerFooterButtonsExpert[COPKGManagerFooterButtonCountExpert] = {
+	{ NEUTRINO_ICON_BUTTON_RED, LOCALE_OPKG_BUTTON_EXPERT_OFF },
+	{ NEUTRINO_ICON_BUTTON_INFO_SMALL, LOCALE_OPKG_BUTTON_INFO },
+	{ NEUTRINO_ICON_BUTTON_OKAY,	   LOCALE_OPKG_BUTTON_INSTALL },
+	{ NEUTRINO_ICON_BUTTON_BLUE, LOCALE_OPKG_BUTTON_UNINSTALL }
+};
+
+void COPKGManager::updateMenu()
+{
+	bool upgradesAvailable = false;
+	getPkgData(OM_LIST_INSTALLED);
+	getPkgData(OM_LIST_UPGRADEABLE);
+	for (std::map<string, struct pkg>::iterator it = pkg_map.begin(); it != pkg_map.end(); it++) {
+		it->second.forwarder->iconName_Info_right = "";
+		it->second.forwarder->setActive(true);
+		if (it->second.upgradable) {
+			it->second.forwarder->iconName_Info_right = NEUTRINO_ICON_WARNING;
+			upgradesAvailable = true;
+		} else if (it->second.installed) {
+			it->second.forwarder->iconName_Info_right = NEUTRINO_ICON_CHECKMARK;
+			it->second.forwarder->setActive(expert_mode);
+		}
+	}
+
+	upgrade_forwarder->setActive(upgradesAvailable);
+
+	if (expert_mode)
+		menu->setFooter(COPKGManagerFooterButtonsExpert, COPKGManagerFooterButtonCountExpert);
+	else
+		menu->setFooter(COPKGManagerFooterButtons, COPKGManagerFooterButtonCount);
+}
+
+void COPKGManager::refreshMenu() {
+	list_installed_done = false,
+	list_upgradeable_done = false;
+	updateMenu();
+}
+
+int COPKGManager::showMenu()
+{
+	installed = false;
+
+	int r = execCmd(pkg_types[OM_UPDATE]);
+	if (r) {
+		std::string loc = g_Locale->getText(LOCALE_OPKG_FAILURE_UPDATE);
+		char rs[strlen(loc.c_str()) + 20];
+		snprintf(rs, sizeof(rs), loc.c_str(), r);
+		DisplayInfoMessage(rs);
+	}
+
+	getPkgData(OM_LIST);
+	getPkgData(OM_LIST_UPGRADEABLE);
+
+	menu = new CMenuWidget(g_Locale->getText(LOCALE_OPKG_TITLE), NEUTRINO_ICON_UPDATE, width, MN_WIDGET_ID_SOFTWAREUPDATE);
+	CMenuForwarder menuBack(LOCALE_MENU_BACK, true, NULL, NULL, NULL, CRCInput::RC_nokey, NEUTRINO_ICON_BUTTON_LEFT, NULL, true);
+	menuBack.setItemButton(!g_settings.menu_left_exit ? NEUTRINO_ICON_BUTTON_HOME : NEUTRINO_ICON_BUTTON_LEFT);
+	menu->addItem(&menuBack);
+	menuBack.setHint(NEUTRINO_ICON_HINT_BACK, LOCALE_MENU_HINT_BACK_BRIEF);
+	menu->addItem(GenericMenuSeparatorLine);
+
+	upgrade_forwarder = new CMenuForwarder(LOCALE_OPKG_UPGRADE, true, NULL , this, pkg_types[OM_UPGRADE].c_str(), CRCInput::RC_red);
+	upgrade_forwarder->setHint(NEUTRINO_ICON_HINT_SW_UPDATE, LOCALE_MENU_HINT_OPKG_UPGRADE);
+	menu->addItem(upgrade_forwarder);
+	menu->addItem(GenericMenuSeparatorLine);
+
+	menu_offset = menu->getItemsCount();
+
+	menu->addKey(CRCInput::RC_info, this, "rc_info");
+	menu->addKey(CRCInput::RC_blue, this, "rc_blue");
+	menu->addKey(CRCInput::RC_red, this, "rc_red");
+
+	pkg_vec.clear();
+	for (std::map<string, struct pkg>::iterator it = pkg_map.begin(); it != pkg_map.end(); it++) {
+		it->second.forwarder = new CMenuForwarder(it->second.desc, true, NULL , this, it->second.name.c_str());
+		it->second.forwarder->setHint("", it->second.desc);
+		menu->addItem(it->second.forwarder);
+		pkg_vec.push_back(&it->second);
+	}
+
+	updateMenu();
+
+	int res = menu->exec(NULL, "");
+
+	menu->hide ();
+
+	if (installed)
+		DisplayInfoMessage(g_Locale->getText(LOCALE_OPKG_SUCCESS_INSTALL));
+	delete menu;
+	return res;
+}
+
+bool COPKGManager::hasOpkgSupport()
+{
+	string deps[] = {OPKG_CL, OPKG_KEY, "/etc/opkg/opkg.conf", "/var/lib/opkg"};
+
+	for(size_t i=0; i<sizeof(deps)/sizeof(deps[0]) ;i++){
+		dprintf(DEBUG_INFO,  "[neutrino opkg] check if %s is available...\n", deps[i].c_str());
+		if(access(deps[i].c_str(), R_OK) !=0) {
+			dprintf(DEBUG_INFO,  "[neutrino opkg] %s not found\n", deps[i].c_str());
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void COPKGManager::getPkgData(const int pkg_content_id)
+{
+	dprintf(DEBUG_INFO, "COPKGManager: executing %s\n", pkg_types[pkg_content_id].c_str());
+
+	switch (pkg_content_id) {
+		case OM_LIST:
+			pkg_map.clear();
+			list_installed_done = false;
+			list_upgradeable_done = false;
+			break;
+		case OM_LIST_INSTALLED:
+			if (list_installed_done)
+				return;
+			list_installed_done = true;
+			for (std::map<string, struct pkg>::iterator it = pkg_map.begin(); it != pkg_map.end(); it++)
+				it->second.installed = false;
+			break;
+		case OM_LIST_UPGRADEABLE:
+			if (list_upgradeable_done)
+				return;
+			list_upgradeable_done = true;
+			for (std::map<string, struct pkg>::iterator it = pkg_map.begin(); it != pkg_map.end(); it++)
+				it->second.upgradable = false;
+			break;
+	}
+
+	FILE *f = popen(pkg_types[pkg_content_id].c_str(), "r");
+	if (!f) {
+		DisplayInfoMessage("Command failed");
+		return;
+	}
+
+	char buf[256];
+
+	while (fgets(buf, sizeof(buf), f))
+	{
+		std::string line(buf);
+		trim(line);
+
+		std::string name = getBlankPkgName(line);
+
+		switch (pkg_content_id) {
+			case OM_LIST: {
+				pkg_map[name] = pkg(name, line);
+				break;
+			}
+			case OM_LIST_INSTALLED: {
+				std::map<string, struct pkg>::iterator it = pkg_map.find(name);
+				if (it != pkg_map.end())
+					it->second.installed = true;
+				break;
+			}
+			case OM_LIST_UPGRADEABLE: {
+				std::map<string, struct pkg>::iterator it = pkg_map.find(name);
+				if (it != pkg_map.end())
+					it->second.upgradable = true;
+				break;
+			}
+			default:
+				fprintf(stderr, "%s %s %d: unrecognized content id %d\n", __FILE__, __func__, __LINE__, pkg_content_id);
+				break;
+		}
+	}
+
+	pclose(f);
+}
+
+std::string COPKGManager::getBlankPkgName(const std::string& line)
+{
+	size_t l_pos = line.find(" ");
+	if (l_pos != string::npos)
+		return line.substr(0, l_pos);
+	return line;
+}
+
+int COPKGManager::execCmd(const char *cmdstr, bool verbose, bool acknowledge)
+{
+fprintf(stderr, "execCmd(%s)\n", cmdstr);
+	std::string cmd(cmdstr);
+	if (verbose) {
+		cmd += " 2>&1";
+		int res;
+		CShellWindow(cmd, (verbose ? CShellWindow::VERBOSE : 0) | (acknowledge ? CShellWindow::ACKNOWLEDGE : 0), &res);
+		return res;
+	} else {
+		cmd += " 2>/dev/null >&2";
+		int r = system(cmd.c_str());
+		if (r == -1)
+			return r;
+		return WEXITSTATUS(r);
+	}
+}

src/gui/opkg_manager.h

@@ -0,0 +1,88 @@
+/*
+	Based up Neutrino-GUI - Tuxbox-Project
+	Copyright (C) 2001 by Steffen Hehn 'McClean'
+
+	OPKG-Manager Class for Neutrino-GUI
+
+	Implementation:
+	Copyright (C) 2012 T. Graf 'dbt'
+	www.dbox2-tuning.net
+
+	Adaptions:
+	Copyright (C) 2013 martii
+	gitorious.org/neutrino-mp/martiis-neutrino-mp
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public
+	License as published by the Free Software Foundation; either
+	version 2 of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __OPKG_MANAGER__
+#define __OPKG_MANAGER__
+
+#include <gui/widget/menue.h>
+#include <driver/framebuffer.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+class COPKGManager : public CMenuTarget
+{
+	private:
+		int width;
+
+		CFrameBuffer *frameBuffer;
+
+		struct pkg;
+
+		std::map<std::string,pkg> pkg_map;
+		std::vector<pkg*> pkg_vec;
+
+		CMenuWidget *menu;
+		CMenuForwarder *upgrade_forwarder;
+		bool list_installed_done;
+		bool list_upgradeable_done;
+		bool installed;
+		bool expert_mode;
+		int menu_offset;
+
+		int execCmd(const char* cmdstr, bool verbose = false, bool acknowledge = false);
+		int execCmd(std::string cmdstr, bool verbose = false, bool acknowledge = false) {
+			return execCmd(cmdstr.c_str(), verbose, acknowledge);
+		};
+		void getPkgData(const int pkg_content_id);
+		static std::string getBlankPkgName(const std::string& line);
+		int showMenu();
+		void updateMenu();
+		void refreshMenu();
+
+		struct pkg {
+			std::string name;
+			std::string desc;
+			bool installed;
+			bool upgradable;
+			CMenuForwarder *forwarder;
+			pkg() { }
+			pkg(std::string &_name, std::string &_desc)
+				: name(_name), desc(_desc), installed(false), upgradable(false) { }
+		};
+	public:
+		COPKGManager();
+		~COPKGManager();
+
+		int exec(CMenuTarget* parent, const std::string & actionKey);
+		static bool hasOpkgSupport();
+};
+#endif

src/gui/update_menue.cpp

@@ -41,7 +41,7 @@
 
 #include "update_menue.h"
 #include "update_settings.h"
-
+#include "gui/opkg_manager.h"
 #include <gui/widget/icons.h>
 #include <driver/screen_max.h>
 #include <system/debug.h>
@@ -113,7 +113,15 @@ int CSoftwareUpdate::showSoftwareUpdate()
 		mf->setHint("", LOCALE_MENU_HINT_SOFTUPDATE_EXPERT);
 		softUpdate.addItem(mf);
 
+		//firmware update via opkg
+		if (COPKGManager::hasOpkgSupport()) {
+			mf = new CMenuForwarder(LOCALE_OPKG_TITLE, true, NULL, new COPKGManager());
+			mf->setHint(NEUTRINO_ICON_HINT_SW_UPDATE, LOCALE_MENU_HINT_OPKG);
+			softUpdate.addItem(mf);
+		}
+
 	}
+
 #ifdef BOXMODEL_APOLLO
 	softUpdate.addItem(GenericMenuSeparatorLine);
 

src/gui/widget/Makefile.am

@@ -38,6 +38,7 @@ libneutrino_gui_widget_a_SOURCES = \
 	messagebox.cpp \
 	mountchooser.cpp \
 	msgbox.cpp \
+	shellwindow.cpp \
 	stringinput.cpp \
 	stringinput_ext.cpp \
 	textbox.cpp

src/gui/widget/icons.h

@@ -248,6 +248,10 @@
 #define NEUTRINO_ICON_HINT_RESTORE	"hint_restore"
 #define NEUTRINO_ICON_HINT_FACTORY	"hint_factory"
 
+/* opkg manager */
+#define NEUTRINO_ICON_CHECKMARK "checkmark"
+#define NEUTRINO_ICON_WARNING "warning"
+
 /* misc */
 #define NEUTRINO_ICON_HINT_YTPLAY	"hint_ytplay"
 

src/gui/widget/shellwindow.cpp

@@ -0,0 +1,205 @@
+/*
+	Based up Neutrino-GUI - Tuxbox-Project
+	Copyright (C) 2001 by Steffen Hehn 'McClean'
+
+	Shell window class, visualize of system events on gui screen.
+
+	Implementation:
+	Copyright (C) 2013 martii
+	gitorious.org/neutrino-mp/martiis-neutrino-mp
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public
+	License as published by the Free Software Foundation; either
+	version 2 of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+#include "shellwindow.h"
+
+#include <global.h>
+#include <neutrino.h>
+#include <driver/framebuffer.h>
+#include <gui/widget/textbox.h>
+#include <stdio.h>
+#include <poll.h>
+#include <fcntl.h>
+
+CShellWindow::CShellWindow(const std::string &command, const int _mode, int *res) {
+	textBox = NULL;
+	std::string cmd;
+	mode = _mode;
+	if (!(mode & VERBOSE)){
+		cmd = "PATH=/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/usr/local/sbin ; export PATH ; " + command + " 2>/dev/null >&2";
+		int r = system(cmd.c_str());
+		if (res) {
+			if (r == -1)
+				*res = r;
+			else
+				*res = WEXITSTATUS(r);
+		}
+		return;
+	}
+
+	cmd = command + " 2>&1";
+	FILE *f = popen(cmd.c_str(), "r");
+	if (!f) {
+		if (res)
+			*res = -1;
+		return;
+	}
+	Font *font = g_Font[SNeutrinoSettings::FONT_TYPE_GAMELIST_ITEMSMALL];
+	frameBuffer = CFrameBuffer::getInstance();
+	unsigned int lines_max = frameBuffer->getScreenHeight() / font->getHeight();
+	list<std::string> lines;
+	CBox textBoxPosition(frameBuffer->getScreenX(), frameBuffer->getScreenY(), frameBuffer->getScreenWidth(), frameBuffer->getScreenHeight());
+	textBox = new CTextBox(cmd.c_str(), font, CTextBox::BOTTOM, &textBoxPosition);
+	struct pollfd fds;
+	fds.fd = fileno(f);
+	fds.events = POLLIN | POLLHUP | POLLERR;
+	fcntl(fds.fd, F_SETFL, fcntl(fds.fd, F_GETFL, 0) | O_NONBLOCK);
+
+	struct timeval tv;
+	gettimeofday(&tv,NULL);
+	uint64_t lastPaint = (uint64_t) tv.tv_usec + (uint64_t)((uint64_t) tv.tv_sec * (uint64_t) 1000000);
+	bool ok = true, nlseen = false, dirty = false, pushed = false;
+	char output[1024];
+	int off = 0;
+	std::string txt = "";
+
+	do {
+		uint64_t now;
+		fds.revents = 0;
+		int r = poll(&fds, 1, 300);
+
+		if (r > 0) {
+			if (!feof(f)) {
+				gettimeofday(&tv,NULL);
+				now = (uint64_t) tv.tv_usec + (uint64_t)((uint64_t) tv.tv_sec * (uint64_t) 1000000);
+
+				unsigned int lines_read = 0;
+				while (fgets(output + off, sizeof(output) - off, f)) {
+					char *outputp = output + off;
+					dirty = true;
+
+					for (int i = off; output[i] && !nlseen; i++)
+						switch (output[i]) {
+							case '\b':
+								if (outputp > output)
+									outputp--;
+								*outputp = 0;
+								break;
+							case '\r':
+								outputp = output;
+								break;
+							case '\n':
+								lines_read++;
+								nlseen = true;
+								*outputp = 0;
+								break;
+							default:
+								*outputp++ = output[i];
+								break;
+						}
+
+					if (outputp < output + sizeof(output))
+						*outputp = 0;
+					if (nlseen) {
+						pushed = false;
+						nlseen = false;
+						off = 0;
+					} else {
+						off = strlen(output);
+						if (pushed)
+							lines.pop_back();
+					}
+					lines.push_back(std::string((output)));
+					pushed = true;
+					if (lines.size() > lines_max)
+						lines.pop_front();
+					txt = "";
+					bool first = true;
+					for (std::list<std::string>::const_iterator it = lines.begin(), end = lines.end(); it != end; ++it) {
+						if (first)
+							first = false;
+						else
+							txt += '\n';
+						txt += *it;
+					}
+					if (((lines_read == lines_max) && (lastPaint + 100000 < now)) || (lastPaint + 250000 < now)) {
+						textBox->setText(&txt);
+						textBox->paint();
+						lines_read = 0;
+						lastPaint = now;
+						dirty = false;
+					}
+				}
+			} else
+				ok = false;
+		} else if (r < 0)
+			ok = false;
+
+		gettimeofday(&tv,NULL);
+		now = (uint64_t) tv.tv_usec + (uint64_t)((uint64_t) tv.tv_sec * (uint64_t) 1000000);
+		if (r < 1 || dirty || lastPaint + 250000 < now) {
+			textBox->setText(&txt);
+			textBox->paint();
+			lastPaint = now;
+			dirty = false;
+		}
+	} while(ok);
+
+	int r = pclose(f);
+
+	if (res) {
+		if (r == -1)
+			*res = r;
+		else
+			*res = WEXITSTATUS(r);
+	}
+}
+
+CShellWindow::~CShellWindow()
+{
+	if (textBox && (mode & ACKNOWLEDGE)) {
+		int iw, ih;
+		frameBuffer->getIconSize(NEUTRINO_ICON_BUTTON_OKAY, &iw, &ih);
+		Font *font = g_Font[SNeutrinoSettings::FONT_TYPE_INFOBAR_SMALL];
+		int b_width = font->getRenderWidth(g_Locale->getText(LOCALE_MESSAGEBOX_OK), true) + 36 + ih + (RADIUS_LARGE / 2);
+		int fh = font->getHeight();
+		int b_height = std::max(fh, ih) + 8 + (RADIUS_LARGE / 2);
+		int xpos = frameBuffer->getScreenWidth() - b_width;
+		int ypos = frameBuffer->getScreenHeight() - b_height;
+		frameBuffer->paintBoxRel(xpos, ypos, b_width, b_height, COL_MENUCONTENT_PLUS_0, RADIUS_LARGE);
+		frameBuffer->paintIcon(NEUTRINO_ICON_BUTTON_OKAY, xpos + ((b_height - ih) / 2), ypos + ((b_height - ih) / 2), ih);
+		font->RenderString(xpos + iw + 17, ypos + fh + ((b_height - fh) / 2), b_width - (iw + 21), g_Locale->getText(LOCALE_MESSAGEBOX_OK), COL_MENUCONTENT_TEXT, 0, true);
+		frameBuffer->blit();
+
+		neutrino_msg_t msg;
+		neutrino_msg_data_t data;
+		do
+			g_RCInput->getMsg(&msg, &data, 100);
+		while (msg != CRCInput::RC_ok && msg != CRCInput::RC_home);
+
+		frameBuffer->Clear();
+		frameBuffer->blit();
+	}
+	if (textBox) {
+		textBox->hide();
+		delete textBox;
+	}
+}

src/gui/widget/shellwindow.h

@@ -0,0 +1,48 @@
+/*
+	Based up Neutrino-GUI - Tuxbox-Project
+	Copyright (C) 2001 by Steffen Hehn 'McClean'
+
+	Shell window class, visualize of system events on gui screen.
+
+	Implementation:
+	Copyright (C) 2013 martii
+	gitorious.org/neutrino-mp/martiis-neutrino-mp
+
+	License: GPL
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public
+	License as published by the Free Software Foundation; either
+	version 2 of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __WIDGET_SHELLWINDOW_H__
+#define __WIDGET_SHELLWINDOW_H__
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string>
+#include <gui/widget/textbox.h>
+
+class CShellWindow
+{
+	public:
+		enum shellwindow_modes { VERBOSE = 1, ACKNOWLEDGE = 2 };
+		CShellWindow(const std::string &cmd, const int mode = 0, int *res = NULL);
+		~CShellWindow();
+	private:
+		int mode;
+		CFrameBuffer *frameBuffer;
+		CTextBox *textBox;
+};
+
+#endif

src/neutrino_menue.cpp

@@ -513,6 +513,9 @@ void CNeutrinoApp::InitMenuService()
 	}
 
 	//separator
+	personalize.addSeparator(MENU_SERVICE);
+
+
 	if (!g_settings.easymenu) {
 		personalize.addSeparator(MENU_SERVICE);
 

src/system/locals.h

@@ -845,6 +845,7 @@ typedef enum
 	LOCALE_MENU_HINT_AUTO_LANG,
 	LOCALE_MENU_HINT_AUTO_SUBS,
 	LOCALE_MENU_HINT_BACK,
+	LOCALE_MENU_HINT_BACK_BRIEF,
 	LOCALE_MENU_HINT_BACKLIGHT,
 	LOCALE_MENU_HINT_BACKUP,
 	LOCALE_MENU_HINT_BEDIT,
@@ -1061,6 +1062,8 @@ typedef enum
 	LOCALE_MENU_HINT_NEW_ZAP_MODE,
 	LOCALE_MENU_HINT_NUMERIC_ADJUST,
 	LOCALE_MENU_HINT_ONEKEY_PLUGIN,
+	LOCALE_MENU_HINT_OPKG,
+	LOCALE_MENU_HINT_OPKG_UPGRADE,
 	LOCALE_MENU_HINT_OSD,
 	LOCALE_MENU_HINT_OSD_LANGUAGE,
 	LOCALE_MENU_HINT_OSD_PRESET,
@@ -1622,6 +1625,19 @@ typedef enum
 	LOCALE_NVODSELECTOR_DIRECTORMODE,
 	LOCALE_NVODSELECTOR_HEAD,
 	LOCALE_NVODSELECTOR_SUBSERVICE,
+	LOCALE_OPKG_BUTTON_EXPERT_OFF,
+	LOCALE_OPKG_BUTTON_EXPERT_ON,
+	LOCALE_OPKG_BUTTON_INFO,
+	LOCALE_OPKG_BUTTON_INSTALL,
+	LOCALE_OPKG_BUTTON_UNINSTALL,
+	LOCALE_OPKG_FAILURE_INSTALL,
+	LOCALE_OPKG_FAILURE_UPDATE,
+	LOCALE_OPKG_FAILURE_UPGRADE,
+	LOCALE_OPKG_MESSAGEBOX_REINSTALL,
+	LOCALE_OPKG_MESSAGEBOX_REMOVE,
+	LOCALE_OPKG_SUCCESS_INSTALL,
+	LOCALE_OPKG_TITLE,
+	LOCALE_OPKG_UPGRADE,
 	LOCALE_OPTIONS_DEFAULT,
 	LOCALE_OPTIONS_FB,
 	LOCALE_OPTIONS_NTP_OFF,

src/system/locals_intern.h

@@ -845,6 +845,7 @@ const char * locale_real_names[] =
 	"menu.hint_auto_lang",
 	"menu.hint_auto_subs",
 	"menu.hint_back",
+	"menu.hint_back_brief",
 	"menu.hint_backlight",
 	"menu.hint_backup",
 	"menu.hint_bedit",
@@ -1061,6 +1062,8 @@ const char * locale_real_names[] =
 	"menu.hint_new_zap_mode",
 	"menu.hint_numeric_adjust",
 	"menu.hint_onekey_plugin",
+	"menu.hint_opkg",
+	"menu.hint_opkg_upgrade",
 	"menu.hint_osd",
 	"menu.hint_osd_language",
 	"menu.hint_osd_preset",
@@ -1622,6 +1625,19 @@ const char * locale_real_names[] =
 	"nvodselector.directormode",
 	"nvodselector.head",
 	"nvodselector.subservice",
+	"opkg.button.expert_off",
+	"opkg.button.expert_on",
+	"opkg.button.info",
+	"opkg.button.install",
+	"opkg.button.uninstall",
+	"opkg.failure.install",
+	"opkg.failure.update",
+	"opkg.failure.upgrade",
+	"opkg.messagebox.reinstall",
+	"opkg.messagebox.remove",
+	"opkg.success.install",
+	"opkg.title",
+	"opkg.upgrade",
 	"options.default",
 	"options.fb",
 	"options.ntp_off",