Ideas GSoC 2015

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

Inhaltsverzeichnis

Add Projects and Ideas

Retroshare Social Net

Community networks are about freedom and decentralization. Recent events have shown that privacy and control over the data is a also very important parameter in the adoption of such networks. RetroShare is a Friend-to-Friend system that brings these principles, and it is very suitable for use in our community networks because it takes full advantage of the decentralized nature of the network.

The Retroshare system is based on a core library that allows developers to implement community network applications on top of it, while benefiting from the security and cryptographic primitives below. The up-coming version 0.6 offers interesting cryptographically designed community primitives such as pseudo-anonymous identities, reputation handling and circles of friends. The new cache system that is responsible for distributing the data inside the network is entirely ruled by a permission system based on these primitives.

After the successfull "Social network plugin for Retrohare" of GSoC 2014 this year we wanna improve the user interface of RetroShare 0.6 social network plugin, which will bring a real decentralized social network to end users, and reduce dependency from the rest of the internet on our community networks, while ensuring full control of user's data at a cryptographic level. Providing a web-based interface will make it more confortable for users coming from other mainstream social networks and lower the adoption barrier. From the point of view of the end user, the final application would be a headless Retroshare node running in the background which the user accesses on his computer using his web browser. The look and feel of the HTML pages should look somewhat similar to what other social networking companies offer, but with a significant additional level of security and control.

Useful Skills: Retroshare GXS, HTML5/CSS/React.js, Social Networking
Type of Work: Web Design, Coding
Progamming Languages: HTML5, Javascript, JSON, C++
Possible mentors: Tillman Gansky, Cyril Soler
Level from Beginner
1-5 Professional:
4 Semi-Professional


Retroshare IPv6

Community networks are about freedom and decentralization. Recent events have shown that privacy and control over the data is a also very important parameter in the adoption of such networks. RetroShare is a Friend-to-Friend system that brings these principles, and it is very suitable for use in our community networks because it takes full advantage of the decentralized nature of the network.

The up-coming version 0.6 offers interesting cryptographically designed community primitives such as pseudo-anonymous identities, reputation handling and circles of friends, but it still lack IPv6 support that is a foundamental to complete the appeal with community networks.

The student should port low level networking code in RetroShare to support dual stack connections, and extend higher layer parts to support multiple kind of addressing.

Useful Skills: IPv6, P2P, TLV, TCP, UDP, SSL
Type of Work: Coding
Progamming Languages: C++
Possible mentors: Tillman Gansky, Cyril Soler, DrBob
Level from Beginner
1-5 Professional:
5 Professional


OLSRv2 roaming support

In a decentralized network, each node offers an own subnet for clients. When a client roams from one node to another, the HNA/LAN-entrie known to the net must also move. Till now we use a NAT'ed approach, but a cleaner approach is to change the routing-table.

Useful Skills: routing, mac80211
Type of Work: Coding
Progamming Languages: C
Possible mentors: Andreas Braeu, Henning Rogge, Bastian Bittorf
Level from Beginner
1-5 Professional:
3 Intermediate

uHTTPd compression-support

The defacto webserver on OpenWrt is 'uhttpd'. It has nearly all the features we need, but has no support for compression, which is especially usefull when serving large JSON-sets and/or in slow networks. Support for 'gzip' and/or 'SDHC' compression: http://en.wikipedia.org/wiki/HTTP_compression.

Useful Skills: HTTP
Type of Work: Coding
Progamming Languages: C
Possible mentors: Andreas Braeu, Bastian Bittorf, Jow-Phillip Wich
Level from Beginner
1-5 Professional:
3 Intermediate

uHTTPd HTTP2-support

The defacto webserver on OpenWrt is 'uhttpd'. It has nearly all the features we need, but has no support HTTP2: http://en.wikipedia.org/wiki/HTTP/2

Useful Skills: HTTP2
Type of Work: Coding
Progamming Languages: C
Possible mentors: Andreas Braeu, Bastian Bittorf, Jow-Phillip Wich
Level from Beginner
1-5 Professional:
5 Professional

OpenWrt: Luci Interface to announce and register internal services

Make it easy to provide services, e.g. by connecting Raspberry Pi to your router.

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

Responsible: Jan Dittrich, Weimar, http://mindthegap.blog.bau-ha.us/

Useful Skills: OpenWrt, MVC, Interface Design, UX
Type of Work: Web Development, Scripting
Progamming Languages: Lua, Html, Javascript, Makefile
Level from Beginner
1-5 Professional:
3 Intermediate

LuCI Bootstrap3 Theme

Create a new LuCI theme using twitter's bootstrap3. You could use the existing bootstrap theme as coding base or build a new theme from scratch. There're lot of new features, LuCI could benefit from, including a much more easier way to create themes. The project focus can either be more technical or design. Things to do:

  • upgrade to bootstrap3 (less;css;buildsystem)
  • create more bootstrap and meta components (e.g. data tables, node info boxes)
  • enhance kitchensink to style guide
  • polish freifunk themes, or create a new one
  • convert icons to vector graphics
Useful Skills: Web development, HTML5/CSS/Less, jQuery, UI-Design, UX
Type of Work: Application coding, UI Design
Progamming Languages: JavaScript, JS frameworks, Lua, JSON
Level from Beginner
1-5 Professional:
3

Freifunk API DeepaMehta Integration

Make our Freifunk API searchable by extending the existing DeepaMehta Plugin. The goal is to get a web interface to query the API with conditions and selects and get results as JSON.

Wishlist:

  • choose result set (e.g. show nodes and website of communities)
  • use conditions (e.g. show nodes of communities using OLSR as routing daemon)
Useful Skills: Java, Maven, REST, Semantic Databases
Type of Work: Application coding, Data modelling
Progamming Languages: Java, Javascript
Level from Beginner
1-5 Professional:
4

Distributed DHCP

Many communities using Layer2 mesh protocols rely on few centralized DHCP servers. By moving the responsibility to all mesh nodes we could remove this dependency.

Requirements:

  • All nodes distribute a shared subnet (say a /20) dynamically to clients connected anywhere on the network.
  • Can work in net-split situations without causing too much chaos on net-joins.

Some Ideas we've had to tackle this:

  • Distributed Hash Table (didn't seem too promising after taking a closer look)
  • Distributed Censensus Protocols
  • Dynamic adjustment of lease times (especially during net-splits)
  • pseudo-random IP assignment using a shared seed
  • Libre-Mesh anygw (any gateway) protocol
  • Babel AHCP protocol
  • qmp's MAC-deterministic DHCP hack

This project is rather large so sufficient goal may be to create (or modify an existing) DHCP server where the "distributed" part can be plugged in using a clean API.

Responsible: Nils Schneider, Lübeck

Useful Skills: C, IPv6, Multicast, IPv4
Type of Work: Application coding,
Progamming Languages: C
Level from Beginner
1-5 Professional:
5


LibreMap agent port to LuCI2

LibreMap agent take advantage of luci framework the new OpenWrt release will come with Luci2, with this project we aim to migrate LibreMap agent to LuCI2 framework.

Useful Skills: Lua, Ubus, JSON, LibreMap
Type of Work: Coding
Progamming Languages: Lua, Shell
Possible Mentor: Nicolás Echániz
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

JSON for Network module for Nodeshot

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 Nodeshot implementing import/export/sync of data in this format, this will help giving to the format specification the final touch and having Nodeshot interoperate with others community networks maps.

Useful Skills: JSON and Django knowledges
Type of Work: Programming
Programming Languages: Python, JavaScript
Possible mentors: Nemesis
Level from Beginner
1-5 Professional:
3 Intermediate


JSON for Network module for nodewatcher

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 nodewatcher implementing import/export/sync of data in this format, this will help giving to the format specification the final touch and having nodewatcher interoperate with others community networks maps.

Useful Skills: JSON and Django knowledges
Type of Work: Programming
Programming Languages: Python, JavaScript
Possible mentors: Mitar
Level from Beginner
1-5 Professional:
3 Intermediate


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: Frontend development
Type of Work: Programming
Programming Languages: Python, JavaScript
Level from Beginner
1-5 Professional:
3 Intermediate

Overview of used IP space module for nodewatcher

In nodewatcher, 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: Frontend development
Type of Work: Programming
Programming Languages: Python, JavaScript
Level from Beginner
1-5 Professional:
3 Intermediate


Plotting signal coverage on node map for nodewatcher

We currently have a map that shows geographical location of nodes. It would be great to have tools that could overlay signal coverage over this map. This can be done even without exact antenna radiation diagrams, we just need the node's general antenna direction. Then we can check neighboring nodes and color all the appropriate triangles (so the first node and its two neighbors – for all neighbors). This can then be used to mark areas that the node's signal should reach. Of course this will not be an exact computation but it can serve as a general reference when checking signal coverage and having data from neighbors available.

We could also take link quality into account. For example if one node has two links with 60° inner angle, both having 1.0 link quality, we could assume that the signal will also be ok +/- 30° to either side of the triangle. These additional triangles could then be drawn with a lighter color (and they could also be transparent).

Extra useful it would be if this would be a general library for plotting signal coverage on maps, so that it could be used with nodeshot node mapping software. Also that it supports both Google Maps and OpenStreetMap.

Student should have experience or be willing to learn Python and Django, but mostly good experience with JavaScript, drawing with JavaScript and integration with Google Maps and other mapping APIs. Good understanding of math is probably a must as well.

Useful Skills: Frontend development, math
Type of Work: Programming
Programming Languages: Python, JavaScript
Level from Beginner
1-5 Professional:
4


Integrated link planner for nodewatcher

Integrate a link planner into nodewatcher, where potential the links to all surrounding nodes are calculated, the elevation profile is drawn for each of the potential links and the signal loss is calculated.

The benefit of such planner would be much simpler link planning. When a node is added, the full potential of the links from that location is seen.

A desktop tool for that is for example Radio Mobile. Integration and scripting for it should be checked, especially running/porting it on Linux. If not already existing, a library (with Python bindings) or standalone console application based on it could be developed.

It seems also an online version already exists.

Student should have experience or be willing to learn Python and Django and how to write Django apps together with basic understanding of HTML/JavaScript and general web development.

Useful Skills: Frontend development, math
Type of Work: Programming
Programming Languages: Python, JavaScript, C/C++
Level from Beginner
1-5 Professional:
5


IPv6 support for Tunneldigger

Tunneldigger is a VPN solution used in many community/mesh networks to connect nodes which do not have a wireless link between them into a common network. It uses existing network connectivity (like Internet) between nodes to create L2TP tunnels between them. Current limitation is that those tunnels use only IPv4 and cannot be established over IPv6. (Tunnels are layer 2 and can carry both IPv4 and IPv6 traffic already. The issue here is that they themselves cannot be established over IPv6.)

The aim of the GSoC project is to design and implement IPv6 support for Tunneldigger so that it works in IPv6-only and IPv4/IPV6 mixed environment where both server and client have IPv6 connectivity in some form. Student should have experience or be willing to learn Python and C, compiling and running code for OpenWRT, have experience with networking stack (IPv4, IPv6, NAT).

Useful Skills: Understanding of computer networks
Type of Work: Programming
Programming Languages: Python, C
Level from Beginner
1-5 Professional:
4


Linux kernel support for multiple L2TP tunnels on the same server port

Current L2TP tunneling support in Linux kernel is limited by the fact that each tunnel requires unique UDP port on the server side. This creates problems for clients behind NAT as it would be much easier to configure NAT traversal if all tunnels would connect to the same server port. L2TP tunnels are used in Tunneldigger for providing a VPN solution for community/mesh networks.

The aim of the GSoC project is to implement support for multiple L2TP tunnels on the same server port in Linux kernel, create a patch for OpenWrt and Linux and send it upstream for inclusion. Student should have experience or be willing to learn Python and C and Linux kernel hacking/compiling and have experience with networking stack (IPv4, IPv6, NAT) and reading and implementing RFC standards.


Useful Skills: Understanding of computer networks, Linux kernel
Type of Work: Programming
Programming Languages: C
Level from Beginner
1-5 Professional:
5

Implement better gluon route selection

Gluon with badman-adv is used to route packets between freifunk nodes. The better route is determined by less packet loss. This does not take into consideration the link bandwidth.The result are slow mesh connections while much faster routes would be possible, e.g. a parallel link via LAN.

Improve the Freifunk firmware to handle multiple routes more wisely to increase the performance of local meshes.

Hint: You can try using [1] for 802.11 and [2] for wired Ethernet to acquire the expected link throughput.

Added by: Benutzer:Apoapo

Useful Skills: Understanding of computer networks and gluon firmware
Type of Work: Programming
Programming Languages: C?
Level from Beginner
1-5 Professional:
5


Write documentation for OpenWrt's C API

OpenWrt comes with a bunch of nice C libraries and services: libubox, libuclient, netifd and rpcd, to name just a few. Unfortunately there is very little documentation around (only few comments in the code), making them quite hard to use for coders not yet familiar with the code. Having better documentation would significantly improve that and reduce the use of redundant libraries or scripting languages (which is undesirable on space- and memory-constraint embedded targets).

Useful Skills: Good understanding of OpenWrt and advanced C code
Type of Work: Writing Documentation
Possible mentors: any OpenWrt developer
Programming Languages: either reST, Markdown, TeX or DocBook
Level from Beginner
1-5 Professional:
3


Fix bootstrapping of DHT based applications to work on autonomous mesh networks

Many of today's most promising peer-to-peer applications use a DHT. Unfortunately, bootstrapping usually depends on a couple of hard-coded hosts on the ARPA internet -- if these are not reachable or only through IPv4-NAT, most of these services do not function well on wireless mesh networks. While IPv6 support of both, applications and networks, will bring some improvements, this will still not allow these applications to run entirely independent of ARPA-net connectivity. Good examples are BitCoin and BitCoin-based like Twister or Tox, RetroShare, BitTorrent and BitTorrent-based like PopcornTime or Peerflix. Solutions to this problem can range from introducing multicast (mDNS) discovery of other DHT nodes to the application itself; protocol-specific hacks (like announcing retracker.local via KadNode) to nasty iptables-hacks redirecting those specific bootstrap nodes on the ARPA internet in an ANYCAST fashion to any available participating node on the mesh. Imho, all this is acceptable as long as it works :)

Useful Skills: Understanding of P2P protocols and IP networking
Type of Work: Writing code to be submitted to upstream projects, writing firewall hacks to be deployed on OpenWrt routers
Possible mentors: Daniel Golle
Programming Languages: C, C++, Python, ...
Level from Beginner
1-5 Professional:
4


add ENUM/E.164 zone support to KadNode

Now that KadNode crossed my mind, something else came up: Adding ENUM support to KadNode would be great! Having the option to resolve E.164 via KadNode would allow distributed Voice-over-IP to work over the mesh without any need to modify VoIP software, as resolving E.164/ENUM is already supported in many of them (e.g. Asterisk). Now that we get closer to "recycled" VoIP hardware (e.g. ADSL2+ VoIP-capable routers from ISPs -- if you simply don't use the DSL modem, it still makes a good Mesh-VoIP-ATA) being supported by OpenWrt this seems particularly relevant. (Lantiq DANUBE generally works well already, some work on SPI drivers for HFC Cologne based ISDN stuff is still missing, but analog-only hardware close to Lantiq's reference designs do work already with Asterisk)

Useful Skills: Understanding of DNS and prior experience with Voice-over-IP or even E.164 could be useful
Type of Work: Writing code to be submitted to KadNode project
Possible mentors: Daniel Golle, Moritz Warning (?)
Programming Languages: C
Level from Beginner
1-5 Professional:
3


BMX6 integration with Ubus and procd

The goal of this project is to integrate the BMX6 routing protocol with OpenWrt's microbus and process management architecture Ubus and procd. This way, other daemons and applications can communicate with BMX6 using a standard interface instead of calling particular daemon commands or reading files at /var/run/bmx6.

BMX6 is a distance-vector routing protocol for Linux-based operating systems. It is specially designed for dynamic mesh wireless adhoc networks and is currently included in the routing feed of OpenWrt. Ubus is OpenWrt's microbus (µbus) architecture, developed to provide communication between various daemons and applications in OpenWrt.

To achieve the integration, a new BMX6 plugin will be created to handle communication with Ubus and init scripts must be adapted to support new openWrt process management.

Useful Skills: OpenWrt, BMX6, C
Type of Work: Coding
Programming Languages: C
Level from Beginner
1-5 Professional:
4


Openconnect client for iphone

OpenWRT can be used as a an openconnect VPN server, and there are clients for multiple platforms available, including android phones. However, there is no client for iphone. The goal of this project is to create a graphical openconnect client for iphone, utilizing libopenconnect.

OpenConnect is a TLS/DTLS based VPN server which runs on OpenWRT. It is specially designed for small systems, and systems with dynamic IP addresses.

With the iphone client one should be able to access the LAN exposed by the VPN and apply the configuration sent by the server.

Useful Skills: C, Objective C, Xcode
Type of Work: Coding
Programming Languages: C, Objective C
Level from Beginner
1-5 Professional:
4
Possible mentors: Nikos Mavrogiannopoulos

Making easy the federation of distributed users databases

The concentration of services and activity in particular corporations disposing all needed data (often, even more than needed) is the current trend. However, still there are groups of users with internal self-organization. The natural evolution of these groups is to join other groups to form a federation without losing its initial independence. The result is a distributed users database.

These federations are based in cooperation and reciprocal trust. They allow a distributed management , extend the availability of services and the resulting system can be more reliable. All without the intromission among different groups. The groups are technically free to leave the federation at will. An example of such a federation is Eduroam. This system is an international federation of universities, allowing a student to connect to any of the WiFi campus networks in the federation. The authentication is sent to the student’s home university.

The goal of this project is to develop a meta-packet to make easy the configuration of a federation of LDAP databases and also its replication (to increment reliability and/or performance). Existing groups, after installing the meta-packet should adhere or leave federations using simple forms. The result of the project will be applied to the proxy web federation already working in the guifi.net community network, which already has thousands of users.


Useful Skills: Frontend development
Type of Work: Programming, system administration
Programming Languages: Python, shell scripting
Level from Beginner
1-5 Professional:
2


DTN for Community Networks

Integration of mobile users in community networks can be made even more flexible by adopting Delay/Disruption Tolerant Network (DTN) strategies, leading to an opportunistic communication infrastructure. Users could roam around issuing requests and receiving responses at a later time and place; think about social networking applications, but also emergency recovery scenarios where the Internet (fixed and mobile) has failed, or, in tactical settings, where there is no infrastructure, or, in remote third-world type scenarios.

Since there is already a sufficient base of software for DTN, the student could use as a starting point any of them (e.g., http://sourceforge.net/projects/ion-dtn/files/, or http://www.dtnrg.org/wiki/Code). Since users are supposed to use smartphones as access devices, so regarding the porting to smartphones, the student can look and adapt, if necessary, the Bytewalla or the JDTN (http://sourceforge.net/projects/jdtn/).

The student will have to implement, either reusing the existing software above, and creating new software:

  • First, a Bundle Protocol Agent (BPA-F) to be run on fixed nodes based on OpenWrt. A BPA is a Bundle Daemon (BD) that implements the functionality needed to manage the sending and receiving of DTN 'bundles' over network communication links as specified in RFC 5050.
  • Second, a HTTP-DTN module so to enable experimentation with web based applications with the BPAs. Due to the limitations of HTTP and the request-response principles, a server-client architecture is essential. On the server-side, a module is required to offer the necessary DTN functionality and a HTTP convergence layer to encapsulate DTN bundles into HTTP. Additionally, a database is needed to store meta-data of stored bundles. We name this component "server", because it does not initiate any connection and just waits for incoming HTTP connections from DTN clients. The client is provided with an additional HTTP convergence layer and performs GET and PUT calls to the server.
  • Finally, a Bundle Protocol Agent to be run on the smartphones. This agent will basically be the porting of the BPA-F and of the client for the HTTP-DTM module to an Android based device.



Useful Skills: IP, TCP, Networking
Type of Work: Middleware coding
Programming Languages: Java, C++
Level from Beginner
1-5 Professional:
4


Management and monitorization dashboard for communication equipment and wireless links

The main objective of this project is to automate, simplify and ease the management and maintenance of wireless network deployments, where the fragility of the links may result in loss of performance of the entire network. A monitoring system capable of detecting the problems associated with fallen or downgraded links is essential for the proper operation of the environment.

Parts of the project

  • Management of architecture. A REST API that gives us the essential mechanisms for structuring the network deployment.
    • Add/remove nodes and links in the database management.
    • Geographically positioning of nodes (communication equipment).
  • Monitorización of the architecture:
    • Automatic inspection of the current configuration of network routers through its API. Major operating systems that support query via API: Mikrotik RouterOS, OpenWRT.
    • Continuous status checks of the routers in network Layer 3 and Layer 2.
    • Monitor various critical indicators such as the current bandwidth of the link, node status currently active routes, etc and store it on a time series database storage.
  • Data presentation. Website visually representing the position and status of each of the links and routers.
    • Map respresentation of nodes and links.
    • Graph representation of the monitored time series (bandwidth, connected users, etc.).
    • Show the route taken by packets to get from one node to another in the wireless network.

There is already a version of the monitoring system in operation: http://gps.qui.guifi.net/ This is currently part of the guifi.net monitoring network in the metropolitan area of Castellón. The project should consider adapting the API for easy integration with existing management platforms, such as web platform guifi.net

The technologies currently in use are: nodeJS/express, AngularJS, mongoDB, collectd. Proposed new technologies for time series storage: Grafana, InfluxDB


Useful Skills: Web development, HTML5/CSS, jQuery, UI-Design
Type of Work: web programming
Programming Languages: php, javascript
Level from Beginner
1-5 Professional:
4


Migration of qMp to LuCI2

The goal of this project is to migrate the web interface and the configuration scripts of qMp to the new LuCI2 framework. This will provide an infrastructure for new tools to monitor and manage nodes remotely.

Tasks to accomplish:

  • Port current qMp controllers to objects/methods to OpenWrt's Ubus architecture.
  • Write templates and views in JavaScript


Useful Skills: JavaScript XHR, HTML, CSS, OpenWrt, Ubus, qMp
Type of Work: Coding, Web desing
Progamming Languages: JavaScript, JSON, HTML5
Level from Beginner
1-5 Professional:
4 Semi-professional


qMp visualisation support

In qMp there have been several attempts to support a map visualisation that not only displays the nodes but also includes links quality and capacity, etc. As a result, libremap is partially supported, but no integration is provided for Guifi.net Maps, for instance.

The goal of this proposal is aimed at updating this support and extending it to, at least, Guifi.net Maps visualisation system. In this network, a series of servers distributed amongst it poll the nodes for their status, to then provide the data to the central maps server.

Tasks to accomplish:

  • Creation of an qMp plug-in (in the form of an OpenWrt package) to provide data on demand
  • Integration of qMp-based mesh nodes in Guifi.net Maps


Useful Skills: OpenWrt, qMp, Drupal
Type of Work: Coding, Web desing
Progamming Languages: Lua, PHP, HTML5, CSS, JavaScript XHR, JSON
Level from Beginner
1-5 Professional:
4 Semi-professional


qMp bits

There are certain aspects of qMp that have become outdated as OpenWrt development has advanced and need to be updated. This proposal is made out after gathering the current ones, plus those that may appear during its execution.

Tasks:

  • Analysis of current status and lacks (also getting feedback from the community via mailing lists, etc.)
  • Choice of problems to tackle and prioritisation
  • Development
  • Assessment

There are certain issues that have already been identified:

  • Wireless interfaces detection and management (802.11n/ac, 802.11s, VAP capabilities, etc.)
  • Proper management of switched wired interfaces
  • Automated scan of mesh wireless neighbours to join
  • Harmonisation and improvement of usability for certain pages of the web interface
  • Documentation update


Useful Skills: OpenWrt, qMp/BMX6, gp-Easy
Type of Work: Coding, Web desing, Documentation
Progamming Languages: Lua, HTML5, CSS, JavaScript XHR, JSON
Level from Beginner
1-5 Professional:
3 Intermediate


Extending Bird/BGP integration to support more routing-protocols and functionalities

Bird is a lightweight alternative to Quagga for route export and import between BGP and other routing protocols such as OLSR, BMX6, Batman, Babel, OSPF. During a previous GSoC project Bird has been successfully enhanced and integrated for IPv4 and IPv6 into the qMp firmware to support automatic route exchange between BGP and BMX6. During this project, the integration should be continued to support a borader scope of routing-protocols and functionalities. Related tasks include:

  • Enhance integration of Bird inside OpenWRT (conforming to existing UCI/LUCI style)
  • Continue adding the rest of BGP options to enhance flexibility.
  • Add OSPF (first of all) and other (yet unsupported) protocols to the UCI and LuCI solution.
  • Perform extensive testing of supported functionality within community network of choice (one currently using Quagga)
  • Integrate bird4/6-uci/luci as official package to OpenWRT routing feed.
Useful Skills: Lua, OpenWRT, Routing protocols (BGP, OSPF, Babel,OLSR,...)
Type of Work: Coding/Testing
Progamming Languages: Lua/Shell
Level from Beginner
1-5 Professional:
4 Semi-professional


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


Libre-Mesh Guifi.net integration

In Libre-Mesh network islands we miss integration with the already existent Guifi.net infrastructure, to make possible a seamless migration to LiMe it should be capable to route packets from BGP networks and vice versa, moreover at least a minimal suport on Guifi.net map for LiMe is needed.

The goal of this proposal is to implement the glue between the legacy Guifi.net network, maps and tools and the new LiMe networks.

Tasks to accomplish:

  • Creation of an LiMe plug-in (in the form of an OpenWrt package) to autoconfigure a BGP daemon (possibly BIRD)
  • Integration of LiMe-based mesh nodes in Guifi.net Maps


Useful Skills: OpenWrt, LiMe, Drupal
Type of Work: Coding, Web desing
Progamming Languages: Lua, PHP, HTML5, CSS, JavaScript XHR, JSON
Possible Mentors: Al
Level from Beginner
1-5 Professional:
5 Professional


ERP/CRM for Community Networks

Aside from the technological development, Community Networks (CN) must take care of the economic and social aspects, because they are key components in the proper development of the project's Common Pool Resource (i.e. network infrastructure). In CNs the profiles of the participants are extremely diverse, users, volunteers, installers, professionals, as well as their roles, promotion, use and improvement of infrastructures and services, maintenance, improvement and expansion of the Community Network, etc

This proposal promote a development of a vertical solution and specific modules for CNs, based on Tryton. It must identify different participant roles and the network infrastructures. The operational infrastructure must be identified and the use of it by people must be counted unambiguously. Contributions and economic activity must also be accounted. All this data will be used for costs allocation.


In addition, must be a solution must contribute to the coordination and support of the participants and future participants, with special attention to the different profiles (users, potential users, volunteers, installers, maintainers and operators) because the people is an essential part, together and inseparable, with the infrastructure of the Community Network.

Reusing as much as possible existing code, the student must:

  • Use Tryton as a base
  • Integrate the infrastructure description from the guifi.net database
  • Integrate the participants and their rols from the guifi.net database
  • Integrate the existing monitoring data or suggest modular and scalable alternative solutions
  • Integrate a numeric system based on the used resources, and costs of infrastructure maintenance, services and new investments


Useful Skills: guifi.net backend and frontend
Type of Work: Coding, Documentation
Progamming Languages: Python, PHP, HTML
Level from Beginner
1-5 Professional:
3 Intermediate


Panorama Picture Viewer

Often we use panorama pictures for documentation of installations and point-to-point connections. Those pictures are really huge (40k px and more) and most browsers are overchallenged with them. A proper zoom function is missing, too.

Formerly, zoom.it was used to display panaromas. This service hosted by Microsoft doesn't exist anymore, and their open source successor seems to sleep.

So we're looking for a Slippymap solution where you can:

  • add panorama pictures that will be rendered in tiles
  • zoom in and out panoramas with tiles in different resolutions
  • use a javascript panorama viewer to embed the pictures in wikis and websites

Possible Mentor: wetter

Useful Skills: image processing, web programming, User Interfaces
Type of Work: Coding, Documentation
Progamming Languages: HTML, Javascript, nodejs, Image Processors
Level from Beginner
1-5 Professional:
4 Intermediate

Smartphone App analyzing mesh neighbourhood

During installation of a new Freifunk Node (or a bunch of) there are many wifi things to have a look on. At the moment its done by opening different webpages and ssh-consoles with customized bash-scripts.

This App would be able to work even on mesh networks without internet access and without need for installing mesh-controlling servers (ffmap, libremap, nodewatcher,..). The Userinterface is very easy to understand and there is almost no submission from the user needed. Internet is only needed once, to install the App. Gathered Data from Meshnodes are public available, so there is no need for typing in any password:

intention:

  • make a offline (!) smartphone app (use a nice framework?)
  • gathers public available data from a freifunk node
  • that data will propagate direct mesh neighbours. gather data from these all nodes!
  • repeat data collecting periodically (pay attention to possible communication problems/drops)
  • portrait-mode: nice visualisation about these values to enable the user to find local problems and optimize the wifi-cloud easily
  • landscape-mode: live flow charts about olsr-lq, -nlq and SNR between all these nodes for the last minutes

many of these information doesnt makes sense when looking at values from one device. its important to merge it with details from all involved neighborhood wifi nodes and combine it to a nice visualisation. f.i. sometimes a node can send signal to a next node but cant receive them (f.i. poor wifi or misrepresented directional antenna). so there should be a red dot and icon in the flow charts

data types are:

  • Signal-Noise-Ratio for each mesh neighbour, which can be received on wifi
  • OLSR - Neighbors with LQ, NLQ and ETX.
  • batman-adv neighbors
  • hostname, contact, status, uptime, firmware, version
  • further contact links (opens up webbrowser or 3rd party apps)


within almost all freifunk mesh variants there is at least one method to get detailed data about connections to wifi neighborhood.

  • via http (when luci is installed)
  • via ubus (when rpcd installed, take a look at luci2)
  • via gluon node-status page


this App is NOT:

  • needing any centralized server
  • depending on further software-installation on the mesh nodes
  • communicating to the internet

when starting the App there should be different methods to start communication with a first mesh node:

  • in OLSR Enviroments: IPv4 of the default gateway
  • in batman-adv Enviroments: next-node adress
  • manually: Enter IP-Adress of desired device

Idea from: Ufo

Useful Skills: smartphone app frameworks, flow chart processing, json, User Interfaces
Type of Work: Coding, User Interface
Progamming Languages: web2.0
Level from Beginner
1-5 Professional:
3


Firmware Agent and Web Monitoring

Many projects that use OpenWRT derived firmwares to build a large mesh network don't have ability to easily and centrally monitor and manage the network. This could be achieved by having an agent running on each router which either can have information gathered in read-only mode or be remotely controlled saving time on repetitive tasks (e.g: mass firmware update). A central web interface can gather information from each router agen, issue commands when allowed or simply have a wide view of the network.

Requirements:

  • Development of a web interface and multi-thread agent collector to centralize and show the information collected from the network.
  • Development of an Agent to collect and organize the local router information for the agent collector.
  • Database to store permanent information (settings and collected).

Some Ideas we've had to tackle this:

  • Agent should gather all router network information like: hostname, interfaces, wireless details, router performance, traffic statistics, etc
  • Optional GPS information via USB GPS device used for map positioning.
  • Option to collect logs remotely for troubleshooting proposes.
  • Option for mass firmware update.
  • Some real time information streamed when device is selected.
  • Folder hierarchy in order to organize different locations or areas.
  • Further ideas from airControl software from UBNT.


Useful Skills: C, Bash, Web development, HTML5/CSS, SQL
Type of Work: Application coding, UI Design
Programming Languages: C, Bash
Level from Beginner
1-5 Professional:
6 Near Impossible in a GSoC