Ideas GSoC 2014
Add Projects and Ideas
OpenWrt: D-Link DIR-632 support
D-Link DIR-632 is a router with 9 Ethernet ports with VLAN support, and other interesting hardware feature like 32MB RAM, 8MB flash, 802.11bgn wifi, available at relatively low price, our community networks would benefit from this device as an advanced router and/or as a managed switch if a stable and official OpenWrt support would be relased. This would be specially useful on a typical setup called "routing on the ground" where a router is placed inside the house, while wifi devices on the roof are configured in bridge mode using factory firmware, other cheap device already supported by OpenWrt have been tried without success, because the hardware switch do not support well VLAN (that are necessary for that setup), forcing nodes maintainers to use custom firmware on roof devices, or upgrade to expensive devices and/or to closed source solutions. The fact that some experimental OpenWrt support for this device is already present demonstrate the possibility to support it, so we need a student who wanna bring those experimental patches to the next level and make this device a first class citizen in OpenWrt hardware table.
| Useful Skills: | Linux Networking, Linux Drivers, OpenWrt |
| Type of Work: | System Coding |
| Progamming Languages: | C, Makefile |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
OpenWrt: IEEE 802.1ad VLAN support
In ours community networks we use also some very useful and cheap devices like the one from Tp-Link TL-WDRxxxx series, but we discovered that those machines are affected by a problem with 802.1q VLAN in particular tagged packets get dropped by the hardware switch, as recent Linux Kernel added 802.1ad support, doing some experiment we discovered that the same hardware works without problems with 802.1ad VLAN tagged packets, but OpenWrt UCI doesn't support 802.1ad VLAN yet. OpenWrt main developers are busy with other more difficult tasks, and this should be doable for an average student to implement that, in particular the student should gain good knowledge about netifd and implement creation and managing of 802.1ad VLAN interfaces, so Community Networks, users and developers can benefit of 802.1ad VLAN. This would benefit also BattleMesh folks that use those devices as testbed for various routing protocols using VLAN. Moreover OpenWrt could gain a new developer that have deep knowledge on netifd ( core networking component of OpenWrt ).
| Useful Skills: | Linux Networking, Netlink Sockets, UCI, netifd |
| Type of Work: | System Coding |
| Progamming Languages: | C, BusyBox, CMake |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Community networks are about freedom and decentralization, RetroShare brings principle that motivates community networks to application layer, and it is very suitable for use in our community networks because it take advantage of the decentralized nature of the network, still our physical infrastructure doesn't cover the whole world, and lot of people around the world suffer censorship and severe limitations to freedom of speech and communication. Implementing censorship avoidance in RetroShare we could bring some more communication freedom to people that live far from a community network while expanding our physical networks to reach them, the idea is about disguise the RetroShare traffic as HTTP (when necessary) that is usually not blocked/filtered and can cross also restrictive proxy. This include RetroShare binding on some "carriage free" ports like 80 (where user give it permission), and encapsulating RetroShare traffic as HTTP requests with some long polling strategy, imitating transfer of normal html pages with images etc etc. The idea can evolve as firewall get more strict implementing some more steganography painless, this would be totally innovative technique for a P2P network and make very difficult the "silent" censor work making his work not cost effective anymore.
| Useful Skills: | HTTP, TCP, IPv6, IPv4 |
| Type of Work: | Coding |
| Progamming Languages: | C++ |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Community networks are about freedom and decentralization. Recent events have shown that privacy and control over the data is a also very important parameter in the adoption of such networks. RetroShare is a Friend-to-Friend system that brings these principles, and it is very suitable for use in our community networks because it takes full advantage of the decentralized nature of the network.
The Retroshare system is based on a core library that allows developers to implement community network applications on top of it, while benefiting from the security and cryptographic primitives below. The up-coming version 0.6 (will be out this spring) offers interesting cryptographically designed community primitives such as pseudo-anonymous identities, reputation handling and circles of friends. The new cache system that is responsible for distributing the data inside the network is entirely ruled by a permission system based on these primitives.
This proposal is about implementing a social network plugin on top of RetroShare 0.6, which will bring a real decentralized social network to end users, and reduce dependency from the rest of the internet on our community networks, while ensuring full control of user's data at a cryptographic level. A possible approach is to use Witty to generate web pages from a RetroShare plugin, and use the new cache system to retrieve and send data. Providing a web-based interface will make it more confortable for users coming from other mainstream social networks and lower the adoption barrier. From the point of view of the end user, the final application would be a headless Retroshare node running in the background which the user accesses on his computer using his web browser. The look and feel of the HTML pages should look somewhat similar to what other social networking companies offer, but with a significant additional level of security and control.
| Useful Skills: | Retroshare GXS, Witty |
| Type of Work: | Coding |
| Progamming Languages: | HTML5, JavaScript, C++ |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Libre-Mesh: Modules Runtime Dependencies
Libre-Mesh meta-firmware aims to be highly modularized, and in fact almost all parts it consist are split into modules, some modules depends at runtime on the fact that other module has already run, at moment this condition is guaranteed by the order modules are written in configuration files, but this imply that an user can break things involuntary, so we need some kind of runtime dependency enforcing system to be implemented, it must be light, fast, and simple keeping in mind that will be installed on embedded devices that can have as little as 4MB of flash.
| Useful Skills: | OpenWrt, Unix System Administration |
| Type of Work: | Coding |
| Progamming Languages: | Lua |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Libre-Mesh: Configuration Validator
Libre-Mesh meta-firmware configuration system is highly flexible and powerful, this is very useful for experienced user, but an unexperienced user can easily write an inconsistent configuration leading to unexpected firmware behaviors, a specification to define syntactic and semantic validators in modules and a configuration files validator module could be implemented to check configuration before applying.
| Useful Skills: | OpenWrt, Unix System Administration |
| Type of Work: | Coding |
| Progamming Languages: | Lua |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Libre-Mesh: Test and Save mode
Libre-Mesh meta-firmware configuration system is highly flexible and powerful, although sometime even expert users can commit errors when doing advanced configurations, and this can lead to problematic situations like unreachable device installed on a 12m pole. Most proprietary firmware implement a mode called "Test & Save" that consist in applying configuration and keeping it for a specified amount of time, and if administrator cannot access the device to confirm new configuration the old configuration is restored. This feature is still laking on OpenWrt based opensource firmwares, so a student can implement this as a Libre-Mesh module.
| Useful Skills: | OpenWrt, BusyBox |
| Type of Work: | Coding |
| Progamming Languages: | Lua |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Libre-Mesh: Custom Hardware Detection
Libre-Mesh meta-firmware is used also on very cheap devices, usually those devices are customized, for example adding cheap USB radios or doing some hardware mod to unlock full device potential of already onboard chips, OpenWrt hardware detection often doesn't automatically configure the system to take advantage of such mods and it would be unpractical to supports such things in the core most of the time. A student can implement an hardware detection module for Libre-Mesh and submodules for common mods, like adding ath9k supported USB radios.
| Useful Skills: | OpenWrt, BusyBox, Linux Drivers |
| Type of Work: | Coding |
| Progamming Languages: | Lua |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
LibreMap: routing protocol plugins
The libremap-agent-openwrt component of LibreMap has a plungins system that makes adding support for new information to be pushed to the database very straightforward.
The aim of this project is to add support for pushing routing data.
The webui component of LibreMap[1] understands different types of links. Each protocol plugin will need to push information conforming to the Link Model for the webui to be able to correctly draw the links. This model requires node identification (which may be MAC address, IP o some other unique attribute) for both ends, and link quality expressed in a range from 0 to 1.
The minimal set of protocols that should be supported in this project are: OLSR, batman-adv, bmx6 and babel.
The student will need to know or investigate which are the best methods to obtain neighbor information for each protocol.
As a secondary goal, the student should also implement filters in libremap-webui to allow the user to choose which type of links are to be displayed at any time.
| Useful Skills: | OpenWrt, dynamic routing protocols |
| Type of Work: | Coding |
| Progamming Languages: | Lua, Javascript |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
[1] https://github.com/libremap
IPv6MESH
IPv6MESH [1] is a community project founded on 01/01/2014 to develop and standardize a mesh network extension for the Internet Protocol 6 (OSI Layer 3). Every IPv6MESH node will generate it's cryptographically secured IPv6 addresses (CGEIDs) and connections to neighbour nodes ad-hoc which allows to deploy a large number of nodes in a IPv6MESH cloud automagically. As opposed to darknets like Hyperboria IPv6MESH will completely integrate into the existing BGP-routed internet.
IPv6MESH [1] can be used to set up emergency communication networks, vehicle-2-vehicle communication (car-2-car, ship-2-ship, satellite-2-satellite), can close gaps in networks by e.g. integrating nodes into reflector posts, streetlights, trees, moored buoys or balloons, geostationary satellites or just serve as a community network.
The GSoC goal ist to develop a proof-of-concept/reference implementation using the Github repository. [2]
[2] https://github.com/renne/ipv6mesh
| Useful Skills: | Lua, Shell, Networking, Mesh Protocols |
| Type of Work: | Coding/Testing |
| Progamming Languages: | Lua, C, Shell |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
CommunityCoin (GuifiCoin)
Based on the BitCoin block chain concept, the community coin is a crypto-currency made for network Communities. However the coin reward is not based on the block finding but in the contribution and participation of the community individuals.
A set of algorisms will analyze the community communication mediums such as:
- Contributions in the mailing list
- Number of nodes working
- Traffic (data) of these working nodes
- Services added by the user to the community
- Participation in the code
- etc...
These algorisms will run in a central entity, which transparently will calculate the reward: how much and to which users. The block chain miners will consult this entity for each new block to decide how is the reward spread (transactions for the next block). A small reward will be also given to the miners for finding new blocks to incentivate the mining process and validate new transactions.
This currency may be used for the internal community workaround. For instance if user John have a proxy service which moves 10GB per day, he will be rewarded with 10 CommunityCoins. Afterwards he will be able to spend these coins to pay a video-on-demand service or to buy a second hand hardware to another community member. So at the end, the motivation of the system is to incentivate the community members to work for the community (installing new nodes, creating new services, selling old hardware, etc.) and make the community model self sustainable.
The aim of the GSOC project is to create the first prototype of the CommunityCoin for the Guifi.net community network. It is a community with 20k members which include several small companies, self-employees, a Foundation (NGO) and many other kind of entities and individuals. So this is probably the most big and heterogeneous existing community network in Europe, a perfect scenario to make the first proofs of concept.
| Useful Skills: | C++, HTTP, Community Networks |
| Type of Work: | Coding/Testing |
| Progamming Languages: | C++ |
| Level from Beginner 1-5 Professional: |
5 Professional |
qMp controller (LUPUS)
QMP (Quick Mesh Project) is a firmware for embedded devices based on OpenWRT to easy deploy mesh networks. It was started in 2011 and right now there are several communities around the world using it. However as most of the current mesh network firmwares, there is not (yet) a central web controller to manage the nodes in remote. This is a very appreciated feature to allow non-technical users to deploy and manage their own network.
A QMP folk is already working on that developing a system to communicate any OpenWRT node with a central controller. LUPUS [1] is a REST API for the UCI [2] (Unified Configuration Interface) of OpenWRT. The second step would be to create a web interface to manage the LUPUS service. And the third step would be to create an abstraction layer to configure QMP from LUPUS.
The aim of the GSOC project is to implement the second and third phase. One of the requirements would be to make the system modular enough to allow other FOSS firmware projects based on OpenWRT to use it, so anyone can get profit from the code developed inside this project.
[1] http://dev.qmp.cat/projects/lupus
[2] http://wiki.openwrt.org/doc/uci
| Useful Skills: | Lua, Shell, Networking, OpenWRT, HTTP, Python |
| Type of Work: | Coding |
| Progamming Languages: | Lua/Shell/Python |
| Level from Beginner 1-5 Professional: |
3 Medium |
BGP/Bird integration in qMp
Most of the network communities use Quagga for routing BGP. Bird is a lightweight and more flexible daemon, which will probably peform better in the common mesh hardware used in these communities (MIPS 400MHz, 8MB flash, 32MB ram). In Guifi.net, AWMN and also Ninux, the BGP networks are mixed with the Dynamic Routing Protocol networks (OLSR, BMX6, Batman). The BGP nodes are mainly running a closed source solution (Mikrotik), because there not exist a good integration between a BGP daemon and OpenWRT Linux. The objective of this proposal are two:
1. Improve the integration of Bird inside OpenWRT (by writing a UCI/LUCI plugin)
2. Integrate Bird inside qMp (Quick Mesh Project) and implement a system for exchange metrics and routes between BMX6 and BGP
| Useful Skills: | Lua, Shell, Networking, OpenWRT |
| Type of Work: | Coding/Testing |
| Progamming Languages: | Lua/Shell |
| Level from Beginner 1-5 Professional: |
4 Semi-professional |
LUPI
UCI is an standard interface light, easy and simple meant to unify all the configurations of OpenWRT.
LUPI (Lua Unified Programming Interface) follows the same idea of UCI but in the programming scope. Since OpenWRT is designed as a base Linux distribution for develop complete solutions on its top, it is very usual to find meta distributions such as QMP, AlterMesh or Commotion. These, normaly have a set of small applications (scripts) to configure the system, monitorize it or interact with the end user. In OpenWRT the standard languages to develop such kind of apps are C, Shell script and Lua. As example the well known LUCI, a complete web interface written in Lua to manage the system.
The developers working in the meta distributions are normally choosing shell script because it is easy and quick. However when these scripts beacame big, it is very hard to maintain and debug them because of the design of the language (shell is a command line application not really designed for be used in such situations). In the other side, Lua is very powerfull and much more efficient than shell, it is one of the most languages used for embedded hardware. However the standard library provided by Lua is very small, it meanslightly but also difficulty to use it. Here is where LUPI takes place by providing a standard library specially designed for OpenWRT to facilitate and standarize the development of applications.
LUPI was originally designed by QMP folks for a GSOC project in 2012 (not as a objective but as a medium), but it was never finished (only the required features to accomplish the GSOC needs were developed). Later on it was adopted by LibreMesh [1], but it is stopped due the lack of resources to implement it.
The aim of the GSOC project is to redesign and implement a first production version of LUPI and push it to the OpenWRT mainstream.
[1] https://github.com/libre-mesh/lupi
| Useful Skills: | Lua, Networking, OpenWRT |
| Type of Work: | Coding |
| Progamming Languages: | Lua |
| Level from Beginner 1-5 Professional: |
3 Medium |
IPv6 support for Tunneldigger
Tunneldigger is a VPN solution used in many community/mesh networks to connect nodes which do not have a wireless link between them into a common network. It uses existing network connectivity (like Internet) between nodes to create L2TP tunnels between them. Current limitation is that those tunnels use only IPv4 and cannot be established over IPv6. (Tunnels are layer 2 and can carry both IPv4 and IPv6 traffic already. The issue here is that they themselves cannot be established over IPv6.)
The aim of the GSoC project is to design and implement IPv6 support for Tunneldigger so that it works in IPv6-only and IPv4/IPV6 mixed environment where both server and client have IPv6 connectivity in some form. Student should have experience or be willing to learn Python and C, compiling and running code for OpenWRT, have experience with networking stack (IPv4, IPv6, NAT).
[1] https://github.com/wlanslovenija/tunneldigger
| Useful Skills: | IPv4, IPv6, NAT |
| Type of Work: | Programming |
| Progamming Languages: | Python, C |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Linux kernel support for multiple L2TP tunnels on the same server port
Current L2TP tunneling support in Linux kernel is limited by the fact that each tunnel requires unique UDP port on the server side. This creates problems for clients behind NAT as it would be much easier to configure NAT traversal if all tunnels would connect to the same server port. L2TP tunnels are used in Tunneldigger for providing a VPN solution for community/mesh networks.
The aim of the GSoC project is to implement support for multiple L2TP tunnels on the same server port in Linux kernel, create a patch for OpenWrt and Linux and send it upstream for inclusion. Student should have experience or be willing to learn Python and C and Linux kernel hacking/compiling and have experience with networking stack (IPv4, IPv6, NAT) and reading and implementing RFC standards.
| Useful Skills: | Linux kernel |
| Type of Work: | Kernel development |
| Progamming Languages: | Python, C |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Nodewatcher: Add real-time (push) support to Datastream API
Datastream API (with its HTTP interface) is a library for collecting and visualizing time-series data. It is used in nodewatcher to store and visualize measurements from nodes in a mesh network. Such visualizations through time allow better insight into network's status and operation for both experienced and novice users. Current implementation provides a RESTful API for fetching data to the client (browser) side for visualization. The issue is that for real-time visualization of such RESTful API requires from the client side to constantly poll the API endpoint for new data. A better model would be to use a push based API to get data from the server as new data is available (probably as a publish/subscribe pattern).
The aim of the GSoC project is to design and implement a HTTP push based API for Datastream and integrate support for it into current client-side visualization code. Visualization should be able to read and update in real-time as new data arrives. Student should have experience or be willing to learn Python and Javascript and HTTP push based technologies, probably Django/node.js/Meteor/Tornado or some other suitable stack. (Current RESTful API is implemented in Django.) Datastore for Datastream data is MongoDB.
[1] https://github.com/wlanslovenija/datastream
[2] https://github.com/wlanslovenija/django-datastream
| Useful Skills: | Understanding HTTP push |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Nodewatcher: Upgrade to Django 1.7
Current version of nodewatcher is tested with and built upon Django 1.4. Since then many new features have been implemented in Django and nodewatcher should be ported to support and take advantage of those new features. In addition dependent modules and libraries should also be upgraded to Django 1.7 if there is lack of support. nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community, a modular node database for mesh and community networks.
Student should have experience or be willing to learn Python and Django and how to write tests and use continuous integration tools to ensure quality control as codebase is upgraded to Django 1.7.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django |
| Type of Work: | Web programming |
| Progamming Languages: | Python |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Nodewatcher: Node data matrix comparison module
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community. In its 3.0 version it provides a modular architecture for integration of 3rd party community modules. As a good example of such a module a matrix comparison module could be developed.
The idea is to create a module which provides a page/matrix for node data comparison. Currently data is displayed only as a simple list of nodes with a fixed set of columns. The idea is to improve this so that custom columns can be added/removed. And also to add another dimension to get a matrix so that it is easy to compare values between nodes. For example, see how stability of nodes relate to number of clients. Additionally, this idea could be extended by an option to draw/plot selected columns/values as scatterplots.
You can see many data we collect as potential interesting and it would be interesting to be able to compare them. With matrix display this could be possible. So, a better way to compare nodes among themselves is wanted, and if possible to also visualize that.
Student should have experience or be willing to learn Python and Django and how to write Django apps together with basic understanding of HTML/JavaScript and general web development.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Nodewatcher: Overview of used IP space module
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community. In its 3.0 version it provides a modular architecture for integration of 3rd party community modules. As a good example of such a module an overview of used IP space module could be developed.
Currently we have a very limited overview of used IP space without more precise division of existing and used subnets. This could be improved in a similar manner that it is shown here. A compact and colorful matrix with IP ranges and links to nodes. Maybe also with some additional hover effect when you go over block to get some more information.
Student should have experience or be willing to learn Python and Django and how to write Django apps together with basic understanding of HTML/JavaScript and general web development.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Nodewatcher: Plotting signal coverage on node map
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community. One of features is also a node map of nodes in the network.
We currently have a map that shows geographical location of nodes. It would be great to have tools that could overlay signal coverage over this map. This can be done even without exact antenna radiation diagrams, we just need the node's general antenna direction. Then we can check neighboring nodes and color all the appropriate triangles (so the first node and its two neighbors – for all neighbors). This can then be used to mark areas that the node's signal should reach. Of course this will not be an exact computation but it can serve as a general reference when checking signal coverage and having data from neighbors available.
We could also take link quality into account. For example if one node has two links with 60° inner angle, both having 1.0 link quality, we could assume that the signal will also be ok +/- 30° to either side of the triangle. These additional triangles could then be drawn with a lighter color (and they could also be transparent).
Extra useful it would be if this would be a general library for plotting signal coverage on maps, so that it could be used with nodeshot node mapping software. Also that it supports both Google Maps and OpenStreetMap.
Student should have experience or be willing to learn Python and Django, but mostly good experience with JavaScript, drawing with JavaScript and integration with Google Maps and other mapping APIs. Good understanding of math is probably a must as well.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django, HTML5, math |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Nodewatcher: HMAC signing of nodes data
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community.
Currently all monitoring reports by nodes are unsigned and can be spoofed by anyone. This represents a security problem and a possible solution is that every node would be assigned its own nodewatcher signing key. The node would then sign the monitoring output using a hash function in HMAC mode. Every request from nodewatcher would also contain a random nonce that would be used in signature computation to prevent replay attacks.
Such HMAC-based signing should not be too expensive in terms of CPU usage as it is a simple SHA-256 computation that can be performed via the OpenSSL library.
Signature verification failure would then generate an event and a warning within the nodewatcher monitoring system.
Student should have experience or be willing to learn Python and Django, shell scripting and maybe C, and development of OpenWrt packages and integration. Understanding of basic cryptography is needed, too.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django, OpenWrt, basic cryptography |
| Type of Work: | Web programming |
| Progamming Languages: | Python, C, shell |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Nodewatcher: Render network topology graphs in browser (client-side)
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community.
Currently we have only static rendering of a given moment on the server using GraphViz. It would be better if this would be done client-side in the browser so that user will be also able to interact with the graph, move nodes around to better present them, zoom in/out and so on. Because current image is fixed and sometimes it does not display the topology best and also in dense big networks it soon gets too complex to comprehend.
There are some libraries for that:
For drawing of data we are starting to use datastream library, so the best would be that topology graphs would be rendered inside it as well. Currently, we are using Highcharts for drawing data.
Some useful answers on Stack Overflow.
It is also possible to extend it with visualization through time and 3D: #710.
Student should have experience or be willing to learn Python and Django, but mostly good experience with JavaScript, drawing with JavaScript. Good understanding of math is probably a must as well.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django, HTML5, math |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Nodewatcher: Integrated link planner
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community. One of features is also a node map of nodes in the network.
Integrate a link planner into nodewatcher, where potential the links to all surrounding nodes are calculated, the elevation profile is drawn for each of the potential links and the signal loss is calculated.
The benefit of such planner would be much simpler link planning. When a node is added, the full potential of the links from that location is seen.
A desktop tool for that is for example Radio Mobile. Integration and scripting for it should be checked, especially running/porting it on Linux. If not already existing, a library (with Python bindings) or standalone console application based on it could be developed.
It seems also an online version already exists.
Student should have experience or be willing to learn Python and Django and how to write Django apps together with basic understanding of HTML/JavaScript and general web development.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django, math |
| Type of Work: | Web programming |
| Progamming Languages: | Python, JavaScript |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Nodewatcher: instalation/configuration wizard
nodewatcher is an open source network planning, deployment, monitoring and maintenance platform with emphasis on community. One of features is also a node map of nodes in the network.
nodewatcher is currently being in the process of transforming to the new backend – much more pluggable and extendable, so that different wireless community networks and installations can configure it to their needs. The idea is that at the end we have a bunch of Django apps users will be able to enable or disable.
To ease all this configuration options an admin installation and configuration wizard could be made so that after the installation of nodewatcher user could select through web interface which modules/components/plugins (Django apps) it wants enabled. Of course there is also possibility of dependencies between apps. And information about additional steps necessary for module enabling (like running background processes, cron jobs, or something similar).
Even crazier would be to allow installation of new apps and upgrade of existing apps through the same interface (for example through Django Packages), of course if nodewatcher is running with necessary system privileges.
Student should have experience or be willing to learn Python and Django and how to write Django apps together with basic understanding of HTML/JavaScript and general web development. Probably a good understanding of Django internals are necessary as well.
[1] https://github.com/wlanslovenija/nodewatcher
| Useful Skills: | Django, Django internals |
| Type of Work: | Web programming |
| Progamming Languages: | Python |
| Level from Beginner 1-5 Professional: |
4 Semi-Professional |
Source-sensitive routing in Quagga
Source-sensitive routing [1] (or SADR [2]) consist in routing packets depending on the source address of the packets in addition to the destination. It solves a number of routing problems, especially in multihomed edge networks[3], and may lead to better performance by providing more routes to higher layers. For example, MultiPath TCP at the transport layer is able to use these multiple routes [4,5]. Source-sensitive routing is implemented in an experimental branch of the babeld stand-alone daemon [6].
Quagga [7] is a routing suite written in C providing implementations of network routing protocols for Unix platforms. Quagga's common layer ("zebrad") abstracts away the dirty details of low-level networking, allowing all routing protocols implemented in Quagga to use a common API, independent of the underlying operating system. This common layer does not currently implement source-sensitive routing.
The goal of this project is to provide source-sensitive routing in the Quagga routing suite for the netlink interface. The student need to understand and modify the communication protocol between zebrad and the other daemons, change the local RIB of Quagga, and change the interaction between zebrad and the Linux kernel.
[1] http://tools.ietf.org/html/draft-boutier-homenet-source-specific-routing
[2] http://tools.ietf.org/html/draft-troan-homenet-sadr
[3] http://tools.ietf.org/html/draft-baker-rtgwg-src-dst-routing-use-cases
[4] http://multipath-tcp.org/pmwiki.php/Users/ConfigureRouting
[5] http://www.pps.univ-paris-diderot.fr/~boutier/source-specific-routing.html
[6] http://git.wifi.pps.univ-paris-diderot.fr/?p=babels.git;a=summary
[7] http://www.nongnu.org/quagga
Netengine: consistent JSON representation of network devices across different firmware/protocols
- Netengine
- is a python library that aims to provide a consistent API to extract information from network devices using different protocols (SSH, SNMP, HTTP).
The most important methods of each "backend" are the to_dict() and to_json() methods, the former returns a JSON representation of all the information that could be extracted from the network device.
Many developers have developed custom ways to interact with their firmwares and devices thus duplicating efforts to write code that should really be standardized.
The goal of this project is to improve the existing to_dict and to_json implementations in order to reach good consistency and reliability for the most used protocols and firmwares:
- SSH on OpenWRT
- SNMP on OpenWRT
- HTTP on OpenWRT (via JSON API)
- SSH on Ubiquiti AirOS
- SNMP on Ubiquiti AirOS
- HTTP on Ubiquiti AirOS (via JSON API)
- SSH on Ubiquiti EdgeOS
For each backend there are some missing methods that must be implemented in order to extract the needed information from the platform/protocol.
The patches will have to be thoroughly unit tested and documented.
For this project we are looking for a student who has some basic experience with python and an average understanding of networking and who is willing to improve his/her skills in order to learn how to contribute properly to FOSS projects.
The student will be followed by one mentor and will integrate his work into an existing group of volunteer coders who are already working on other parts of the library.
| Useful Skills: | Python, Networking, OOP, Bash, SNMP, HTTP APIs |
| Type of Work: | Coding |
| Progamming Languages: | Python |
| Level from Beginner 1-5 Professional: |
3 Intermediate |
Open Networks InfoVis
Interactive Visualization of Open Networks. The intent is to collect network Open Data in RethinkDB [1], an open-source, distributed database built to store JSON documents and scale to multiple machines, and display them with D3.js [2], a JavaScript library for manipulating documents based on data. We have a small mockup [3] based on Guifi.net Open Data and a very early stage code [4]. Force-Layout Graph, Chord Diagram, Scatterplot Matrix, etc. are very interesting visualizations to obtain relevant information for the management of these networks.
The goal of this project is to provide other visualizations of networks in addition to maps and assist in making decisions in a group or community.
[2] http://d3js.org
[3] http://bcnproject.com/wp-content/uploads/viz/guifi.html
[4] https://github.com/josepjc/d3-guifi
| Useful Skills: | JavaScript, D3.js |
| Type of Work: | Coding |
| Progamming Languages: | JavaScript, HTML5, DOM, ReQL |
| Level from Beginner 1-5 Professional: |
1 Medium |
Decentralized Router-centric Microblogging (Drombo)
The rise of community networks, in which there is no central ownership and management of the infrastructure, increases the demand for distributed and decentralized services. However most of these rely on the availability of servers, while not all users have the resources and willingness to install and keep one at their homes. On the other hand, community network members are motivated to support and maintain their network equipment, and thus community network routers, capable of running Linux distributions such as OpenWrt, look like a pervasive platform in which to deploy basic community-targeted services.
The aim is to develop a microblogging system that:
- runs on low-resources systems (off the shelf routers: few MBs storage, few KBs RAM)
- is resilient to temporary network disconnections
- does not rely on any specific routing protocol (e.g. based on mDNS)
- exports an HTTP-based API
- has an on-router Web interface
Users should be able to post micro-messages at their homes and spread them to routers all over the community network, subscribe to other users' feeds and re-share other users' short messages.
| Useful Skills: | Linux system and network programming, Basic Web development, OpenWrt administration |
| Type of Work: | Application coding |
| Progamming Languages: | C, Lua, Shell, C++ (no Python, no Ruby) |
| Level from Beginner 1-5 Professional: |
3 |
Freifunk API Query Client
The Freifunk API helps communities to provide their data in a structured way. To access the data we collect all API files and then extract the information needed, e.g. for the map, the rss feed aggregator. There're also additional requests for specific fields (e.g. calendar feeds). Instead of reinventing everything everytime it would be great to build a web based query client.
Goals for such a client are:
- build queries within a web interface
- export http based API to accept queries passed by url (GET, POST) like a web service
- web interface should get fields from a json schema file
- returns result set as json containing the requested fields
- also show results in web interface
- use of an sql-like query language
- maybe embed in wordpress
| Useful Skills: | Web development, Data Structures, Web applications |
| Type of Work: | Application coding |
| Progamming Languages: | JavaScript, JS frameworks, Script languages (Python, Bash), SQL, JSON |
| Level from Beginner 1-5 Professional: |
3 |
LuCI Bootstrap3 Theme
Create a new LuCI theme using twitter's bootstrap3. You could use the existing bootstrap theme as coding base or build a new theme from scratch. There're lot of new features, LuCI could benefit from, including a much more easier way to create themes. The project focus can either be more technical or design. Things to do:
- upgrade to bootstrap3 (less;css;buildsystem)
- create more bootstrap and meta components (e.g. data tables, node info boxes)
- enhance kitchensink to style guide
- polish freifunk themes, or create a new one
- convert icons to vector graphics
| Useful Skills: | Web development, HTML5/CSS/Less, jQuery, UI-Design, UX |
| Type of Work: | Application coding, UI Design |
| Progamming Languages: | JavaScript, JS frameworks, Lua, JSON |
| Level from Beginner 1-5 Professional: |
3 |
