digip.org blog

No more posts about Jansson releases

2016-08-31 00:00:00

Jansson 2.8 was released yesterday. Because of lack of time, I haven't written blog posts about changes after the 2.6 release, and I'm not planning to do so in the future, either.

Jansson 2.6 released

2014-04-01 00:00:00

Jansson 2.6 was released already on 2014-02-11, but I totally forgot to blog about it or even update Jansson's web page. Sorry about that!

Jansson 2.6 is mainly a security release, changing the hash function that is used by Jansson's hashtable implementation. Other changes include minor documentation and build system corrections. For a more comprehensive list of changes, see the release notes.

New hash function

Jansson's old hash function was vulnerable to a denial of service attack. By using specially crafted keys, the attacker could reduce the performance of most object operations. For example, decoding a JSON text with such crafted keys would take tens of seconds for a relatively small file.

Jansson 2.6 changes the hash function to Bob Jenkins' lookup3, which supports seeding. As no non-cryptographic hash function is immune to the key crafting problem, the hash function is seeded by random data when the first JSON object is created, either by explicitly calling json_object(), or by implicitly creating a new object e.g. by decoding a JSON text or calling json_pack().

The purpose of seeding is to make the hash function yield different results on each program run. This makes it virtually impossible to launch a DoS attack anymore.

The hardest part of seeding is how to actually generate random data in a thread-safe manner. Jansson uses /dev/urandom if it's available, or CryptGenRandom() on Windows. If neither are available, a combination of a microsecond precision timestamp and process ID are used as the seed. Seed generation is guarded by architecture dependent lock-free operations to ensure thread safety.

A new function, json_object_seed(), is also exposed, to make it possible for the user to initiate the seeding, e.g. before spawning any threads.

Jansson 2.5 released

2013-09-23 00:00:00

Jansson 2.5 was released a few days ago. It was almost a year since last release, and a lot has happened during this time. In this post, I'll sum up the most important new features. For a more comprehensive list of changes, see the release notes.

New format specifiers

json_pack() and friends learned new format specifiers: s#, +# and +#. All of them deal with packing strings, and they work with both object keys and string values.

The s# format lets you define a length of a substring to be packed. Example:

const char *data = "abcdef";
json_pack("{s#: s#", data, 3, data + 3, 3);
/* ==> {"abd": "def"} */

The + format makes it possible to concatenate strings on the fly easily. It only works after a s or a +, and has the effect of joining the given string to the previous string:

json_pack("{s+: s++}", "abc", "def", "foo", "bar", "baz");
/* ==> {"abcdef": "foobarbaz"} */

And +# is of course for concatenating a substring. Here's a more complex example that shows that the new format specifiers can be mixed in any way you can think of:

const char *data = "abcdef";
json_pack("{s+#+: s#+#", "fed", data, 3, data + 3,
                         data, 1, data, 2);
/* ==> {"fedabcdef": "aab"} */

The new format specifiers are a response for two types of user needs that are discussed regularly on GitHub and mailing list: Creating string values from non-NUL terminated buffers by specifying a length, and making it easier to work with strings directly in Jansson without having to do the C level plumbing yourself. s# solves the first need, and + and +# help with a common use case of concatenating two strings, although they're definitely not a magic bullet for every string manipulation need.

There's also a good reason why these operations were implemented as an extension to json_pack() and not API functions of their own. Creating a new API function for every combination of possible string operations, encoding control, allocation schemes, etc. would need a vast amount of string functions. Extending all of this to object keys would make the situation three times worse.

CMake build system

Support for CMake was perhaps the single most requested feature for a long time. While GNU Autotools, Jansson's default build system, generally works well on Unix-like platforms, many people find CMake generally better and easier to use. It also has better support for non-Unix systems, namely Windows.

GNU Autoconf, Automake and Libtool still stay the default build system for Jansson. However, the CMake build system is complete in a sense that it does everything that the autotools build system does (generates documentation, runs tests, etc.).

Many thanks to Paul Harris for initially developing the CMake support, and to Joakim Söderberg for finishing the work and correcting many bugs and feature requests afterwards.

Smaller features

A new decoding flag JSON_DECODE_INT_AS_REAL was added. It makes the decoder return all numbers as reals, regardless of whether their text representation contains ., e or E.

json_array_foreach() macro was added, paralleling json_object_foreach(). Even though a loop over an array is easier to create, this macro makes it even simpler and better looking to iterate over an array:

json_t *array;  /* holds an array */
size_t index;
json_t *value;
json_array_foreach(array, index, value) {
    /* index is the current position of iteration,
       value is the JSON value at that position.
    */
}

The struct json_t can now be forward declared. This makes it possible to avoid including <jansson.h> in header files that declare global json_t * variables or funtions whose signature uses json_t *.

Jansson's documentation moved to Read the Docs

2013-08-21 00:00:00

Jansson's documentation has been moved to Read the Docs, an amazing service for hosting Sphinx-powered documentation. The documentation of many popular open source projects are already hosted on RTD (e.g. pip, South, Tornado), and it seems to be quite popular especially among open source Python projects.

The main motivation for me to do this change was the mobile aware Sphinx theme. For a long time I've been aware of the the fact that Jansson's documentation cannot be viewed nicely with mobile devices, so it was about time to fix it. The docs look a bit different now, but I think it's a change for the better.

In addition to mobile support, I also got automatic documentation builds for all branches. It was as easy as pointing RTD to Jansson's git repo and selecting tags and branches that get built automatically. GitHub has a built-in service hook that rebuilds changed docs each time I push. Could it be easier than this?

I hope you like the new documentation as much as I do!

Jansson 2.4 released

2012-09-23 00:00:00

Jansson 2.4 has been released. This release adds new features and fixes a few bugs and documentation issues. It also adds support for building the library on Microsoft Visual Studio. The full release notes are available here.

New features

A new macro, json_boolean(), was added. It returns either the JSON true or JSON false value based on its argument. It's useful in situations like this:

json_t *value;
int yes = read_value_from_somewhere();
value = json_boolean(yes);  /* false if yes == 0, true otherwise */

It's now possible to decode JSON with a callback providing the source JSON text. The new json_load_callback() function calls a callback repeatedly to read the source JSON. This is useful when the JSON data is received from a custom stream, for example.

JSON allows, but doesn't require, escaping / characters with \/. This is useful when JSON is embedded in a HTML <script> tag, because the string </ must not occur inside a <script> tag. When using the new JSON_ESCAPE_SLASH encoding flag, Jansson now escapes /'s for you.

Bug fixes

Until now, it has been possible to make Jansson produce invalid JSON by creating a real value with an Inf or NaN special value. json_real() and json_real_set() now check for these special values and refuse to accept them, returning -1 to signal an error. (As a matter of fact, json_real_set() returned 0 even on other errors, and this was fixed, too.)

Windows support

It's now possible to build Jansson on Windows with Microsoft Visual Studio. All the build errors have been fixed, and solution and project files for Visual Studio 2010 are included in the win32/vs2010/ directory in the source distribution.

Sala 1.3 released

2012-06-13 00:00:00

sala 1.3 is now available on PyPI!

New features:

Support for hooks, with a post-set hook initially supported. Patch by Jyrki Pulliainen.
Bash completion script for tab-completion in $SALADIR.

Other changes:

Move the repository state to the .sala subdirectory. .salakey becomes .sala/key and sala.conf becomes .sala/config. These files are moved when sala 1.3 is run the first time on an old repository. Initial patch by Jyrki Pulliainen.
Respect SALADIR when creating subdirectories with set.

When writing this post, I noticed that there was no announcement whatsoever for sala 1.2 last December. Even sala's homepage wasn't updated! I'll try to pay more attention from now on :)

Jansson 2.3.1 released

2012-04-20 00:00:00

Jansson 2.3.1 has been released. This release fixes some minor bugs and documentation issues. The full release notes are available here.

Jansson 2.3 released

2012-01-27 00:00:00

Jansson 2.3 has been released. This release adds new features and fixes some minor bugs and documentation issues. The full release notes are available here.

New features

New syntax for optional object keys was added to unpacking functions. For example, this call:

/* obj is a JSON object */
json_unpack(obj, "{s?i}", "foo", &myint)

only writes to myint if the key foo exists in obj.

New functions, json_object_update_existing() and json_object_update_missing() were added. They work like json_object_update(), but only update existing object keys or add new keys, respectively.

json_object_foreach() macro was added for convenient iteration over objects. For example, the following code prints all keys in an object:

/* obj is a JSON object */
const char *key;
json_t *value;

json_object_foreach(obj, key, value) {
    printf("Found key: %s\n", key);
}

The macro expands to an ordinary for loop, and its performance is comparable to hand-written iteration code. It's now also used internally in many places to replace old hand-written loops. Thanks to Marco Aurélio for the idea and initial implementation!

When decoding JSON, the number of bytes read from the input is now stored to error.position even if on success. This makes it possible to use the JSON_DISABLE_EOF_CHECK to decode multiple JSON texts from a single input also when decoding from string with json_loads() or json_loadb(). Before this change, it was only possible when decoding from a file stream using json_loadf(), because the file position could be used to determine where reading stopped.

Jansson can now decode any JSON value, not only arrays or objects. This support can be enabled with the new JSON_DECODE_ANY decoding flag. Note that this violates strict RFC 4627 conformance, so it should be used with caution. There are also some caveats when dealing with decoding errors. See the documentation for details. Patch by Andrea Marchesini.

Bug fixes

Each JSON object has an internal serial number that is used to record the addition order of keys. It's now reset when json_object_clear() is called to avoid it growing out of bounds for long-living objects. Handling of large serial numbers also now works better when encoding.

All decoding functions now properly return NULL when the first argument is NULL. Patch by Andrea Marchesini.

Obsolete leading + and zeros in exponents aren't written anymore when encoding real numbers. Jansson now also compiles and runs correctly on MinGW.

Jansson 2.2.1 released

2011-10-06 00:00:00

Jansson 2.2.1 has been released. This release fixes a major bug and little documentation and style issues.

The bug has to do with locales: Jansson's encoder and decoder both failed hard on real numbers when the locale's decimal separator was not the standard one. Furthermore, the decoder issued invalid error messages in some cases under non-UTF-8 locales.

The full release notes are available here.

Jansson 2.2 released

2011-09-03 00:00:00

Jansson 2.2 has been released. This release adds one new encoding function, json_dump_callback(), and fixes some minor bugs and documentation glitches. The full release notes are available here.

The new encoding function makes it possible to send encoder's output to a callback function. Here's an example:

#include <jansson.h>

/* Print the buffer's contents. */
int callback(const char *buffer, size_t size, void *x) {
    printf("%.*s\n", size, buffer);
    return 0;
}

int main() {
    json_t *root = json_pack("{s:s, s:i}", "greeting", "Hello, World!", "number", 42);
    json_dump_callback(root, callback, NULL, 0);
    return 0;
}

The third parameter to json_dump_callback() (NULL in this case) is passed through to the callback as x.

Thanks to Jonathan Landis for the initial patch!

Jansson is two years old

2011-08-25 00:00:00

Today is Jansson's birthday. The first release, Jansson 1.0, was released on August 25, 2009. At that time, I thought the library was substantially ready, and there would be only few or no new features to be added anymore. I was wrong.

Because I thought that the library was ready and mature, I was bold and gave it the version number 1.0. In open source software, it's quite common to have 0.x versions for years and years. The safety of 0.x versions lies in the illusion that you can break backwards compatibility in new versions. In my opinion it's like pulling the carpet from under the users' feet.

Quite soon it turned out that Jansson wasn't so mature and featureful after all. On Jansson's first birthday, version 1.3 had been out for two months and there were plenty of new features compared to 1.0. But there were a few problems that bugged me, and fixing them was not possible without breaking backwards compatibility.

It took a long time to make, but version 2.0 was finally released on February 28, 2011. It was the first, and hopefully last, backwards incompatible version, fixing design mistakes in the 1.x series. For the first time, I also tried to prepare for the future; the decoding functions got an extra, unused flags parameter for future needs. The preparing paid off, as version 2.1 already uses the new parameter, and we didn't need another backwards incompatible change to make it happen.

What's most remarkable, though, is that there are people out there who actually use Jansson to make awesome things happen! The library started out as a project to replace existing JSON libraries for C, just because none of them was appropriate for my needs. As time passed, it turned out that other people had similar needs, and that was the driving force for me to fix bugs, add new features, review patches, etc. Thank you everyone, without you there wouldn't be Jansson as we know it!

To celebrate the birthday, I was planning to release version 2.2 today. However, I've been extremely busy organizing PyCon Finland 2011 for the last weeks and months. I really hope to get 2.2 out soon.

Jansson 2.1 released

2011-06-11 00:00:00

Jansson 2.1 was released yesterday. This release adds a few new features and fixes some minor bugs. The full release notes are available here.

New features

A new decoding function, json_loadb(), was added for decoding buffers with length. The most important thing is that the input buffer need not be null terminated. In the future, it may also help to implement the support for zero bytes inside strings.

json_loadb() is like json_loads(), except that it takes an additional length argument:

value = json_loadb(buffer, length, 0, &error);

This version also introduces two new decoding flags and one new encoding flag:

JSON_REJECT_DUPLICATES: Issue a decoding error if any JSON object in the input contins duplicate keys.
JSON_DISABLE_EOF_CHECK: Stop decoding after a valid JSON input. This allows other data after the JSON data.
JSON_ENCODE_ANY: Allow encoding any JSON value. Without this flag, only arrays and objects can be encoded as the root value.

Bugfixes

Fix a memory leak when memory allocation fails in json_object_set() and friends.
Clear errno before calling strtod() for better portability (MINGW in this case).
Avoid set-but-not-used warning/error when building with the newest GCC.

Jansson 2.0.1 released

2011-04-01 00:00:00

Jansson 2.0.1 is out. This release fixes a few bugs, some of them major and some minor.

The most important bug fixes are:

Fix strict key checking in json_unpack() code. The strict mode (JSON_STRICT flag and the ! format character), checking that every object key is unpacked, didn't really work at all.
Fix the return value of json_object_size(). On error, it now returns 0, as documented. This may affect users if someone is relying on the buggy old return value of (size_t)-1.
Fix a few segfaulters when custom memory management is used.
Make the JANSSON_VERSION_HEX constant usable (by fixing the number of closing parentheses).

For full details, see the changelog. Special thanks to Eric Roy, Akos Polster and others who found bugs and provided patches!

New features of Jansson 2.0, part 3

2011-03-08 00:00:00

This post is the last one in a series of articles that give insight to the new features of Jansson 2.0; see part 1 and part 2.

Integer type

Up to version 1.3, the underlying type of JSON integer values was int. This approach limited the available numeric range and caused problems when using the Twitter API, for example, as it uses 64 bit integer IDs.

To overcome these issues, the underlying integer type was changed to the widest signed integer available in the system, i.e. long long if it's supported, falling back to plain long for older systems. The json_int_t typedef defines the actual type. The preprocessor constant JSON_INTEGER_IS_LONG_LONG is set to 1 if long long is supported, and JSON_INTEGER_FORMAT can be used for printing json_int_t values:

json_t *myint = json_integer(123);
printf("%" JSON_INTEGER_FORMAT "\n", json_integer_value(myint));

int should still be used in most cases when dealing with smallish JSON integers, as the compiler handles implicit type coercion. Only when the full 64-bit range is needed, json_int_t should be explicitly used.

Error reporting enhancements

New fields were added to the json_error_t struct that is used to pass error information to the caller. The following table lists all the fields. New fields in version 2.0 are marked with (new).

`char text[]`	UTF-8 error message
`char source[]`	Error source (e.g. file name)	(new)
`int line`	Input line
`int column`	Character column on the input line	(new)
`int position`	Number of bytes from the beginning of the input	(new)

column is the Unicode character column on which the error was encountered, i.e. a multi-byte UTF-8 character in input is treated as one character column. This may make it hard to debug Unicode problems. To remedy this, position gives the byte position of the error from the start of the input.

source is a string that contains the source of the error. When decoding, it is "<string>" when using json_loads(), "<stream>" when using json_loadf(), and the input file name when using json_load_file().

The json_error_t struct is also used to return errors from json_unpack_ex() and json_pack_ex(). In this case, line, column and position point to the position in the format string on which the error occured. source is "<format>" when the format string is invalid, "<args>" when there are problems with the variadic arguments (e.g. NULL string argument or invalid UTF-8 string), "<validation>" when the value being unpacked doesn't validate against the format string, or <internal> when an internal error occurs (e.g. out of memory).

Library version

Preprocessor constans defining the Jansson library version were added:

JANSSON_VERSION_MAJOR, JANSSON_VERSION_MINOR, JANSSON_VERSION_MICRO

Integers specifying the major, minor and micro versions, respectively.

JANSSON_VERSION

A string representation of the current version, e.g. "1.2.1" or "1.3". When micro version is zero, it's omitted from the version string.

JANSSON_VERSION_HEX

A 3-byte hexadecimal representation of the version, e.g. 0x010201 for version 1.2.1 and 0x010300 for version 1.3. This is useful in numeric comparisions, e.g.:

#if JANSSON_VERSION_HEX >= 0x010300
/* Code specific to version 1.3 and above */
#endif

Custom memory allocation

A function to set custom memory allocation functions was added. For example, to use the Boehm's conservative garbage collector, use

json_set_alloc_funcs(GC_malloc, GC_free);

Quite obviously, json_set_alloc_funcs() needs to be called before any other Jansson API function to make sure that all values are allocated and freed with the same set of functions.

New features of Jansson 2.0, part 2

2011-03-02 00:00:00

This post continues a series of articles that give insight to the new features of Jansson 2.0; see part 1.

This article is about the json_pack() API. It allows the user to build arbitrary JSON values using a simple format string-based approach. As with json_unpack(), the idea has been stolen from Python's C API.

Here are some examples:

json_pack("i", 42);
/* -> JSON integer 42 */

json_pack("{s: s, s: i}", "foo", "bar", "baz", 123);
/* -> JSON object {"foo": "bar", "baz": 123} */

json_pack("{s: [{s: i}, {s: i}]}", "data", "value", 15, "value", 16);
/* -> JSON object {"data": [{"value": 15}, {"value": 16}]} */

The first argument is a format string that describes the type and structure of the value that's being built. The format i creates an integer and s means a string (both as a value and an object key). {} and [] are used to build objects and arrays. Whitespace, : and , are ignored. As the last example shows, objects and arrays can be nested, there is no limit on the nesting depth. json_pack() returns the new JSON value, or NULL on error.

json_pack_ex() is also available. It makes it possible to get error messages and pass flags, although currently no flags are defined. Example:

json_t *value;
json_error_t error;

value = json_pack_ex(&error, 0, "[iii]", 1, 2, 3);
if(!value) {
    fprintf(stderr, "Error: %d:%d: %s\n", error.line, error.column, error.text);
    return -1;  /* error */
}

/* ... */

json_decref(value);

The errors that may occur are problems with the format string (e.g. unbalanced } or an invalid format character), out of memory errors and invalid UTF-8 in strings, so this function is mainly useful for debugging format strings.

json_pack() provides a powerful means of creating JSON values, both simple and complex. Without it, you might need tens of lines of code with ugly temporary variables to make nested objects or arrays. I think this is a great addition to Jansson's API and will make it a whole lot easier to create JSON data in C.

For full details of format characters, see the documentation.

New features of Jansson 2.0, part 1

2011-03-01 00:00:00

This post starts a series of articles that give insight to the new features of Jansson 2.0.

First up is the json_unpack() API. I think it's the most powerful new feature, allowing the user to perform two things on a JSON value: data extraction, and validation against a simple schema. The idea has been stolen from Python's C API.

Example:

/* Assume that obj is the following JSON object:
 *   {"x": 15.4, "y": 99.8, "z": 42}}
 */
json_t *obj;
double x, y, z;

if(json_unpack(obj, "{s:f, s:f, s:f}", "x", &x, "y", &y, "z", &z))
    return -1;  /* error */

assert(x == 15.4 && y == 99.8 && z == 42);

The format string passed to json_unpack() describes the structure of the object. The s format denotes an object key, and the f format means a real number value. Whitespace, : and , are ignored, so {sfsfsf} would be an equivalent format string to the one above.

After the format string, there's one argument for each format character. For object keys, a string specifies what key is accessed, and for real numbers, a pointer to double gives an address where to store the value.

The equivalent code without json_unpack() would be something like this:

json_t *obj, *tmp;
double x, y, x;

tmp = json_object_get(obj, "x");
if(!json_is_real(tmp))
    return -1;  /* error */
x = json_real_value(tmp);

/* repeat for y and z */
/* ... */

printf("x: %f, y: %f, z: %f\n", x, y, z);
/* ==> x: 15.4, y: 99.8, z: 42 */

The code that uses json_unpack() is much shorter and cleaner, and it's easier to see what it's doing.

Nested values are supported, too:

/* Assume that nested is the following JSON object:
 *   {"foo": {"bar": [11, 12, 13]}}
 */
json_t *nested;
int i1, i2, i3;

if(json_unpack(nested, "{s:{s:[iii]}}", "foo", "bar", &i1, &i2, &i3))
    return -1;  /* error */

assert(i1 == 11 && i2 == 12 && i3 == 13);

This time, the format string has two nested objects and a nested array. There's no limit on the nesting levels. The variable arguments are used in the "flat" order in which they appear in the format string.

The same API can also be used in a validation-only mode, i.e. without extracting any values. Error messages are also available:

/* Assume the same JSON object as in the previous example */
json_t *nested;
json_error_t error;

if(json_unpack_ex(nested, &error, JSON_VALIDATE_ONLY,
   "{s:{s:[iii]}}", "foo", "bar"))
{
    fprintf(stderr, "Error: %d:%d: %s\n", error.line, error.column, error.text);
    return -1;
}

The json_unpack_ex() function is the extended version of json_unpack(). It takes an error parameter, similar to decoding functions, and optional flags to control the behaviour. The JSON_VALIDATE_ONLY flags tells it to only validate and not to extract anything. Extra arguments after the format sting are only required for object keys. The available validation is quite simple, only the object/array structure and value types can be checked, but usually this saves a lot of code.

I strongly believe that this feature, along with the json_pack() API described in the next part, will make it an order of magnitude more pleasant to manipulate JSON data in C. Many thanks to Graeme Smecher for suggesting this and providing the initial implementation.

This article only gave a few examples. For full details, all available format characters and flags, see the documentation.

Jansson 2.0 released

2011-02-28 00:00:00

Jansson 2.0 is finally out. This is a new major release that is (slightly) backwards incompatible with the older versions.

See the changelog for more details, and the documentation chapter Upgrading from 1.x for instructions on how to upgrade from older versions.

Sala 1.1 released

2011-02-02 00:00:00

I just uploaded sala 1.1 to PyPI. This release adds ~/.config/sala.conf (or, more specifically, $XDG_CONFIG_HOME/sala.conf) to the list of configuration locations that are read, as per the XDG Base Directory Specification. Python 2.5 is also now supported.

I'm also planning to package sala for Ubuntu in the near future. Stay tuned.

Generating data files in setup.py

2011-01-28 00:00:00

In a work project, I have a few JavaScript files that are generated from a bunch of other files. The project is a Django website, so I just have views that generate the files on-the-fly when running in debug mode, and everything works nice and smooth.

For production, though, I needed the flat files that would be served from disk. I figured out that the best approach would be to generate the files in setup.py upon installation, but I could only find very superficial documentation on how to do that.

A brief intro to setup.py: In every project's setup.py file, the setup function, from Python standard library's distutils.core module, is used to define the project's files and metadata. (setup can also be imported from from setuptools or distribute, but they're compatible with distutils.) With the standard commands that setup.py provides, the files and metadata can be compiled to an egg, distributed as a source tarball, uploaded to PyPI, and so on.

The entry point to altering setup.py's behaviour is the optional cmdclass argument to the setup function. It's value is a dict from command names to distutils.command.Command subclasses that implement the commands. The build_py command is where the package data files are installed, so to override build_py, I created the class my_build_py and registered it, like this:

from distutils.core import setup
from distutils.command.build_py import build_py

class my_build_py(build_py):
    # ...

setup(
    # Define metadata, files, etc.
    # ...
    cmdclass={'build_py': my_build_py}
)

The run method of build_py, along with copying and compiling the Python source files, is responsible for copying the packages data files to the build directory build/lib.<platform>. (The actual directory name is stored in the build_py instance's self.build_lib variable.)

To install your own files, just override the run method. Remember to call the superclass after you're done with your own files.

def generate_content():
    # generate the file content...
    return content

class my_build_py(build_py):
    def run(self):
        # honor the --dry-run flag
        if not self.dry_run:
            target_dir = os.path.join(self.build_lib, 'mypkg/media')

            # mkpath is a distutils helper to create directories
            self.mkpath(target_dir)

            with open(os.path.join(target_dir, 'myfile.js'), 'w'):
                fobj.write(generate_content())

        # distutils uses old-style classes, so no super()
        build_py.run(self)

And that's it! A later phase of the installation copies everything from build/lib.<platform> to the correct place, so your generated file gets in, too.

Sala 1.0 released

2011-01-19 00:00:00

For some time now, I've been unsatisfied with the state of user names and passwords for the numerous services I use in the web. I'm having hard time to remember all the services I have singed up to and a bad habit of using a few common passwords for all of them.

So, I hacked for a while, and yestreday, I pushed the first release of sala to PyPI. It's is a simple, filesystem based, encrypted password storage system that uses GnuPG's symmetrical encryption. As usual, a git repository is available at GitHub.

The main idea of sala is to store passwords (or other tiny, plain-text secrets) in encrypted plain-text files in a directory hierarchy, like this:

/path/to/passwords
|-- example-service.com
|   |-- +webmail
|   |   |-- @myuser
|   |   `-- @otheruser
|   `-- +adminpanel
|       `-- @admin
`-- my-linux-box
    |-- @myuser
    `-- @root

As sala is a command line utility and there's one file per password, tab completion and other shell goodies are available. The custom of prefixing user names with @ and category/group/subservice names with + is my own preference and not enforced by the program. You may come up with your own scheme, for example if you want to protect user names as well as the actual passwords. For more information, see the PyPI page.

Use pip install sala to install, or download the source, unpack, and invoke python setup.py install. In addition to Python 2.5 or newer, requires gpg and GnuPGInterface. Currently, Python 3 is not supported because GnuPGInterface doesn't support it.

Update: While writing this blog entry, I found a few packaging bugs, and released version 1.0.1.

Old Jansson news

2011-01-04 00:00:00

All the project news are now gathered in this blog, and I don't want old Jansson news to disappear, so here you go:

2010-06-13	Jansson v1.3 released! This release adds one new encoding flag, enhances the documentation a bit and fixes a few bugs. See the changelog for full details.
2010-04-03	Jansson v1.2.1 released! This is a bugfix release in the 1.2 series. See the changelog for full details.
2010-01-21	Jansson v1.2 released! This release adds new features and fixes some bugs. See the changelog for full details.
2009-12-18	Jansson v1.1.3 released! This is a bugfix release in the 1.1 series. See the changelog for details.
2009-11-08	Jansson v1.1.2 released! This is a bugfix release in the 1.1 series. See the changelog for details.
2009-10-26	Jansson v1.1.1 released! This release only fixes some documentation packaging issues present in v1.1. For details, see the changelog.
2009-10-20	Jansson v1.1 released! This release adds lots of new features and fixes a few bugs. For details, see the changelog. In addition to tar.bz2, the source is now also distributed in tar.gz form.
2009-10-11	Jansson v1.0.4 released! This is a bugfix release in the 1.0 series. See the changelog for details.
2009-10-09	Jansson now has a mailing list: jansson-users.
2009-09-14	Jansson v1.0.3 released! This is a bugfix release in the 1.0 series. See the changelog for details.
2009-09-12	Ubuntu packages available in Jansson PPA at Launchpad. See below for details.
2009-09-08	Jansson v1.0.2 released! This is a bugfix release in the 1.0 series.
2009-09-04	Jansson v1.0.1 released! This is a bugfix release in the 1.0 series.

Blog created

2011-01-04 00:00:00

I decided to start a blog. At first, I will publish news and info for my projects here. Later, I might also write something else.

As the whole site is developed using Stango, this blog is actually a Stango application, the first one. It's an early work in progress.

The site was also redesigned. I hope you like the result.