This is my Github portfolio in a format where repositories are not just listed like on the Github profile page but also described in more detail. My Github profile page has also several minor repositories that are too unimportant to be listed here, and forks of software written by others that I do not want to falsely list here as my own.
CamFTPD is an FTP server intended for surveillance cameras. The only operation it supports is putting new files, it doesn't support getting files, deleting files, listing files, etc. The put operation refuses to overwrite existing files. So the surveillance camera can only append new data, never access or destroy old data. The reasoning why CamFTPD should be used is that FTP sends cleartext passwords over the wire, and there is no widely supported replacement standard for FTP although SFTP/SCP could be used if surveillance cameras only supported it. So, if the attacker can physically access the network connection of a surveillance camera, the only harm the attacker can do is inserting false evidence. However, prior to the timestamps of the false evidence, the attacker's true face has already been caught while tampering with the network connection.
RLCTrans is a transient simulator program for R-L-C circuits with switches, diodes, transformers and voltage sources. The analysis is linear nodal analysis with automatic reanalyses if diode current direction changes. Two models for a transformer are provided: a single transformer may be handled by binary search which slows down the simulation markedly, but a linear matrix model allows multiple transformers and fast simulation. The software is especially intended for designing control algorithms for switched mode power supplies, sine wave inverters and active power factor correction circuits and analyzing what kind of core is needed for the inductors to avoid saturation. For analyzing energy efficiency of SMPS, the software is utterly inadequate. The software does not aim to compete with Spice: it only simulates the high-power path of MOSFET and BJT switches and does not analyze the gate/base control of the switches at all. However, most likely in many cases the software runs way faster than Spice does, and it is easy to integrate it with C code which you would use as the programming language of choice for developing software running on the control microcontrollers anyway.
nodexmlfrag in Github, nodexmlfrag in NPM
Typically, XML is either parsed by a tree-based parser or by an event-based parser. Event-based parsers are fast and have a low memory footprint, but a drawback is that it is cumbersome to write the required event handlers. Tree-based parsers make the code easier to write, to understand and to maintain but have a large memory footprint as a drawback. Often, XML is used for huge files such as database dumps that necessitate event-based parsing, or so it would appear at a glance, because a tree-based parser cannot hold the whole parse tree in memory at the same time. NodeXMLFrag allows XML to be parsed by event-based approach from the top, but allowing switching to a tree-based approach for small structures. So for example a database dump containing billion objects can be parsed in an event-based manner but each object can be parsed into a tree.
pyxmlfrag in Github, pyxmlfrag in PyPI
Typically, XML is either parsed by a tree-based parser or by an event-based parser. Event-based parsers are fast and have a low memory footprint, but a drawback is that it is cumbersome to write the required event handlers. Tree-based parsers make the code easier to write, to understand and to maintain but have a large memory footprint as a drawback. Often, XML is used for huge files such as database dumps that necessitate event-based parsing, or so it would appear at a glance, because a tree-based parser cannot hold the whole parse tree in memory at the same time. PyXMLFrag allows XML to be parsed by event-based approach from the top, but allowing switching to a tree-based approach for small structures. So for example a database dump containing billion objects can be parsed in an event-based manner but each object can be parsed into a tree.
MPloop is a set of scripts for playing music in the background. The idea is that the "loop" part, which is a script that reads the queue and plays songs in that order, is started in a screen or tmux session. The "loop" uses MPlayer or a custom included music player as the tool for playing music.
All of the songs are played from queue in the order they are in the queue.
The user interface is simply a set of scripts managing the queue from a Unix shell, and a set of scripts controlling the player.
Sometimes there is a need to convert a floating point number to a string representation that converts back to the same number. The usual approach is a format specifier with enough precision such as "%.17g". However, there are several problems with this approach such as the fact that the floating point number 2.0 converts to the string "2" that incorrectly implies it is an integer. Also the floating point number 0.2 converts to "0.20000000000000001" instead of "0.2". The pretty ftoa library attempts to find the shortest "pretty" representation for a floating point number that still converts back to the same number and that clearly demonstrates the number is a floating point number and not an integer.
There are cases that the standard C library atof() function call do not handle. For example, atof() is defined only for continuous '\0'-terminated strings. Thus if you have a block of memory that is not guaranteed to be '\0'-terminated, you need to allocate a second block of potentially unlimited size to add the terminating '\0' character. Also, atof() requires all data to be stored in continuous memory at once, so calling it incrementally for newly arriving data blocks does not work. The only way to solve the incremental parsing problem is to allocate a buffer that needs to grow to potentially unbounded sizes to handle numbers such as 1e0, 10e-1, 100e-2, 1000e-3, 10000e-4, 100000e-5, ... which all represent the number 1 in a series of representations that grow without bound. Streaming atof is designed to handle all those use cases where standard atof() fails.
Usually JSON is parsed by a tree-based parser. If the data structures of the parser are different from the ones used in the program, a conversion needs to be performed to modify the parse tree to the desired format. CAJ is an event-driven parser for C language that allows directly parsing to the desired structures. CAJ also includes CAJUN, a tree-based variant; CAJ_out, a JSON output library allowing outputting JSON from any function; and CAJUNfrag, a parser combining the event-driven and tree-based approaches in a flexible way.
Typically, JSON is parsed by a tree-based parser and almost never by an event-based parser. Event-based parsers are fast and have a low memory footprint, but a drawback is that it is cumbersome to write the required event handlers. Tree-based parsers make the code easier to write, to understand and to maintain but have a large memory footprint as a drawback. Usually, JSON is not used for huge files such as database dumps that necessitate event-based parsing, or so it would appear at a glance, because a tree-based parser cannot hold the whole parse tree in memory at the same time, and event-based parsing is not available in common libraries. JavaJSONFrag allows JSON to be parsed by event-based approach from the top, but optionally allowing switching to a tree-based approach for small structures. So for example a database dump containing billion objects can be parsed in an event-based manner but each object can be parsed into a tree. This allows using JSON for huge database dumps, and JSON is a far better serialization format than XML.
abce in Github (Aalto5G), author's fork of abce
A bytecode engine (abce) is a very simple bytecode engine with JSON data model and garbage collection, intended for strongly typed dynamic languages. The opcode format is stable and the argument order of opcodes is natural, meaning compiler can directly emit operations without reordering. A modifiable yacc-based programming language (Amyplan) is the programming language for writing abce programs.
stirmake in Github (Aalto5G), author's fork of stirmake
Stirmake is scalable true implementation of recursive make. It is intended for easily creating whole-project build systems consisting of numerous modules. Numerous deficiencies in standard make have been solved while staying true to the idea of traditional make. For understanding why stirmake is necessary, read "Recursive Make Considered Harmful" and try to follow its instructions.
jmalloc in Github (Aalto5G), author's fork of stirmake
jmalloc is a variable-sized single-threaded memory allocator over 3 times faster than standard Linux allocator. It is on a totally different location of the high performance - low fragmentation scale, wasting memory but saving CPU time. In contrast, other allocators waste CPU time but save memory.
yale in Github (Aalto5G), author's fork of yale
YaLe is an event-driven incremental non-blocking network protocol parser generator for a state machine architecture. YaLe implements a finitely backtracking parser state dependent DFA based lexer for maximal munch tokenizing with a priority system. Parsing is conditionalized callback-attributed LL(1). The callback system is particularly sophisticated. YaLe parses HTTP at over 3 Gbps, whereas its main competitor, BinPAC, parses HTTP at 0.55 Gbps. YaLe can be used for both text and binary protocols.
cghcpcli in Github (Aalto5G), author's fork of cghcpcli
Carrier grade HTTP CONNECT proxy client offers a client-side mechanism for NAT traversal using a HTTP CONNECT proxy in the NAT middlebox.
ldpairwall in Github (Aalto5G), author's fork of ldpairall
The L Data Plane Airwall offers improved NAT traversal with no security policy. It is a prototype of an application layer NAT technology.
nmsynproxy in Github (Aalto5G), author's fork of nmsynproxy
The netmap SYN proxy offers state of the art TCP SYN proxy for protecting against TCP SYN flood attacks at line rate. The TCP SYN cookie mechanism it uses is particularly modern and well thought of. The feature set exceeds that of the Linux SYN proxy iptables module. It is implemented entirely in user space unlike the iptables module.
pptk in Github (Aalto5G), author's fork of pptk
The packet processing toolkit contains several useful utilities for user space packet processing on Linux machines. It also includes L Data Plane, a data plane wrapper similar to OpenDataPlane but with higher netmap performance.
javaxmlfrag in Github, javaxmlfrag documentation
Typically, XML is either parsed by a tree-based parser or by an event-based parser. Event-based parsers are fast and have a low memory footprint, but a drawback is that it is cumbersome to write the required event handlers. Tree-based parsers make the code easier to write, to understand and to maintain but have a large memory footprint as a drawback. Often, XML is used for huge files such as database dumps that necessitate event-based parsing, or so it would appear at a glance, because a tree-based parser cannot hold the whole parse tree in memory at the same time. JavaXMLFrag allows XML to be parsed by event-based approach from the top, but allowing switching to a tree-based approach for small structures. So for example a database dump containing billion objects can be parsed in an event-based manner but each object can be parsed into a tree.
javafastcomplex in Github, javafastcomplex documentation
Javafastcomplex implements two complex number classes, Complex for immutable complex numbers and ComplexBuffer for mutable complex numbers. Both immutable and mutable complex numbers share the same common ComplexNumber interface. This is unlike other available complex number classes that typically only offer an immutable complex number class. Using the mutable complex number class reduces object creation and garbage collection overhead which allows trivially to improve the performance of Java code that does complex number calculations.
Micronova XRD is a fast and convenient user interface for fitting X-ray diffraction curves of multilayers to data measured from heteroepitaxial structures. It originally was only a front-end for Matlab / GNU Octave differential evolution code written by Juha-Matti Tilli for measurements from Philips / PANalytical equipment, but current version is pure Java, uses optionally covariance enhanced multithreaded differential evolution for fitting, and supports quite many data formats.
Micronova XRR is a fast and convenient user interface for fitting X-ray reflectivity curves of multilayers to measured data. It originally was only a front-end for Matlab / GNU Octave genetic algorithm code written by Jouni Tiilikainen for measurements from Philips / PANalytical equipment, but current version is pure Java, uses optionally covariance enhanced multithreaded differential evolution for fitting, and supports quite many data formats.