Ideas GSoC 2017

OpenWRT/LEDE

Implement NetJSON output in ubus (OpenWRT/LEDE)

NetJSON is emerging as a common format to exchange configuration and monitoring information from network devices. Year after year it's becoming easier to achieve interoperability between different software packages for community networks. Now is time to start implementing NetJSON in a lower level of the stack and the next natural step in that direction is to implement it in ubus (OpenWrt micro bus architecture), which is included by default in LEDE and OpenWRT, the two linux distributions commonly used in wireless community networks like Freifunk.

In this project the student will have to develop ubus API extensions that allow retrieving two NetJSON object types: DeviceConfiguration and DeviceMonitoring.

Measurable outcomes:

• Implement a way to retrieve DeviceConfiguration output in ubus using scal (System Configuration Abstraction Layer),
• Implement a way to retrieve DeviceMonitoring output in ubus, consider reusing part of the code used in nodewatcher-agent
• Write a Makefile to package the software for OpenWRT/LEDE
• Document the compilation/install process and the usage of the module in the README

Useful Skills:	C, OpenWRT/LEDE
Type of Work:	Programming
Progamming Languages:	C
Possible mentors:	Eric Shultz, Felix Fietkau, Federico Capoano
Level from Beginner 1-5 Professional:	3

PowQuty Life-Log

In today's Freifunk networks the PowQuty deamon enables everybody to collect voltage samples over time with the use of an USB oscilloscope and calculates important statistics (voltage rms, harmoics, ect.) by using the power quality library. Such an online analysis of power quality is not sufficient in cases where our Freifunk networks are used to drive the communication infrastrucutre of a decentralizes smart power grid. Herefore a power quality log file that provides the appropriate EN50160 norm events is needed.

With this proposal we want to extent the current PowQuty in such a way, that we it is possible to provides a log file for the user and or power grid manager that collects all events of the power quality where the appropriate EN50160 norm is violated. This project aims to add a live log of violation events to the daemon and the luci PowQuty web application. Two information distribution features are developed: (A) a MQTT based pulish & subscribe messaging system to allow customized power quality EN50160 events distribution and (B) a notification system will be added to inform the user e.g. by email if the power quality EN50160 norm is violated. This allows fast responses to changing conditions in a decentralized power grid and will help to improve renewable power generation in Freifunk networks.

Useful Skills:	good motivation to create a web-based power qulity live log with a new LUCI application
Type of Work:	Software development
Programming Languages:	Lua, Html, Ansi C, Makefile
Possible mentors:	Thomas Hühn (aka Bluse) Email: thomas@inet.tu-berlin.de
Level from Beginner 1-5 Professional:	4

Project Babel

Making diversity routing work better

In the absence of explicit diversity routing information supplied by the protocol, the z3 algorithm assumes that a given route is interfering, even if the interface over which a route is learned is obviously not (usbnet), or probably not (ethernet).

Diversity routing also does not take into account (presently) the number of ways channels can be combined in the various wifi standards. HT20 covers 4 channels, HT40, 8, HT80, up to 2 sets of 4 channels, and so on.

Tasks will be to:

1. Add support for HT20, HT40, and HT80 channels.
2. Add support for the ethernet/usbnet case.

ECN support

Particularly with more unicast over wifi, packet loss becomes a very poor metric of link quality - either you get the packet, with potentially tons of delay, or you don't.

It seemed extremely unlikely, except on extremely overburdened networks, that ect(3) will be asserted. However in an age where packet loss is increasingly rare, one test showed 30% of ECN marked babel packets being ECT(3) marked by a fq_codel based congestion controller.

Upon reception of an ect(3) marked packet, a babel instance MUST:

1. Increase the rxcost
2. send a IHU (or other acknowledgement?) marked with ect(3), with an increased hello interval (if present interval is below the default)
3. reduce it's sending rate by half (if performing a routing table update)
4. Receipt of ECT(3) markings MUST NOT be treated the same as packet loss as for the total viability of a given route.

Babel visualisation

Unlike olsr and batman-adv, babel based freifunk-networks cannot be visualized easily. The protocol is lacking support for diagnostics and dumping reachability information into sinks. Current approaches focus on making the information avaiable using a TCP-Service, that can be queried using webapplications - some are out there. The idea is to develop a distribute diagnostics system that is:

1. Secure: Generally, it is dangerous to have a UDP/TCP/HTTP, you-name-it service running on nodes. Load on this service can (and has) impact(ed) the routing performance in serious ways (DoS). Bugs can be used to take control of the nodes - this has already happend in some batman-adv based systems, using some home-brewn freifunk visualisation.
2. Lede / Openwrt friendly: Gathering data has to be done on OpenWRT / Lede. Sinks and visualization services may be provided on more powerful devices (such as Odroid / Rasperri Pi / you-name-it), but data extraction has to happen on each and every babel node.

Remarks:

• Given, that there is nice JavaScript / CSS map for displaying data, make the sinks providing data via JSON/HTTP is enough
• The challenge is to sketch and implement a system allowing Nodes to publish and sinks to subscribe to reachability information.
  • As far as I know, UDP/Multicast-Routing in babel is close to non-existent. Implementing this, is an approach, but this is also somewhat difficult
  • Another idea is to connect all sinks using a p2p network (kadamlia based?) and have all nodes unicasting packets to the nearest sink using anycast addresses. This is easier, then implementing multicast-routing but not that elegant.
• Have a look at nodewatcher: https://arxiv.org/pdf/1601.02372v1.pdf, https://dev.wlan-si.net/wiki/Nodewatcher,
  • Mind that: Nodewatcher introduces a lot complexity
  • Nodewatcher diverges from the data format, structure and methodology for gathering data used in freifunk-communities. Supporting JSON formats used in freifunk communities for maps, etc. vital for integration into existing webpages.
• Be as lightweight as possible.
• It's also interesting to evaluating existing sinks such as collectd, or other ones supported by grafana.
• Consider storing data: How does the system evolves over time?

Useful Skills:	Basic understanding of: Babel / DV-Routing, Multicasting, Data transformation, data propagation in distributed systems (patterns such as publish / subscribe, JSON)
Type of Work:	Programming Backend + Frontend
Programming Languages:	Shell / Rust / C / Unix-Language-You-Name it
Possible mentors:	yanosz
Level from Beginner 1-5 Professional:	That depends ;-) 2 - if nodewatcher components are used to provide a JSON/HTTP Service, 3 - if UDP/Anycast is used, 4 - if you implement sinks for graph data in babel, 5 - if you implement multicast routing in babel

BATMAN

batman-adv: Multicast Streaming Support

Introduce a mechanism to allow sending a multicast packet to multiple listeners without needing to flood the whole mesh network.

Current state of batman-adv multicast optimizations can be found here

Suggestions for a mechanism:

• Split a multicast packet into multiple unicast transmissions (level 1)
• Send a multicast packet with a new multicast header type containing multiple destinations (level 2)

Useful Skills:	Network and Linux kernel coding experience
Type of Work:	Linux kernel programming
Programming Languages:	C
Possible mentors:	_
Level from Beginner 1-5 Professional:	4

(Contact: Linus Lüssing)

batman-adv: Reactive Protocol Enhancements: Rest-In-Peace

Reduce BATMAN V protocol overhead by introducing reactive enhancements.

The current idea, "RIP", can be found here

Useful Skills:	Network and Linux kernel coding experience
Type of Work:	Linux kernel programming
Programming Languages:	C
Possible mentors:	_
Level from Beginner 1-5 Professional:	4

(Contact: Linus Lüssing)

batman-adv: TT Privacy Enhancements

Currently, the node a a client device is connected to is known through out the whole mesh. Enhance privacy by only storing the next-hop node information towards a client device instead of the final destination node.

In batman-adv client devices are handled via the reactive Translation Table protocol. More information on TT can be found here, here and here.

Useful Skills:	Network and Linux kernel coding experience
Type of Work:	Linux kernel programming
Programming Languages:	C
Possible mentors:	_
Level from Beginner 1-5 Professional:	5

(Contact: Linus Lüssing)

batman-adv: Anycast Support (+ Gluon integration)

Implement a toggle to enable a static unicast MAC address range to be excluded from the TT roaming mechanism, instead handling it similar to the BLA code path.

This would allow handling these selected MAC addresses in an anycast fashion.

Finally an option for a Gluon node owner should be implemented to opt-in as an Internet gateway via the Gluon "Config Mode" web interface.

Technically, a default route would utilize an anycast MAC+IP address and when opting-in would get configured on the according node. To start with, NAT should be used both for IPv4 and IPv6 gateway node routing (implementing prefix delegation is out-of-scope for this proposal).

Some more thoughts on batman-adv and anycast here

Useful Skills:	Network, Linux kernel and OpenWRT/LEDE/Gluon coding experience, netfilter/ebtables experience
Type of Work:	Linux kernel programming, Gluon integration/packaging
Programming Languages:	C, Lua
Possible mentors:	_
Level from Beginner 1-5 Professional:	4

(Contact: Linus Lüssing)

batman-adv: algorithm "external"

batman-adv already supports switching the algorithm at runtime, currently between "BATMAN_IV" and "BATMAN_V". Implement a new option called "external" which does not set forwarding table entries on its own, but enables an interface reachable via userspace instead.

This would allow using babeld, olsrd2 or bmxd and their according algorithms to not only configure layer 3 routing tables, but to fill the layer 2 forwarding table of batman-adv, too. And would allow easier prototyping for and experimentation with layer 2 mesh routing.

Useful Skills:	Network and Linux kernel coding experience
Type of Work:	Linux kernel programming
Programming Languages:	C
Possible mentors:	_
Level from Beginner 1-5 Professional:	4

(Contact: Linus Lüssing)

Firmware Gluon

l3roamd

Improve:

• https://github.com/tcatm/l3roamd
• https://github.com/freifunk-gluon/gluon/pull/934

Conceptual information here

Useful Skills:
Type of Work:
Programming Languages:
Possible mentors:	_
Level from Beginner 1-5 Professional:

(Contact: Linus Lüssing and Nils Schneider)

batman-adv: Anycast Gateway

See "batman-adv: Anycast Support (+ Gluon integration)" above.

Project "ModeM": "Anyroam" Support

A decentral, non-hierarchical, no-trusted-node implementation of the Eduroam concept. In case of routing issues to the internet, this would allow a user to choose alternative exit points.

Technically, implement this through WPA-EAP and snooping the domain provided in the unencrypted username of an EAP message. Create an L2TP tunnel to the target domain and forward WPA-CCMP frames to the according destination.

Standardize/document the protocol requirements so that VPN providers can implement it independently.

Brainstorming + links here: https://pad.freifunk.net/p/WPA-over-IP

Useful Skills:	Network and Linux kernel coding experience, WPA-EAP experience
Type of Work:	Programming, Documentation
Programming Languages:	C
Possible mentors:	_
Level from Beginner 1-5 Professional:	5

(Contact: Linus Lüssing)

autoupdater-ng

Improve the current autoupdater in Gluon to allow:

• Switching the routing protocol
• Changing wifi settings

As this affects many nodes and users, care needs to be taken to implement it in a robust way.

The current suggestion is:

• If normal updating via the mesh fails:
  • Scan neighborhood for nodes
  • One by one, try connecting to a neighbor node as an STA and try fetching an update there until retrieval was successful
  • Update router.

Useful Skills:	Experience with embedded devices and OpenWRT/LEDE
Type of Work:	Programming, testing
Programming Languages:	Lua
Possible mentors:	_
Level from Beginner 1-5 Professional:	3

(Contact: Linus Lüssing)

Rhizomatica

Extend BotRf to draw coverage maps

BotRf is a tool for the electromagnetic spectrum analysis of Terrain, loss, and RF Signal Propagation that run on Telegram Messenger: https://github.com/tvwsanalyzer/BotRf_telegram_bot_manager When you give it two coordinates, it gives you the fresnel zone of a point to point link. The project seeks to extend it's functionality to build heat maps of RF coverage. This can be used for wireless mesh networks, GSM networks and TVWS networks.

The scope of this proposal is:

• understand how the current bot works
• implement a function that receives the parameters of the coverage map, and returns the graph
• add a function to the telegram bot that makes the dialog happen
• potentially implement a webapp to access the same information
• potentially deploy it locally instead of in the cloud

Useful Skills:	Rf signals
Type of Work:	Coding
Progamming Languages:	Python
Possible Mentors:	Gui, Pau
Level from Beginner 1-5 Professional:	3 Intermediate

LibreMesh/LibreRouter

lime-webui: port to LuCI2

LibreMesh Web Interface is based on of LuCI framework. LuCI developers has decided for a complete rewrite of the LuCI concept and framework, this effort is called LuCI2 and is not retro-compatible with the plain old LuCI. As new OpenWrt/LEDE releases will ship with LuCI2, we need to migrate LibreMesh components depending on LuCI, to LuCI2. By far LibreMesh Web Interface is the most affected component of our meta-firmware, so the aim of this project is to port it to the new framework.

Useful Skills:	JavaScript XHR, OpenWrt/LEDE, Ubus, JSON, LibreMesh
Type of Work:	Coding, Web design
Progamming Languages:	JavaScript, HTML5, Lua
Possible Mentors:	Gui, Pau
Level from Beginner 1-5 Professional:	3 Intermediate

lime-system: Modules Runtime Dependencies

LibreMesh meta-firmware aims to be highly modular, and in fact almost all parts it consist are split into modules. Some modules depends at runtime on the fact that another module has already run, nowadays this condition is not guaranteed and depends on how configuration files are written, but this imply that an user can break things involuntarily. Implementing a runtime dependency check system would avoid troublesome situations, it have to be light, fast, and simple keeping in mind that will be installed on embedded devices with as little as 4MB of flash.

Useful Skills:	OpenWrt/LEDE, UCI, GNU/Linux System Administration, LibreMesh Architecture
Type of Work:	Software Architecture, Coding
Progamming Languages:	Lua
Possible Mentors:	G10h4ck
Level from Beginner 1-5 Professional:	4 Semi-Professional

lime-system: Test and Save mode

LibreMesh 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 missing on most OpenWrt/LEDE based free firmwares, so we are willing to mentor a student to implement this in LibreMesh.

Useful Skills:	OpenWrt/LEDE, BusyBox, LibreMesh Architecture
Type of Work:	Software Architecture, Coding
Progamming Languages:	Lua, ash
Possible Mentors:	G10h4ck, Gui
Level from Beginner 1-5 Professional:	4 Semi-Professional

lime-system: Configuration Validator

LibreMesh meta-firmware configuration system is highly flexible and powerful, this is very useful for experienced user, but an inexperienced 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/LEDE, GNU/Linux System Administration, LibreMesh Architecture
Type of Work:	Software Architecture, Coding
Programming Languages:	Lua
Possible Mentors:	G10h4ck
Level from Beginner 1-5 Professional:	4 Semi-Professional

LibreMesh NetJSON Agent

LibreMesh has support for monitoring via LibreMap agent since years, nowadays NetJSON is emerging as common format to exchange networking information between community networks actors, since the inception of NetJSON. LibreMesh community has been supportive of this effort and now that NetJSON gain momentum we think is the right moment to implement NetJSON based monitoring as a module of LibreMesh firmware.

Useful Skills:	OpenWrt/LEDE, GNU/Linux System Administration, uBus, NetJSON
Type of Work:	Coding
Programming Languages:	Lua, ash
Possible Mentors:	G10h4ck, Nemesis, Nico
Level from Beginner 1-5 Professional:	3 Intermediate

LibreMesh based Battle Mesh testbed

In latest years to collect relevant data at Wireless Battle Mesh has been an hard challenge and in some cases a failure. A big part of its community agrees that not having a well tested firmware for the testbed has been a big hindrance to successful testing and data collection. Past tentatives of creating a testbed based on WiBed have failed too, apparently due to lack of maintenance. While LibreMesh hasn't been designed with testbeds in mind, thanks to its high modularity and flexibility troughs years it has gained most of the needed features for a testbed firmware, as a plus it is actively maintained by a conspicuous and heterogeneous developers community from different community networks in the world that participate to Battle Mesh, all propitious factors for a satisfactory Battle Mesh.

To accomplish this project a student must:

• Learn the basics of LibreMesh software architecture
• Complete the implementation of lime-proto-babeld
• Prepare compilation profiles for lime-build or Chef for each test
• Document how to use the created firmware images to run scientifically valuable tests
• Document how to extend testbed to collect new kinds of data
• Document how to add support for testing of new protocols
• Eventually demonstrate progress at next BattleMesh
• Eventually create lime-proto modules for new protocols that need testing

Useful Skills:	OpenWrt/LEDE, Ubus, LibreMesh
Type of Work:	Software Architecture, Web design
Progamming Languages:	Lua, ash
Possible Mentors:	G10h4ck, Gui, Pau
Level from Beginner 1-5 Professional:	4 Semi-Professional

LibreMesh LibreNet6 integration

LibreMesh already does extensive use of IPv6 technology, we even have an IPv6 mesh tunnel broker provider based on Tinc VPN. It works very well but configuring the tunnel is a manual work that requires specific skills which are not common in the majority of communities. Because of this, communities often are not taking advantage on IPv6 while their routers already support and make good use of it.

To solve this issue a student will have to:

• Design a semi-automatic system to grant access to trusted routers to LibreNet6 (this may include key exchange)
• Code a tiny LiMe module that take care of tunnel configuration

Useful Skills:	OpenWrt/LEDE, Tinc VPN, LibreMesh, IPv6
Type of Work:	System Architecture, Coding
Programming Languages:	Lua, ash
Possible mentors:	G10h4ck, Gui
Level from Beginner 1-5 Professional:	3 Intermediate

Improve Easy Internet Sharing in LibreMesh

Up to now LibreMesh is able to detect IPv4 internet availability via Watchping, written specifically for LibreMesh, and to share it automatically with the rest of the community network.

A bunch of users who share their internet connections report some limitation with the current system, the scope of this proposal is to:

• Do a viability study of the migration from Watchping to Pingcheck or other more sophisticated and modular upstream connectivity checking system taking in account that some upstream connections fake ICMP ping responses but do not provide internet access.
• Eventually port the lime-*-auto-gw-mode packages to the new gateway checking system.
• Implement missing lime-*-auto-gw-mode modules for newer supported protocol (Babeld, OLSRd, OLSR2).
• Implement an easy to use QoS system for prioritizing traffic from node owner to local WAN.
• Implement/integrate a lite captive portal/splash page solution into LiMe

Useful Skills:	OpenWrt/LEDE, Netfilter, Traffic Control, LibreMesh
Type of Work:	System Architecture, Coding
Programming Languages:	Lua, ash
Possible mentors:	G10h4ck
Level from Beginner 1-5 Professional:	4 Semiprofessional

Spectrum Analyzer

The Atheros radios used in LibreRouter (and many of the OpenWRT/LEDE supported hardware) have a feature that allow to measure how much each frequency is used, but until now this feature has not been used in open firmwares. This feature enable us to create a Spectrum Analyzer which will allow anyone to pick the best (least used) channel and to understand how the frequencies are being used in the area.

Also, with LibreRouter's TV WhiteSpace module, the 2.4Ghz radio will also work on the TV White Space band, so it will be able to do Spectrum Analysis on those frequencies too. This is an innovative approach because we will be able to know which frequencies are being use in a dynamic way and maybe peek the one that is less used also dynamically.

The scope of this proposal is:

• Implement a library that can interact with the radio module and retrieve the information in a usable way
• Implement an interface for LuCI/LuCI2 to see how the frequencies are being used.
• Implement an export/import function so we can see what was read on a specific moment.
• Implement the translation between 2.4Ghz and TVWS frequencies inside LuCI.
• Implement tests to ensure that the possible scenarios are tested

Useful Skills:	OpenWrt/LEDE, LibreMesh, Web development
Type of Work:	System Architecture, Coding
Programming Languages:	Lua, C
Possible mentors:	nicopace <nico+gsoc@libre.ws>
Level from Beginner 1-5 Professional:	3

TVWS Database Server and Client

The TVWS (TV White Space) has been mostly freed thanks to the massively implementation of Digital Television Worldwide. The frequency that got freed is available to use, and it is a very flexible one because it allows to do non-line-of-sight links, so many remote communities will be able to get connected with this new technology. Some governments started regulating the use of these new frequencies creating TVWS Databases: this allows for dynamic use of the spectrum, by asking a server if it can give a frequency for a period of time on a specific place. We want LibreRouter to be part of this dialog, and to standardize the way that TVWS Database servers, clients and reporters (the software that reports spectrum usage) communicate.

The scope of this proposal is:

• research what needs to be stored (probably geolocation and signal power: a signal stronger than a threshold will be consider as occupied, lower will be free)
• design a methodology to age the information retrieved (when a specific data is not usable anymore and needs to be discarded when deciding if a frequency is available)
• implement a reference server that will lease frequencies on request
• implement a reference client that will talk with the the server to request leases of a frequency and bandwidth based on a geolocation
• implement a reference reporter that will report frequency usage to the server

Useful Skills:	OpenWrt/LEDE, LibreMesh, Radiowave understanding
Type of Work:	System Architecture, Coding
Programming Languages:	Lua, C
Possible mentors:	Gui, nicopace <nico+gsoc@libre.ws>
Level from Beginner 1-5 Professional:	4-SemiProffesional

LibreMesh WPA2 and 802.11s mesh encryption support

LibreMesh meta-firmware is designed for creating open and free wireless mesh networks. Up to now the encryption of the traffic is left to the upper layers (VPN, HTTPS, etc). Thanks to its modularity and flexibility LibreMesh can be used for setting up a private mesh network just adding encryption in mesh and AP-client LibreMesh components. Regarding the mesh side: as encryption for adhoc is not considered mature yet, a switch to encrypted 802.11s (plain 802.11s is already supported) or WPA2 protected AP-sta backbone are the two options to be implemented. WPA2 would also be used for securing the client-to-node communications.

Useful Skills:	LibreMesh Architecture, OpenWrt/LEDE
Type of Work:	Coding
Programming Languages:	Lua
Possible mentors:	G10h4ck
Level from Beginner 1-5 Professional:	3 Intermediate

LibreMesh Captive Portal and Access Control

In order to make LibreMesh community networks sustainable, we need a system to provide internal communication - such as the captive portal page. This page should work even in cases where the Internet connection is down, so people can check its status and know how to use local applications.This can be done by forking nodogsplash to create a lime version. Also, in order to charge maintenance fees or taxes, there should be some personal access control. There is a validation shell script written by Gui that can be easily rewritten in C. Besides, all these features need user-friendly Lua interfaces.

Useful Skills:	OpenWrt/LEDE, UCI, GNU/Linux System Administration, LibreMesh Architecture
Type of Work:	Software Architecture, Coding
Progamming Languages:	Lua, C
Possible mentors:	?
Level from Beginner 1-5 Professional:	3 Intermediate
Contact:	bruno at pobox.com

Netmon Software Compilation

The Netmon Software Compilation is a web based client-server environment for monitoring and administration of free networks. It comes with an https://git.ffnw.de/netmon-sc/api-server API-Server] as the central piece of software that has been developed using the Laravel PHP framework. The server provides a staleless REST API using the json:api format. Alongside this several client applications have been developed for data-collection, -visualization and -administration. Client applications to mention are the Web-Client developed using the Angular 2 and Material 2 frameworks and the Node-Client developed for the Gluon firmware stack using the LUA scripting language. The initial versions of the mentioned software have developed as part of a bachelor thesis at University Osnabrück and where release in version 1.0.0 in January 2017. The environment is currenty prepared for production use in the Freifunk Nordwest community.

Administration and monitoring of region based network segments

Background: several free network communities using routing on layer 2 (B.A.T.M.A.N. advanced) have split up their network into different region based network segments (hoods) to lower their layer 2 management traffic. Each hood contains about 100-300 network devices (nodes). A new device plugged in by a user determines it's hood automatically using a prepared list of hoods (hoodlist) and a small software called the hoodselector which has been developed as a side project in GSoC 2016. If the maximum number of nodes that fit into a hood is reached, a hood can be split up into multiple new hoods. Communities using this kind of technology are Freifunk Franken and Freifunk Nordwest. Several tools exist to prepare an updated hoodlist and watch the status of a hood. But all of these tools require a lot of knowledge and manual interaction.

Your project: your project will be to extend the existing Server and Web-Client with a datamodel and a GUI for administration and monitoring of region based network segments. Therefore you will review our existing datamodels and learn how to extend the Netmon API-Server (Laravel) and Web-Client (Angular 2) using the module pattern. Goal of the project ist to have a Server and a GUI module that can be used to replace the existing software in production mode by the end of GSoC.

Measurable outcomes:

* Datamodel for implementing the Netmon API-Server module
* Netmon API-Server module
* Netmon Web-Client integration

REST, Laravel, Angular 2, Material 2|

Data model design, implementation|

PHP, Typescript, Javascript|

Clemens John|

3|

Modules for data vizualisation

Background: devices regulary update their status pushing a bunch of interesting data to the Netmon API-Server. We want to not only get a historical view on this data but also visualize other interesting coherences we have in our database to answer questions like "can we build a link between those two antennas?" (landscape profile).

Your project: your project will be to prepare an overview of existing time series databases for our requirements. Then you will build a module for the Netmon API-Server that forwards all the interesting data we collect to an external tool that can store and provide time series to clients (i.e. RRD, Graphite, Prometheus). A big goal will be to do this disk utilazation friendly. In the next step you will get your hands on the Web-Client and display the collected data in nice client side rendered graphs. If time permitts we will do some research on other things to visualize like drawing fresnel zones between two landmarks like WiND does using NASA SRTM data.

Measurable outcomes:

* Requirements analysis
* Overview of existing tools
* Netmon API-Server module
* Netmon Web-Client integration
* Research on other vizualisation tasks

Data Visualization, Laravel, Angular 2, Material 2|

Research, implementation|

PHP, Typescript, Javascript|

Clemens John|

2|

Ninux

Convert netengine output to NetJSON DeviceMonitoring

netengine is an abstraction layer for extracting information from network devices. It was developed prior to NetJSON and it has helped us understanding that we needed a common format like NetJSON.

Measurable outcomes:

• Change the JSON output to match NetJSON DeviceMonitoring
• Implement mocking in tests
• Add compatibility for OpenWRT Chaos Calmer, Designated Driver and LEDE
• Add compatibility for AirOS 7
• Update the documentation contained in the repository

Useful Skills:	Python, networking
Type of Work:	Programming
Progamming Languages:	Python
Possible mentors:	Federico Capoano
Level from Beginner 1-5 Professional:	3

Ansible plugin for netjsonconfig

Ansible is an IT automation tool that has been recently gaining popularity also in the OpenWRT world. We want to implement an ansible plugin that integrates netjsonconfig and allows using its two most interesting features, templates and context, in ansible. It should be possible to define configuration templates, assign them to specific playbooks and define specific configurations for hosts. The configuration format format used by netjsonconfig is NetJSON DeviceConfiguration, but a YAML conversion of NetJSON would be good as well. Support for both would be preferred.

Measurable outcomes:

• Implement an ansible module that integrates netjsonconfig in ansible and allows using NetJSON DeviceConfiguration (or its YAML equivalent) to configure OpenWRT devices
• Achieve a test coverage higher than 80%
• Provide documentation in python-sphinx format

Useful Skills:	Python, ansible
Type of Work:	Programming
Progamming Languages:	Python
Possible mentors:	Federico Capoano
Level from Beginner 1-5 Professional:	2

Netjsongraph.js: canvas and geographic data

netjsongraph.js is a javascript library based on d3 that allows visualization of NetJSON NetworkGraph objects. The library uses SVG for visualization, which can be quite slow when many elements are shown, therefore we would like to try switching to canvas. We also need an optional mode in which the network is displayed on a map.

Measurable outcomes:

• Rewrite the visualizer to use canvas
• Add an optional map mode
• Modernize javascript code organization: you may want to use some modern JS tool for building the library, you may rewrite the code in ES6, up to you
• Update documentation and examples in README

Useful Skills:	Javascript, CSS, ES6
Type of Work:	Programming
Progamming Languages:	Javascript
Possible mentors:	Federico Capoano
Level from Beginner 1-5 Professional:	2

Node building coordination Web platform

Building a community network node is often a task that cannot be accomplished by a person alone. The typical process of node building in the ninux.org community network goes through the following phases:

1. the future node owner performs a survey of the location (i.e. the roof of her house/building) and takes pictures
2. the feasibility of the node building and the establishment of links to other nodes is assessed by other members of the community network
3. if it's feasible, the node owner buys the devices to be installed (or takes them from the community network common pool)
4. the node installation is planned in advance: the tools to use, the hardware (poles, ties, etc.) to employ, the number of people needed to perform the installation (help from other community network members is essential for node installation)
5. a date and time is decided for the installation

Today community network members use a set general purpose online tools (e.g. mailing list, doodle, chat) to schedule and organize node installations. This can be sometimes frustrating as it might be difficult to get an overview and track the user activities.

We believe that the development a Web platform targeted to the specific purpose of coordinating and planning node building could benefit all community networks over the World. The platform should:

• allow the future node owner to create a description of the node installation environment (location on the map, survey pictures, links) and a target number of volunteers to help
• allow to choose a common date, time and place between the node installation participants for the node installation
• allow interaction (e.g. comments) between node installation participants
• allow a global view of the number of missing volunteers to reach the set target for each node installation, so that others willing to contribute can jump in
• allow the export a calendar (e.g. in ics format) with the scheduled installations

Useful Skills:	Web development
Type of Work:	Design and programming
Programming Languages:	Python/Django
Possible mentors:	Claudio Pisa (ninux.org)
Level from Beginner 1-5 Professional:	3-4

Implementing Pop-Routing in OSPF

Any routing protocol for mesh networks periodically generates control messages to perform link-sensing and to give to other nodes enough information to build their routing tables. The timers used to generate these messages determine the convergence speed of the routing protocol (smaller timer implies faster convergence) and the total amount of overhead in the network (larger timer implies less wasted resources).

All the most common routing protocols support the generation of these messages with a dynamic and customized timer, but in practice, all of them set their timers to a static value decided in the configuration file based on the experience of the person deploying the node.

Recently, Pop-Routing was introduced [1], a technique to auto-tune the timers for control message generation in an dynamic and optimized way. Pop-Routing exploits the knowledge of the full topology in link-state protocols to compute the timers for each node optimizing the trade-off between fast convergence and generated overhead. Pop-Routing uses node centrality to compute the optimal value, currently, an open-source library implementing state-of-the art centrality algorithms is under development at the University of Trento [2].

Thanks to the GSoC 2016 we have implemented Pop-Routing for the OLSRv2 routing protocol [3]. Prince is a network daemon that continuosly monitors the network topology and sets the timers for OLSRv2, it is developed in C and we are currently deploying it in the Ninux community network in Florence. This year we want to implement Pop-Routing for another link-state routing protocol: OSPF. OSPF is the state-of-the-art interior routing protocol for wired networks and it is used also in some wireless community networks. This project consists in realizing a plug-in of the OSPF open source routing daemon (Quagga or Bird) that will: 1 export the network topology and push it to Prince 2 receive and re-set the network parameters from Prince

Useful Skills:	OSPF, OLSR, good C/C++, OpenWRT
Type of Work:	Programming
Progamming Languages:	C/C++
Possible mentors:	Leonardo Maccari [4]
Level from Beginner 1-5 Professional:	4

api.freifunk.net

update api schema to json schema v5 draft

When we created the freifunk API some years ago, json schema v3 draft was en vogue. If you want to know more about the freifunk API, see https://api.freifunk.net

Goal is to update our schema and the depending tools to the newer v5 draft. The schema version is already contained in our schema files. So tools that use these schema files can be backwards compatible until every community updated their api files. The api viewer contains a validation of api files: https://github.com/freifunk/viewer.api.freifunk.net/blob/master/render.py#L76 This should be used in the community collector, too.

Tools we created are:

• API generator to generate a new API file: https://freifunk.net/generator
• the community map: http://community.freifunk.net
• RSS feed aggregator
• community collector (to collect all api files and summarize it)
• the api viewer
• betterplace donations table
• freifunk-karte.de
• more to find.

a lot of these tools use the summarized file produced by the community collector.

analyzing, coding |

identify components that must be changed, refactoring, migrations|

javascript, python, php, wordpress plugins |

Andi Bräu|

3|

WIFI GeoLocator

Based on the first work of Freifunk Nordwest Geolocator ( lwtrace libwlocate), create a new WiFi Geolocator, that supports multiple Wifi Geolocation Services. (openwifi.su, Mozilla Location Service, etc...) This gives the chance to a device to determine the position based on the WiFi Networks around him. Without having any GPS Reciver Connected

Goals should be:

• Deliver Information in NEMA 0183 Format on a virtual tty
• It should work on LEDE
• New Wifi Geolocation Service Support should be added easily and fast
• A Proxy Application for https Services if Space for SSL Library is not available on a small device, so communication is working between the device and the proxy only over http
• Unit Tests for your code

Useful Skills:	analyzing, coding, basic understanding of GPS, LEDE, WLAN, Linux
Type of Work:	Programming Services for Linux Based devices, Analyzing different GEO Location APIs
Programming Languages:	c, lua, javascript... what ever you maybe need
Possible mentors:	Johannes Rudolph
Level from Beginner 1-5 Professional:	That depends ;-) 3-4

Project: wlan slovenija - open wireless network of Slovenia

wlan slovenija is an informal country-wide initiative from Slovenia which works mainly on building open and free community wireless networks in a bottom-up approach, encouraging people to build their common network with use of their own common computer network infrastructure, mostly using consumer products.

Flagship application of wlan slovenija development is called nodewatcher and it is an open source system for easier planning, deployment and maintenance of the network. It is a centralized web user interface which enables easier coordination and planning of a network with monitoring at the same time. Furthermore it is also a web based image generator that generates a customized image for a given network node, so no node configuration after flashing is necessary.

nodewatcher: Node data matrix comparison module for nodewatcher

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.

Useful Skills:	Django, web programming, visualizations
Type of Work:	Programming
Progamming Languages:	JavaScript, Python
Possible mentors:	Mitar, mitar at https://chat.wlan-si.net/, or @wlan-si.net
Level from Beginner 1-5 Professional:	3

nodewatcher: nodewatcher API and datastream query builder

nodewatcher collects a lot of data from nodes and exposes it through an API called datastream. Moreover it provides API to access its registry of nodes. Both APIs are powerful, but building queries against them requires a lot of knowledge.

Currently various ndoewatcher modules consume this data and make hard-coded queries to display it. The issue is that there is much more data available then currently displayed, but also not everything is interesting to everybody. Moreover, manually building URLs for queries against is complicated. So, the idea is to create a web interface for the query builder where users could create their own query by combining available fields, filters, sorting, and ways to display data. If they are satisfied, they could also store the query for others to use it.

Inspiration can be taken from Trac query builder and how it allows to store made queries as reports.

This will probably be mostly a JavaScript client-side implementation, but reading and understanding the server-side API is also needed.

Useful Skills:	Django, web programming
Type of Work:	Programming
Progamming Languages:	JavaScript, Python
Possible mentors:	Mitar, mitar at https://chat.wlan-si.net/, or @wlan-si.net
Level from Beginner 1-5 Professional:	3

nodewatcher: Overview of used IP space module

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.

Useful Skills:	Django, web programming
Type of Work:	Programming
Progamming Languages:	Python, JavaScript
Possible mentors:	Jernej Kos, kostko at https://chat.wlan-si.net/, or @wlan-si.net
Level from Beginner 1-5 Professional:	3

nodewatcher: SNMP support for monitoring

Currently nodewatcher uses its own HTTP-based monitoring protocol. But this requires custom firmware on the node. It would be great if nodewatcher could support devices in the network which simply publish data using SNMP.

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. Understanding of SNMP is a plus.

Useful Skills:	Web programming, SNMP
Type of Work:	Programming
Progamming Languages:	JavaScript, Python
Possible mentors:	Jernej Kos, kostko at https://chat.wlan-si.net/, or @wlan-si.net
Level from Beginner 1-5 Professional:	4

Improving Rocket.Chat for use in community networks

Rocket.Chat is an open source chat platforms. In cooperation with Rocket.Chat project you can also see two ideas of improving Rocket.Chat use in community networks:

• Rocket.Chat on mesh networks
• Creating channels based on which node you are connected to in the mesh network

Check out the longer description of ideas on Rocket.Chat ideas list.

Retroshare – secure communication software

Retroshare is a cross-platform secure Friend-to-Friend software that creates a network over a mesh of computers connected through TLS-encrypted links. On top of the network it provides generic and secure data distribution methods: authenticate/anonymous tunneling, and a generic database distribution system called GXS. This year will be the year where GXS is opened to plugins so that people can define their own services while benefiting from the automated and flexible distribution mechanism. Some of the projects proposed below cover the creation of such services in the form of new plugins. The rest of them are important milestones in the roadmap of significantly improving the software. Among last year's proposals, one has been fully implemented (differential file lists system) and will be released soon, another one in currently under development (unified email system).

Links:

• Web page: https://retroshare.net
• GitHub repository: https://github.com/retroshare/retroshare

Contacts:

• Cyril Soler: csoler - [at] - users - [dot] - sourceforge - [dot] - net
• electron: electron128 - [at] - yahoo - [dot] - com

Wall/blog plugin based on GXS

Retroshare contains a generic distributed database system (called GXS) which allows to share data between nodes, in a way that is cryptographically secured (database access may be limited to circles of people, etc). This database system is currently used for distributing forums and channels over the network. The GXS system also offers the possibility to respond, submit comments, and vote over posts. We would like to use it to create a service that allows users to create a blog-like service, to which friend nodes subscribe so as to propagate the info over the network. Depending on the student's skills and motivation, such a plugin could offer one of the following similar services: twitter (distributed micro-blogging), blog (distributed blogging), Wall (facebook style information sharing).

Things to be implemented:

• plugin interface to the backend. Needs to properly define how to represent objects (posts, responses, comments) by which GXS components.
• GUI for the Wall/Twitter/Blog service (preferably Qt. Could be Json+web, but would add some complexity)
• backend service, based on GXS interaction handles

This is not an easy project, since GXS internals are hard to understand in the first place. But the devs are highly motivated to get it done.

Useful Skills:	High level C++ knowledge, Qt
Type of Work:	Discuss/create concept, implement Wall GXS service, implement graphical display.
Progamming Languages:	C++
Possible mentors:	Cyril Soler, Electron, G10h4ck
Level from Beginner 1-5 Professional:	4-5

A calendar/task GXS-based plugin

This the typical plugin that one would like to have when using Retroshare in a professional environment. The work consists in first representing the various calendar/tasks objects into GXS components. Then it needs to implement the calendar GXS service which will serv as an interface between the GXS distribution system and the UI. Finally it needs to implement a minimal Qt UI to display and manage calendar events. Optionally, to provide an API in a standard calendar format, so that people can use their own UI/client software to display the events.

The service will manage publishing/creation rights over the calendar events,

Useful Skills:	High level C++ knowledge, Qt
Type of Work:	Discuss/create concept (and get familiar with GXS), create the appropriate GXS-based objects, implement calendar GXS service, implement a minimal graphical display.
Progamming Languages:	C++
Possible mentors:	Cyril Soler, G10h4ck
Level from Beginner 1-5 Professional:	4-5

Retroshare web interface

The software already has a preliminary web interface, but it covers only the very basics of the software interactions, and does not benefit from the nice graphical look it should have. This project is probably the easiest of all, since the software already implements a partial json API to join the software internals and the html requests from the browser, but it still represent a lot of work as the software currently offers a lot of GUI handles in its Qt version that would need to find an equivalent functionality in the web interface version.

By order of priority:

• improve the web UI for file transfers (it is extremely basic now), adding/removing friends, showing internal statistics, etc.
• implement the web UI for configuration options
• implement a nice looking CSS for the web UI

Useful Skills:	C++, JSon, Qt
Type of Work:	Extend JSon API, design new CSS.
Progamming Languages:	C++
Possible mentors:	Cyril Soler, Electron, Zener
Level from Beginner 1-5 Professional:	2-3

Implement a Markup Language Text editor/display for Retroshare

Most of user-input texts in the Retroshare software are supplied to the backend as HTML by Qt. Although it offers a lot of possibilities, it is also a double weakness both in terms of security and CPU-efficiency. The plan is therefore to implement a markup language (ex. a subset of AsciiDoc) translation which would ensure that a only minimal set of features can be represented and displayed (namely emoticons, links, images, font-style (bold, italic...).

This project will need to:

• Define a new text editing widget/component that has the needed buttons and options to handle markup text (e.g. link and image insertion).

The widget should:

• Accept markup text to be displayed and convert it internally into proper HTML that Qt will understand
• Allow the user to get the markup text generated by the widget.
• Possibly ensure some minimal backward compatibility with the existing data.

Useful Skills:	High level C++ knowledge, Qt
Type of Work:	Discuss/create concept, implement new widget (independently), insert it in Retroshare.
Progamming Languages:	C++
Possible mentors:	Cyril Soler, G10h4ck
Level from Beginner 1-5 Professional:	3-4

Video over IP in RS

Retroshare offers the possibility to talk using Voice/Video over IP, but only as a toy system. It currently needs a skilled developer to integrate a proper cross-platform video codec that would be capable of frame-rate auto-adjustment and be robust to network delays. This is a challenging project that needs a good understanding of how VoIP works and interacts with the network layer.

Things to be implemented:

• find a suitable cross-plaform video codec
• handle auto-adjustment of bandwidth for video/sound with proper priority handling to avoid gaps
• proper GUI device selection and notifications

Useful Skills:	Good level C/C++ knowledge, Qt
Type of Work:	Digg for codecs and assess current codec limitations, integrate the new codec and add the right handles.
Progamming Languages:	C/C++
Possible mentors:	Cyril Soler, Phenom, Sehraf
Level from Beginner 1-5 Professional:	4-5

Chess/Go plugin - play between GXS identities

Retroshare v0.6 offers an authenticated/encrypted/robust tunnel system to exchange data in real time between pseudo-anonymous identities over the network. This system is already used for chatting, but it has a lot of potential. At the same time Retroshare offers a plugin system that users can leverage to create new decentralised services. The Retroshare Chess/Go project has a double tap impact: creating a simple example of a portable service plugin using the new tunnel system of v0.6, and creating a cool game interface to allow users to play Chess/Go. This project includes some GUI (which will be done in Qt) for the games, and a bit of backend to handle the interface with the tunnel system. It also needs to fit in the current plugin architecture which will be adapted if needed.

Things to be implemented:

• game data exchange service and encrypted tunnel handling
• GUI for the games
• GUI for game handling

Useful Skills:	Good level C++ knowledge, Qt
Type of Work:	Discuss/create concept, implement service to talk through tunnels, implement interaction between players and graphical display.
Progamming Languages:	C++
Possible mentors:	Cyril Soler, Jolavillette
Level from Beginner 1-5 Professional:	3-4

IPv6 Support

Retroshare 0.6.x offers interesting community primitives based on cryptography such as pseudo-anonymous identities, reputation handling and circles of friends, but it still lack IPv6 support that is a fundamental to complete the appeal with community networks.

The student should implement IPv6 support in RetroShare low level networking code in, and extend higher layer parts to support multiple kind of addressing.

Useful Skills:	IPv6, P2P, TCP, UDP, TLS
Type of Work:	Software Architecture, Coding
Progamming Languages:	C++
Possible mentors:	Cyril Soler, G10h4ck, Sehraf
Level from Beginner 1-5 Professional:	5 Professional

Censorship Avoidance

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 painlessly, this would be an innovative technique for a P2P network and make posing serious cost effectiveness threats to a potential censor.

Useful Skills:	HTTP, TCP
Type of Work:	Software Architecture, Coding
Progamming Languages:	C++
Possible mentors:	Cyril Soler, G10h4ck, Sehraf
Level from Beginner 1-5 Professional:	4 Semi-Professional

qaul.net – Mesh Network Communication App

qaul.net is a self configuring mesh network communication app. qaul.net is compatible with any OLSR based community network – Community templates for various Freifunk are already in the program. The application is running on Linux, OSX, Windows and Android. All services are fully decentralized and independent of any centralized services. Over the whole network the following communication services are available: user discovery, one to all messages, one to one chat, file sharing, VoIP sip calls. The qaul.net user iterface has been translated so far to nine languages. Even without running the app, one can connect to the network over Wifi and communicate via a web interface – delivered via captive portal - over it.

Links:

• github repository: https://github.com/qaul/qaul.net
• web page: http://qaul.net

qaul.net: Enhanced Android App

The qaul.net android client needs to be much more Android like. There also needs to be

The following features should be implemented:

• split the app into a background service and a UI frontend which are communication via JSON.
• show if qaul is running in the android top bar. make android startable and stopable from there.
• make qaul app self aware and show the information to the user
  • is the phone rooted?
  • which wifi configuration possibilities are available, which one has been chosen.
  • which hardware and drivers has the system the app is running on.
• make files sharable from within the other android apps.
• show message notifications.
• create a possibility to create a bluetooth network without being root.

Useful Skills:	Android programming knowledge
Type of Work:	explore bluetooth networking possibilities, implement Android services
Progamming Languages:	Java, C, HTML5
Possible mentors:	Math Jud, Christoph Wachter & others from the qaul.net community
Level from Beginner 1-5 Professional:	3

qaul.net: Asynchronous Messaging: Message History Update, Late Delivery & Offline Routing

One to all messages are flooded over network (using OLSRD flooding mechanism), private messages are sent directly to the receiver via TCP. Is the user not reachable, he won't get the message. There should be a possibility to receive an update on public messages from once neighbours when having access to the network. Further there needs to be a local message storage for direct messages that are delivered automatically when this person comes online.

Additionally could a system be implemented that manages direct messages completely connection less. Automatically guessing the best paths for these messages. There is the possibility for message deliverers such as mobile stations on bikes, cars, etc.

Tasks:

• Develop concept for message synchronization
  • How is a message identified (eg. ID based, hash based, time based, sender based)
  • How is the message history synchronized with other users
• Implement the concept
  • Poll updates from neighbours
  • Advertise updates
  • search for messages in network by Hashtag
• Create late delivery storage for messages
• Create a concept for offline routing (e.g. delay tolerant networks)
  • For the situation when a device is moving and a message could travel on that device from network segment A to network segment B

Useful Skills:	Basic C knowledge, Web technology
Type of Work:	Discuss/create concept, implement message ID mechanism, implement synchronization mechanism.
Progamming Languages:	C
Possible mentors:	Math Jud, Christoph Wachter & others from the qaul.net community
Level from Beginner 1-5 Professional:	2-3

qaul.net: WebRTC VoIP Communication via Web Client

Every qaul.net application offers the possibility for other users to communicate over it via a web interface. At the moment, the web interface offers only limited functionality. This could be extended to have a full featured web client. The most interesting feature would be to have a web based VoIP solution. qaul.net is using pjsip for VoIP. The library has experimental WebRTC support.

Tasks:

• Implement WebRTC client to communicate with the running pjsip server.
• Implement the call handling of the web clients in to the pjsip server.
• Implement locally saved user user ID

Links:

• Pjsip library: [5]

Useful Skills:	Basic C knowledge, Web technology
Type of Work:	Discuss/create concept, implement sharing mechanism, generate plugin API, generate plugin management create a sample plugin
Progamming Languages:	C, HTML5
Possible mentors:	Math Jud, Christoph Wachter & others from the qaul.net community
Level from Beginner 1-5 Professional:	3-4

Firmware Deployment Toolbox

The configuration and initial flash process to install new Freifunk routers is a time consuming part of any new deployment. With this proposal we want to create a software toolbox to automate the initial flash and configuration process in order to speed up the deployment of new Freifunk nodes for everybody. Our toolbox proposal consist of two student project: (I) the development of a firmware flash tool to provide an easy and fast initial firmware flash tool and (II) the development of a configuration tool to provide a convenient interface to apply configurations to LEDE/Openwrt routers. In order to use the toolbox independent from any OS, both projects build upon a Vagrant container concept.

Links:

• TBD

Firmware Image Flash Tool

The goal of this project is to automate the initial LEDE/OpenWrt firmware flash process from manual system upgrade instructing the routers default web interface by hand to an automated flash process. After unboxing a new router, it should be plugged via Ethernet to the machine running the Firmware Image Flash Tool and the tool flashes the selected firmware image by either automated web interface controls or tftp without further user interaction. As an extended feature, we plan to extend the image flash capabilities to use a mac-vlan capable switch in order to flash multiple routers in parallel.

The following features should be implemented:

• automated flash script via Bash/Curl/Expect to transfer and flash a LEDE/OpenWrt image to a fresh router
  • supported router platforms to begin with are: TPLink CPE510, CPE210, TPLInk 703n, 810n, 1043n
• provide a Vagrant image with the flash tool included and a user friendly image management interface

Useful Skills:	Scripting knowledge, GNU/Linux System knowledge.
Type of Work:	Implementation of a LEDE/OpenWRT firmware flash tool to automate the initial router flash process
Progamming Languages:	Bash, Expect
Possible mentors:	Thomas Hühn (aka Bluse) Email: thomas@inet.tu-berlin.de
Level from Beginner 1-5 Professional:	3

LEDE/ OpenWrt Configuration and Management System

In this project, we plan to build an OpenWrt device management and configuration system which leverages OpenWrt’s rpcd/ubus interface through uhttpd. Specifically, configurations and files will be managed via uci and rpcd-mod-file, e.g., to write ssh keys, set wireless channel etc. Moreover, the system will provide a web UI to configure OpenWrt-based devices individually or through templates. We plan to implement different discovery mechanisms: preconfigured DNS name, as a DHCP option, and via nDNS. While there is already a simplistic proof-of-concept version, the system will be extended to show information such as configuration status of the different devices, number of users, WiFi channel on a dashboard. Through the dashboard, an operator can identify the configuration status of the OpenWrt device and to provision APs. Additionally, there will also provide a plugin to automatically add OpenWrt devices to an Icinga2 monitoring system for Monitoring of specific Ports, Services etc.

Useful Skills:	Knowledge of UCI, ubus, rpcd, basic network design, Python and JavaScript programming
Type of Work:	Software development
Programming Languages:	Python, JavaScript, Shell, JSON, Makefile
Possible mentors:	Julius Schulz-Zander (aka tabas) Email: julius@inet.tu-berlin.de
Level from Beginner 1-5 Professional:	3-4

Collect anonymised platform information to improve Freifunk/OpenWrt Development & Support

Freifunk and the underlying OpenWrt supports many different hardware platforms. The process and the focus in development and support of a certain router platform could be improved and focused by knowing an estimate of the distribution of current hardware in use. Question like which hardware is heavily used in the field, which is end of life, which release shows the most uptime and which reboots often, what impact may cause a certain bug, etc.

We do lack a tool that enables the user to decide if he/she wants to participate in such an information service, that sends anonymised system information to a dedicated server.

Therefore general, non user-specific information about the vendor, cpu, the wireless driver, OpenWrt version, Luci & Freifunk versions should be selectable to send to a dedicated information server. First, the user must have the ability to transparently choose which information he/she is willing to share about the system. Second, we need to make sure by design, that once the user subscribes to such a service, the transport of this information is designed in such a way, that the path does not point to the actual source source of the information in any way. ` The student proposal aims to create a package for OpenWrt which can be installed and configured by the user. The user should be able to decide which information will be send to which information server. On the server side it should be ensured to have a regular and robust device and information count in place to generate valid statistics, while keeping the actual user anonymous. Therefore a transparent JSON based structure of selectable system information has to be designed and implemented and in order to anonymise the transport from the router to the server, a DNS based delivery process of the system record has to be implemented.

Similar approaches can be found for many software projects, but there is no transparent, open-source and fully anonymized implementation yet out there. A good candidate to compare in terms if transparent system information selection is the IPFire Linux distribution with its service "collect system information". The information delivery via DNS records through the hierarchical DNS system, ensures that the sender can not easy be tracked by the serves received packets.

Useful Skills:	good motivation to create a OpenWrt client and server deamon to transport system information via custom dns records
Type of Work:	Software development
Programming Languages:	Ansi C, JSON, Makefile
Possible mentors:	Thomas Hühn (aka Bluse) Email: thomas@inet.tu-berlin.de
Level from Beginner 1-5 Professional:	4-5

Guifi.net

Packet Radio implentation for ssh backup in servers

In the event of connectivity loss in a remote server, ssh-ing it is an issue. Using a packet radio appliance attached to the server would make feasible to access it during the connectivity loss and try to solve (if possible) the outage from the "backdoor" this access will provide. Currently implentation depends of several programs. The proposal is standarize it for community networks.

Useful Skills:	AX.25 protocol, GNU/Linux System Administration
Type of Work:	Programming
Programming Languages:	C++
Possible mentors:	Al Cano (guifi.net)
Level from Beginner 1-5 Professional:	4

Sensor network data management package for servers and support for web application

Sensor networks are a very interesting feature to be implemented inside community networks because we have presence in a lot of outdoor locations. Data gathered from sensor devices deployed inside the network needs to be collected, stored and displayed to be useful. Creating a package for community networks servers will automate this task. The idea is installing the package in the server, let the package find in the devices to take care of, gather the data, store in the server, cross-backup the data with other servers, display data locally and also provide it to global initiatives.

Useful Skills:	LPWAN (generic name for Low Power wireless technologies like LoRa and others), NetJSON, GNU/Linux System Administration
Type of Work:	Design and programming
Programming Languages:	Lua and Python/Django
Possible mentors:	Albert Homs and Al Cano (guifi.net)
Level from Beginner 1-5 Professional:	3-4

Maps and common representation of networks

Optical Fiber Support

There's a lot of community networks that are making links with optical fiber. We need to storage the information of optical fiber infraestructures (cables, boxes, grooves, manholes, cable chambers, poles,...), their links in our NetJSON and CNML standards and represent it in maps.

Useful Skills:	Web development, NetJSON, CNML
Type of Work:	Design and programming
Programming Languages:	Python/Django (optionally also PHP)
Possible mentors:	Al Cano (guifi.net)
Level from Beginner 1-5 Professional:	3-4

Linked Data backend model for community networks

The aim of this project is to create an ontology for community networks that could be used between them. This would provide better ways to organize, share and use the information and align their infrastructure to the principles of open data.

There are many tasks that people participating in such networks have to do such as finding potential nodes to connect to, searching available services in the net, monitoring network status, and many others. It is important that the information of the network is available to tackle this tasks, furthermore, it is better if the information is well organize in accessible formats that could be used to build applications on top.

At the bottom layer open routing and network protocols ensure interoperability among networks making it possible for machines to communicate with each other, but the standards for sharing information of higher layers are more recent.

From the information perspective we find two problems.

Each network stores it´s own information using it´s own data model, describing different aspects of it that are considered important.

Fortunately they joined efforts to develop a standard called CNML (Community Network Markup Language), and some of them such as Guifi.net

This standar has been implemented in some networks, such as Guifi.net and others libre networks as Freifunk are working on it.

Each of them stores information in their database making sometimes difficult to access directly to that information, end up looking like 'data silo'.

This is the main part of the project. It involves to migrate the actual Community Network Mark Up Language (CNML) based on XML to an ontology based model based on RDF/OWL and a triplestore.

Useful Skills:	CNML, NetJSON, RDF, OWL, ontology definition
Type of Work:	Design and programming
Programming Languages:
Possible mentors:	Al Cano (guifi.net)
Level from Beginner 1-5 Professional:	3-4

Project MultipathTCP

Add MPTCP support in LEDE/OpenWRT trunk

Goal

Build a set of 2 gigabit routers (with or without a switch) running OpenWRT/LEDE that is running a TCP intercepting proxy in order to increase the bandwith using multiple wifi bridges.

Details

1. Minimal setup can be a gigabit single port router that is connected through a gigabit ethernet switch to 2 or more wifi bridges, with the same setup on the other side. Ideally, the wifi channels used are non-interfering ones;
2. Get one version of OpenWRT/LEDE to build with MultipathTCP kernel patches (currently, the stable is 4.1, but there are some unstable 4.4 patches floating on the MPTCP mailing-list);
3. Configure iptables to intercept TCP traffic and send it to a local SOCKS proxy (SSH with HPN patches to disable encryption does the job), eventually with autossh to maintain the tunnel;
4. Install a lightweight TCP tunnel of your choice for the non-TCP traffic (glorytun for ex.);
5. OVH developed patches for their solution based on openwrt, some inspiration might be taken from there, especially improvements to the web interface for visualizing the aggregated traffic;
6. Debugging tools (speedtests) needs to be made to validate the speed aggregation (iperf on both sides);

Useful Skills:	Basic understanding of: TCP / Routing tables, OpenWRT/LEDE packaging, basic networking tools (ping, traceroute, etc...)
Type of Work:	Packaging + system administration
Programming Languages:	Shell / Makefile / C
Possible mentors:	zoobab
Level from Beginner 1-5 Professional:	3 - you have played and compiled your own Linux kernel before

Idea template

Your idea

Write some things about your idea, your project and what goals there are. Provide information and links so a student will be enabled to propose a Google Summer of Code project.

Useful Skills:
Type of Work:
Programming Languages:
Possible mentors:
Level from Beginner 1-5 Professional: