Ideas GSoC 2016

Aus wiki.freifunk.net
Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

Project: gluon, a B.A.T.M.A.N. based mesh firmware framework

Profile-based network configuration for OpenWrt

During the development of Gluon, we've noticed many times that the design concepts OpenWrt's netifd are suboptimal for the kind of network configuration we need. This includes:

  • All configuration of netifd is held in one place (/etc/config). Upgrades which need to change the default configuration must run scripts which modify this configuration, which may be difficult if the configuration has been changed by the user.
  • Configuration can't be removed when a package disappears, as no pre/postrm scripts are run on OpenWrt sysupgrades.
  • netifd's configuration is too low-level. Changing the "role" of one interface sometimes requires several complex configuration changes (see https://github.com/freifunk-gluon/gluon/wiki/Commandline-administration#mesh-on-lan for an example)
  • netifd handles too many details in shell scripts, which can use a lot of ressources (some things like handling IPv6 router advertisements require an absurd number of processes)
  • netifd doesn't support network namespaces. This requires us to deploy some ugly hacks using multiple routing tables and iptables rules to properly

separate between WAN and mesh routes. The situation is even worse for DNS servers (but this can't be solved easily using network namespaces).

We propose to create a new, profile-based network configuration system, which should provide:

  • Configuration profiles installed by packages in /lib, together with default settings mapping interfaces to these profiles. Usually, multiple interfaces can use the same profile, and in some cases, multiple profiles can be assigned to a single interface (e.g. VPN uplink and meshing on the WAN port).
  • User configuration in /etc (empty by default) allowing to override assignments and some of the profile's settings
  • Mostly- or fully-integrated network configuration daemon (systemd-networkd is a good example for this, it handles all configuration in a single process and includes a DHCP and DHCPv6 client)
  • Full support for network namespaces, for clean separation between different networks connected to a single node.

Issues this should allow to solve:

While not strictly necessary in the beginning, nice-to-have features would include extensibility (loadable modules?) and dynamic reconfiguration, which might also help solve the following:

At least some parts of this might be realized in several different ways, for example:

As some of the abovementioned issues do not only concern the configuration of netifd, but also other of its basic properties (reliance on external scripts, missing namespace support), the most promising suggested solutions would be a fork or complete replacement of netifd.

While OpenWrt would be the main target, I'd love to get something so flexible that I could also run it on my notebook ;)


Useful Skills: Programming, knowledge of network configuration APIs
Type of Work: Software development
Progamming Languages: C
Possible mentors: Linus Lüssing (Freifunk Lübeck, BATMAN)
Level from Beginner
1-5 Professional:
4

Layer 3 Roaming Daemon (l3roamd)

Freifunk networks consist of many wifi routers forming a mesh. Clients connect to these routers, all sharing the same ESSID. Most of these clients are mobile devices like laptops and smartphones without any knowledge of the underlying mesh structure. As such, they can't really perform a handover when switching to another router within mesh. This burden is placed upon the routers.

As of now, there are two established approaches:

  • Let the client rediscover the network each time (disrupting all active TCP connections, causing delays, whatsoever).
  • Simulate a big layer 2 segment by flooding all broadcast traffic (this can be optimised to some extent, but has severe drawbacks once the mesh becomes large).

l3roamd aims to address these issues by enabling roaming and handover ontop a (routed) layer 3 mesh. The basic approach is as follows:

  • a reasonable efficient layer 3 mesh protocol (babel, olsr) is deployed between all routers
  • l3roamd will, on the mac80211 layer, track a clients IP addresses and inject matching host routes into the mesh
  • l3roamd will share information with other nodes to facilitate fast handover when a client roams

As of today, there is a very hastily written proof of concept at https://github.com/tcatm/l3roamd

The goals for this project during GSoC are:

  • finalize the specification (currently found in the README)
  • implement some part of l3roamd (it's going to be multiple daemons, but it is not yet clear what these are going to be)


Useful Skills: IPv6, distributed databases, network protocol design, spec writing
Type of Work: Design and/or Implementation
Progamming Languages: C
Possible mentors: Nils Schneider (Freifunk Lübeck)
Level from Beginner
1-5 Professional:
5


batman-adv: Simple Multicast-to-Unicast Enhancements

Since not that long ago, batman-adv has gained some multicast-awareness, in that a framework to keep track of multicast listeners was added. Patches for bridge-support are currently under review. The implementation so far allows to drop multicast packets which have no listener or to send packets via unicast if only one listener is present.

The idea now is to enhance that capability by forwarding multicast packets via unicast to multiple destinations as long as that number of nodes is below a configurable threshold. (otherwise stay with classic flooding approach)

In large batman-adv and therefore layer 2 mesh networks, multicast traffic can quickly accumulate and become a limiting factor for scalability and a risk for reliability. Currently, most multicast traffic is filtered in Gluon-based mesh communities, but there are still some essential multicast types left: ICMPv6 Neighbor Discovery, Router Solicitations or MLD for instance would greatly benefit from this proposed feature.

From this feature on, there are multiple other exciting ideas, tasks and ToDos regarding multicast in batman-adv and Linux bridges which we could dive into if there is any time left in the end :).


Useful Skills: Network and Linux kernel coding experience
Type of Work: Linux kernel programming
Progamming Languages: C
Possible mentors: Linus Lüssing (Freifunk Lübeck, BATMAN)
Level from Beginner
1-5 Professional:
4


Project: Netmon-SC

The Netmon Software Compilation (Netmon-SC) is a redesign of the open wifi network administration and monitoring tool Netmon that has been used since 2009 in the Freifunk Nordwest and Freifunk Franken Community. The system architecture of the software has been redesigned as part of a bachelor thesis at University Osnabrück (WIP) and is now beeing split into a bunch of different applications for different use cases to make the whole system more customizable and maintainable. The kernel of this software compilation is the core application that provides a REST API based on the NetJSON format. This API can be used by applications to exchange data and provide solutions for common administration, monitoring and quality assurance tasks. Your goal at GSoC will be to write an application that uses the REST API and privides a solution for one of our common administration, monitoring or quality assurance tasks. Some Ideas would be:

Responsive and extendable web 2.0 user interface for Netmon-SC

Create a responsive user interface build on top of standardized web 2.0 technologies that is extendable using plugins and provides a performant and self explaining GUI for basic usecases like:

  • register a new user
  • create a new device
  • assign automatically created devices to users
  • manage devices using tags
  • visualize devices and statusdata (map, client side rendered graphs)
  • extend the application using plugins

The task will be split into three workingphases:

  • blueprint (mockups, technologie stack discussion, prototyping)
  • implementation (write code and unittests, test the application)
  • documentation and setup (your software will be used by hundreds of users afterwards and needs to be maintained for years. So documentation of all parts and a first running setup of the software is a big deal)
Useful Skills: Responsive Web, REST-API, Git, continuous integration, self explaining user interface design
Type of Work: Softwaredevelopment
Progamming Languages: Javascript, HtML5, CSS
Possible mentors: Clemens John (Freifunk Nordwest)
Level from Beginner
1-5 Professional:
3

Statusdata Aggregation Client

For aggregating statusdata of routers in the Netmon Web-API an application on the router is needed, that collects statusdata and sends it to a web api. We already have an old application written in bash that can be taken as example. The goal of this task is to write a new application for collecting statusdata. This application should run on a basic OpenWRT systems with low memory. Therefore the application should be written in C or LUA and should be able to communicate with a JSON REST API. Some common tasks of this software would be:

  • Set up OpenWRT development environment
  • How to comunicate with a JSON REST API in C or LUA and especially on OpenWRT systems (https://forum.openwrt.org/viewtopic.php?id=57904)?
  • Design a process to authenticate at the web api
  • Collect statusdata
  • Send statusdata to web api

There already exists a repository for this task: https://forum.openwrt.org/viewtopic.php?id=57904

Useful Skills: Linux (especially OpenWRT), C, compiling software, virtual machines, JSON, REST-API
Type of Work: Softwaredevelopment
Progamming Languages: C or Lua
Possible mentors: Clemens John (Freifunk Nordwest)
Level from Beginner
1-5 Professional:
3

Monitoring and quality assurance of open wifi networks: the client view

Running a huge open wifi network that is split into different network areas needs monitoring to assure an appropriate quality of service to it's users. Until now we just monitor our servers to recognize network bottlenecks and failures. But to assure an appropriate quality of service we also need the users view onto the network.

The goal of this task is to build a software running on low budget OpenWRT-Routers like WR841ND that acts like a client and regulary gathers status data from the clients view onto the network. Some common tasks of this software would be:

  • connect the router as client to a wifi network
  • connect the router to a fallback lan network
  • get a list of network segments from Netmon-SC JSON REST API
  • detect which network segment of the open wifi network the router is in
  • get a list of resources to check based on which network segment the router is in
  • check resources
  • send the data that has been gathered to the Netmon-SC JSON REST API

The software should be build as OpenWRT package and should contain a user interface for the Luci web interface.

Useful Skills: Linux (especially OpenWRT), scripting languages, compiling software, virtual machines
Type of Work: Softwaredevelopment
Progamming Languages: Lua
Possible mentors: Clemens John (Freifunk Nordwest)
Level from Beginner
1-5 Professional:
2



HUBS - community networks in the UK

HUBS is a confederation of rural community networks. Each has their own internal structure and methodology. Some may run OSLR, some BATMAN, some might be more traditionally organised and run OSPF or even static routes for simple topologies that seldom change. For this reason the networks are encapsulated in a autonomous systems (sometimes using public ASN, sometimes private). These networks peer with each other where practical physical circumstances permit and with the HUBS transit ASN through which they collectively present themselves to the Internet.

Streamlining inter-network policy articulation

As the confederation grows, managing routing policy at the community network borders becomes more complex, particularly as the operators cannot be expected to be experts in BGP. Nevertheless BGP is the best protocol we have for connecting networks together. There has been some work in generating (fragments of) router configuration from IRR data, however the setting up the entire stack of software for this to work properly (IRRd, interaction with IRRd over email and via the web, irrtoolset for generating abstract representations of policy from RPSL, transforming this abstract representation into a router config) is quite complex. There are also no good tools for describing the desired policy in a way that is intelligeable to the average community network operator.

This suggests several projects:

  • Packaging and deployment of IRRd and associated software and glue so that groups of community networks can collectively manage their number resources
  • Generation of router configuration for a variety of software used by community networks from IRR data (bird, openbgpd, quagga -- we like to use Free Software not proprietary vendor kit)
  • Web interface or other UI that allows describing the relationship and policies between adjacent community networks in an intuitive way and produces RPSL
  • Test tools to verify that the generated RPSL conforms to (1) the articulated policy and (2) that the articulated policy conforms to the desiderata given as examples


Useful Skills: Experience with or knowledge of inter-network routing
Type of Work: Systems integration and software development
Progamming Languages: Various
Possible mentors: HUBS / University of Edinburgh
Level from Beginner
1-5 Professional:
4

RPSL <-> YAML

A specific sub-project that can also be considered stand-alone is to develop a representation of routing policy in YAML (keeping in mind that YAML is convenient for humans to write and is nearly isomorphic to JSON) and a tool to convert back and forth between that representation and standard RPSL. This would help make it easier to write down what the policy should be in YAML (which not coincidentally can drive tools like ansible which are used for configuration management and generation) and export that to an IRR database on the one hand and to router configs on the other. Existing policy already present in the IRR database can be imported.


Useful Skills: Experience with transforming data from one form to another, ability to understand formal (e.g. EBNF) grammars
Type of Work: Software development
Progamming Languages: According to taste. Preference for functional languages with decent type systems considered good taste
Possible mentors: HUBS / University of Edinburgh
Level from Beginner
1-5 Professional:
3


Project: 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:

qaul.net: Implement Cryptography

Implement cryptography in qaul.net. Ideal concept would be to have an OpenPGP public/private key system, with an own trust system. Cryptography is needed to verify users, sign messages, encrypt messages and other content; and optimally to be used to authenticate secure connections. Use of a stable, embeddable C-crypto-library (eg. mbedTLS).

Things to be implemented:

  • Key generation
  • Trust system, key verification (e.g. over optical image verification), user identity management
  • Content signing / validation
  • Content encryption / decryption

Links:


Useful Skills: Basic understanding of public-/private-key cryptography, basic C knowledge
Type of Work: Discussion of concept, implementation, GUI / User interaction & awareness
Progamming Languages: C
Possible mentors: Math Jud, Christoph Wachter & others from the qaul.net community
Level from Beginner
1-5 Professional:
3-4

qaul.net: Sharable Plugin System

The qaul.net messaging systems can be used as a communication layer for other use cases. eg. a map with location updates, event notifications, etc. The messaging system can be easily opened to other apps. These apps/extensions could themselves be sharable over the qaul.net file sharing.

The following tasks need to be done:

  • Concept of the plugin system, the plugin structure and functions.
  • Plugin API (a simple mechanism to use the messaging system for plugins and give plugins the access to the qaul.net topology)
  • Implement a plugin structure
    • e.g. a zipped folder with a special ending and internal structure, that can be shared as one file over file sharing and is automatically unzipped into the web plugin directory, when the plugin is installed.
  • Add a plugin management function
    • Implement a plugin sharing and installing possibility
  • Implement a sample plugin. e.g. a simple position sharing application.


Useful Skills: Basic C knowledge, Web technology knowledge
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

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: [1]


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


Project: Retroshare - Decentralised Communication Platform

Retroshare is a decentralised communication platform that is based on a mesh of computers all running a Retroshare clients, and talking to each others using TLS/OpenSSL connexions. On top of this mesh, Retroshare provides a set of distributed services (forums/IRC chat/channels/email/file sharing) which allow a fully decentralised community to exchange ideas and data. The software has reached a good level of maturity and offers a nice opportunity to develop stand-alone distributed services. The various projects below a such examples.

Links:


Differential file list sharing system

Retroshare allows you to share files between friends and lists of shared files are exchanged between neighbor nodes. The current file exchange system is quite old and very unefficient. Besides, it relies on an old component of the backend (the v0.5 cache system) which should disappear. The goal of the project is to design an efficient and versatile system for sharing file lists, while keeping the existing GUI. The project needs a good understanding of the software backend, so it is not as easy as it might look.

Things to be implemented:

  • new file list storage. It should be extensible, and should at least contain information about hash (and other crypto

primitives depending on how the file transfer is encrypted), access dates, amount of upload/download per file, and friend-based permissions.

  • interface layer between GUI (Qt-based, where file lists are already shown as trees) and the core file lists system

which holds your own shared file list and your friends' shared file lists.

  • differential file list exchange service. This should be a regular Retroshare service, with its own network transport items. It should only send/request data when shared directories change using a two-tracks request queue (one fast queue fed

when the user is browsing his friends' shared files and one slow queue used to update outdated entries). Data exchange will depend on specific user permissions.


Useful Skills: Very good knowledge of algorithmics and C++
Type of Work: Discussion/design of concept, implementation, a bit of GUI
Progamming Languages: C++
Possible mentors: Cyril Soler, Tillman Gansky (Core developpers of the Retroshare project)
Level
4-5 Professional:
3-4

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 C++ knowledge, Qt (can be learned easily)
Type of Work: Discussion of concept, implementation, GUI / User interaction
Progamming Languages: C++
Possible mentors: Cyril Soler, Tillman Gansky (Core developpers of the Retroshare project)
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 developper to implement/port a proper cross-platform video codec that would be capable of frame-rate auto-adjustment and 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 (or implement?) a good 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: Basic C++ and Qt knowledge. Good skills in video encoding.
Type of Work: Discussion of concept, implementation, GUI / User interaction
Progamming Languages: C++
Possible mentors: Cyril Soler, Tillman Gansky (Core developpers of the Retroshare project)
Level from Beginner
1-5 Professional:
3-4

wall/blog plugin based on GXS latest stuff

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
  • GUI for the Wall/Twitter/Blog service (to be defined)
  • backend service, based on GXS interaction handles


Useful Skills: Good C++ and algorithmic skills.
Type of Work: Discussion of concept, implementation, GUI / User interaction
Progamming Languages: C++
Possible mentors: Cyril Soler, Tillman Gansky (Core developpers of the Retroshare project)
Level from Semi-professional to
4-5 Professional:
3-4

Retroshare better Chat backend

The current Retroshare chat system is very simple: if the peer is online, it sends the messages and assume they get received on the other end. Messages are sent directly to locations, so the user has to decide where a friend with multiple online locations actually is, in order to hold a proper conversation.

An improved chat protocol would send messages to all locations. It would also send a confirmation if the message arrived. It would send another confirmation if the user has read the message. This should work across all locations as well: if a users has read a chat message on one location, it would be marked as read on all other locations.


Useful Skills: Good C++ knowledge, Qt
Type of Work: Develop a new protocol to transport chat messages. Implement with C++ and integrate into Retroshare
Progamming Languages: C++
Possible mentors: Tillman Gansky
Level from Beginner
1-5 Professional:
4 Semi-Professional

Retroshare single search for all services

Retroshare has many services: forums, identities, channels, file lists... Each of this service has its own search box. For the forums, every forums has its own search box. It is currently impossible to search across all subscribed forums at once, not to say accross the entire set of services.

As a solution, we propose that every service has an interface where it exposes internal data in a searchable format. A search service would collect data from all services and build a search index. A single search box in the UI would query the index. All results would be displayed in a single list.


Useful Skills: Good C++, Qt
Type of Work: Design and Programming
Progamming Languages: C++
Possible mentors: Tillman Gansky
Level from Beginner
1-5 Professional:
4 Semi-Professional


Project: ninux.org - wireless community networks in italy

Ninux.org is a group of community networks in Italy. It aims at building experimental networks with a decentralized ownership and management. Ninux.org was involved in the CONFINE European research project and several researchers perform their experiments on the ninux networks. Many of its members are also active in the development of Free and Open Source software.

Implementing Pop-Routing

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 [2], 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 [3].

The GSOC student will implement Pop-Routing in the OLSRd daemon, he will leverage the mentioned library and build an OpenWRT package and an interface to integrate Pop-Routing in OLSRd with a dedicated plugin. He will test the software on real OpenWRT-based embedded devices. Pop-Routing can be gradually introduced in a network without requiring a full network reconfiguration, so the package can be tested directly on real community network, for instance, the Ninux network which uses OLSRd.

The final result will be an OpenWRT open source package directly installable on any real device, together with an OLSRd plugin that will allow the deployment of Pop-Routing in real networks. As a bonus, he will test the scalability properties of Pop-Routing integrating the embedded device with a real-time network emulator already developed for this task [4], in order to make the device work in an emulated network made of hundreds/thousands of nodes.


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

A web-based video streaming application for community networks

The PeerStreamer [6] open source project is a live video streaming platform, realized by the University of Trento. It is a stable video streaming software realized in the C language that implements all the state of the art algorithms for fast, distributed P2P video streaming. It can be used in community networks to broadcast live events without requiring a centralized system. It has been recently tested in community networks using network emulators and the Community-Lab testbed and showed that P2P video streaming can be done with good performance in real community networks.


This project will develop a P2P-based stream sharing among the peers of a community network. The idea is that PeerStreamer can be installed directly on the network nodes (PeerStreamer has a very light memory footprint and CPU occupation, it is written in C and can run on embedded devices) and be controlled via a web interface. The architecture is the second one described in this paper [7], which has been drafted in a previous proof of concept available here [8].

Conf2.png

Concretely, the student will have to realize a RESTful manager (in C) for the instances of PeerStreamer and a web interface.


Useful Skills: C programming, web programming, openWRT
Type of Work: Programming
Progamming Languages: C, web language tbd
Possible mentors: Leonardo Maccari [9]
Level from Beginner
1-5 Professional:
3-4

Node building coordination web platform

Building a community network node is often a task that cannot be accomplished by a person alone. Today community network members use very different tools, designed for other tasks, to schedule and organize node installations, and this can be frustrating and difficult to track. So we want to develop a web platform that can be used for this purpose that:

  • allows the node owner to create a description of the node installation environment (map, pictures, links) and a target number of volunteers
  • allows to choose a common date, time and place between the node installation participants
  • allows interaction (e.g. comments) between node installation participants
  • allows a global view of the number of missing volunteers for each node installation, so that others willing to contribute can jump in
  • can 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


Project: OpenWrt tools and extensions

Automatic Network Configuration

We want to build tools and scripts for OpenWrt to configure network interfaces for use in mesh networks. Configuration should happen fully automated without any central services. At the end we only need a general firmware image for all routers we want to flash. Base of all this should be MAC addresses and IPv6. Routing should be done with OLSRv2. For this zero conf approach we need concepts, some work on OLSRv2, tools to establish network configuration and a proper DNS setup on the routers.

Useful Skills: IPv6 Knowledge, network design, programming
Type of Work: Concept work, Programming
Progamming Languages: C++, Shell
Possible mentors: Andi Bräu and other people of weimarnetz
Level from Beginner
1-5 Professional:
4

OpenWrt: Luci Interface to announce and register internal services

Make it easy to provide services, e.g. by connecting Raspberry Pi to your router. For example, this could be a chat to use for the neigbourhood, an user editable page with a list of the best restaurants and bars around or information about Freifunk

Create an interface to manage internal services provided in your network. It should work within the LuCI configuration interface. Maybe evaluate usage of Luci2.


Useful Skills: OpenWrt, MVC, Interface Design, UX
Type of Work: Web Development, Scripting
Progamming Languages: Lua, Html, Javascript, Makefile
Possible mentors: Jan Dittrich, Weimar, http:/fordes.de/
Level from Beginner
1-5 Professional:
3 Intermediate

Analyze your wireless environment by visualising airtime distribution with RegMon

RegMon is an open-source in-kernel PHY- & MAC-layer measurement tool to sample control & state registers on Atheros based WiFi hardware. One of its main scope is high precision sampling of airtime usage (is the radio sending, receiving, facing interference or idle). It is available as Linux driver patch for ath5k and ath9k and maintained for OpenWRT trunk (dd). The actual register addresses, the sampling interval and the generated trace file are all handled via plain file access through debugfs (within the folder /sys/kernel/debug/ieee80211/phyXY/regmon/...). The trace file generated by RegMon is currently formatted as space separated list of timestamped measurement values, which turned out to be a sufficient format to parse and process the further analysis. BUT this mostly addresses developers that use RegMons file based output, collect, parse, merge (it if needed with e.g. tcpdump) and analyze/plot the results with their preferred statistical tool set.

This student proposal aims to enable OpenWrt users to analyze their wireless environment by simplifying the current steps of usage into a simple visual live plot of airtime usage displayed on the routers LUCI-based web interface. Therefore the goal is to develop a new luci-app that reads RegMons measurements from debugfs, parses the 4 relevant values of airtime usage from the timestamped tracefile and prepare them as live plot accessible by a web browser.

-all sources and full documentation of RegMon are at: https://github.com/thuehn/RegMon
-technical reference of LUCI is at: https://wiki.openwrt.org/doc/techref/luci
-all sources and examples for LUCI and its apps are at: https://wiki.openwrt.org/doc/techref/luci


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



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



Dynamic access point validator and creator

In today's Freifunk networks it is quite common to have multiple access points connected to the actual Freifunk router (by Ethernet) in order to have a dedicated Freifunk access network (ap mode) for all kind of clients (sta mode) beside the Freifunk mesh network (adhoc mode). Such access point setups are quite static once configured in OpenWrt and lead to the following challenges in practice: The wireless access network is announced as soon as the ap interface is up and running, regardless of e.g. its internet connectivity. To inform a non-technical user of the circumstance that the router is up & running but no internet connectivity is available yet, different browser/dns based redirect approaches to inform about the non-internet-connectivity by a web site have been tested over time with little success in terms of robustness and usability.

With this proposal we take a different approach. The goal is that the student extends the configuration of an OpenWrt access interface in Luci in such a way, that the wireless interface bring up via UBUS depends on a set of network conditions - so does the ability for the user to connect to it with its client device and his expectations.

A concrete example would look like this:

  • as soon as the Freifunk ap router is up and running bring up the access ssid: "freifunk-maintainance-mode"
  • based on the pingcheck package in OpenWrt, create a reasonable set of hosts and their IPs to check weather they are reachable from the router itself and only in case of a positive check result create the access point network with ssid "freifunk.net" and stop announcing the ssid: "freifunk-maintainance-mode"
  • test the conditions of internet accessibility in a regular manner and in case the reachability changes, switch off the access point network with ssid "freifunk.net" and switch on the ssid: "freifunk-maintenance-mode"

With this kind of dynamic access ssid creation, the expectations about the connectivity to a certain ssid are glued to the actual ssid itself, rather than todays approach to create a single accesspoint ssid where current network connectivity can only be tested in the second step after having connected to it.

-all sources and full documentation of pingcheck: https://github.com/br101/pingcheck
-technical reference of LUCI is at: https://wiki.openwrt.org/doc/techref/luci
-all sources and examples for LUCI and its apps are at: https://wiki.openwrt.org/doc/techref/luci


Useful Skills: good motivation to create a web-based airtime analyzer 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



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

Device-Handler Extension for netifd

The network interface daemon (netifd) is OpenWrt’s default daemon for creating and managing network devices, interfaces, and protocols. Currently, however, netifd's device handling functionality is restricted to a small set of different built-in device managers such as linux bridge handling and does not support other device handler, e.g., to use Open vSwitch instead of the standard Linux bridge.

In this project, we will extend netifd by a generic device handler interface, which is exposed via the ubus IPC system to enable interaction with external device handlers. In other words, the goal is to decouple the device management functionality from netifd to other separately maintained device managers to allow both sides to evolve independently. Moreover, the decoupling will allow netifd to manage devices of types which may even be unknown to netifd without the need to change the central UCI network device configuration in /etc/config/network. In this project, we will present a basic proof-of-concept module which outsources the control over Open vSwitch in OpenWrt to an external device handling entity. Specifically, we will realize a small daemon acting as a relay between the ovs command line tools and netifd's ubus device handler interface. Native support of Open vSwitch in OpenWRT will open a wide range of different use-cases.

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


LibreMesh port to LuCI2

Libre-Mesh take advantage of luci framework the new OpenWrt release will come with Luci2, with this project we aim to migrate Libre-Mesh to luci2 and to create a web interface for Libre-Mesh based on the new LuCI2 framework.

Useful Skills: JavaScript XHR, HTML, CSS, OpenWrt, Ubus, JSON, Libre-Mesh
Type of Work: Coding, Web desing
Progamming Languages: JavaScript, HTML5, Lua
Possible Mentor: Gui
Level from Beginner
1-5 Professional:
3 Intermediate


JSON for Networks module for LibreMap

Mainly for historical reasons we ended up with each community network having his own map server to represent and in some case monitorize the community network, after some struggle we understood that it is extremely difficult to produce a map server software that satisfy all communities so under the interop-dev project we agreed on creating a data exchange format that we can use to exchange a minimum common set of informations about our networks with other communities map servers. We called this format JSON for Netowrks, after a lot of iterations the format is now usable and stabilizing, what we need is LibreMap implementing import/export/sync of data in this format, this will help giving to the format specification the final touch and having LibreMap interoperate with others community networks maps.

Useful Skills: JSON, CouchDB and node.js knowledges
Type of Work: Programming
Programming Languages: JavaScript
Possible mentors: Nicolás Echániz
Level from Beginner
1-5 Professional:
3 Intermediate

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
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
Level from Beginner
1-5 Professional:
3

nodewatcher: Support for AP nodes without a routing protocol

Currently nodewatcher requires that all nodes run a routing protocol for them to be part of the network. But we should also support just normal AP nodes which are bridged into the network, instead of routed. nodewatcher should be adapted to know how to monitor such nodes.

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: Mitar
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
Level from Beginner
1-5 Professional:
4


Freifunk API visualisation framework

The Freifunk API aggregates the decentralized metadata from the communities in a simple way. It's represented by a json file hosted by the communities themselves and listed in the API directory. We provide some tools to collect all files from communities to aggregate information like rss feeds and calendars, have a common site for donation campaigns, find communities by address or zip.

Interested people can access information how to get in contact, where groups do meet and how to donate and participate.

We think there are a lot of more ways to make use of the data.

At the end there should be a framework to easily building charts and lists of API data, i.e.

  • Euler charts to display by countries, metacommunities, cities
  • Pie-Charts: how to contact communities (Facebook, Jabber, IRC, usw..)
  • Lists of services and their status
  • displaying historic data, as we save a copy of all available API files every hour.


Useful Skills: UX, Webdesign, JSON, Data management
Type of Work: Programming, Interface design
Programming Languages: JavaScript, HTML, RESTful services
Possible mentors: Andi Bräu
Level from Beginner
1-5 Professional:
2