SRA Lab Open Source Code

libsoup and Django

If you need to interface C code with a Django app, you should consider to use libsoup. It's a nice HTTP client/server library based on GObject and integrated with the glib main loop.

This is the code I used to authenticate with libsoup against my Django application (and the code is similar for any forms):

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <glib.h>

#include <libsoup/soup.h>
#include <libsoup/soup-auth.h>

static char* django_get_csrftoken_from_body(SoupMessage *msg)
{
    char *csrftoken = NULL;
    char *p_found;

    p_found = g_strrstr_len(msg->response_body->data,
                msg->response_body->length,
                "csrfmiddlewaretoken");
    if (p_found != NULL) {
    csrftoken = g_strndup(p_found + strlen("csrfmiddlewaretoken' value='"),
                  strlen("c711343cd20077a3aa869fcc9b931ff3"));
    }
    return csrftoken;
}

static int django_authenticate(SoupSession *session, const char *base_uri)
{
    char *uri;
    SoupMessage *msg;
    char *csrftoken;

    uri = g_strconcat(base_uri, "login/", NULL);
    msg = soup_message_new(SOUP_METHOD_GET, uri);
    soup_session_send_message(session, msg);
    printf("Login Status Code: %d\n", msg->status_code);
    if (msg->status_code != 200) {
    g_object_unref(msg);
    g_free(uri);
    return -1;
    }

    csrftoken = django_get_csrftoken_from_body(msg);
    g_object_unref(msg);

    printf("CSRF token %s\n", csrftoken);

    msg = soup_form_request_new("POST", uri,
                "username", "MYUSERNAME",
                "password", "MYPASSWORD",
                "csrfmiddlewaretoken", csrftoken,
                NULL);
    soup_session_send_message(session, msg);
    printf("POST Login Status Code: %d\n", msg->status_code);
    printf("Message %s\n", msg->response_body->data);

    g_free(csrftoken);
    g_object_unref(msg);
    g_free(uri);

    return 0;
}

int main(int argc, char** argv)
{
    SoupSession *session;
    SoupCookieJar *jar;

    g_type_init();

    session = soup_session_sync_new();

    /* Accept all cookies */
    soup_session_add_feature_by_type(session, SOUP_TYPE_COOKIE_JAR);
    jar = SOUP_COOKIE_JAR(soup_session_get_feature(session,
                           SOUP_TYPE_COOKIE_JAR));
    soup_cookie_jar_set_accept_policy(jar, SOUP_COOKIE_JAR_ACCEPT_ALWAYS);

    django_authenticate(session, "http://localhost:8000/");

    soup_session_abort(session);
    g_object_unref(session);

    return 0;
}

The perfect git workflow!

It's strangely hard to find documentation on the git workflow to follow to keep a clean commit history when you want to merge external contributions.

First enable rebasing by default

As it's written on live.gnome.org, many users find that they happen to do "git pull --rebase" most of the time. Would be nice if "git pull" simply did that by default. You can set that up for the master branch of all your repositories by:

git config --global branch.master.rebase true

An upstream project

For our example, we've an upstream project with only one commit called C1

mkdir upstream
cd upstream
git init
touch hello.c
git add hello.c
git commit -m "C1"

Your fork

As contributor, you can fork as usual and commits your changes on a specific branch (newfeature).

git clone upstream fork
cd fork
git checkout -b newfeature
edit hello.c
git commit -a -m "C2"

When you're ready to ask for a pull request, sync with upstream project with a final "git pull" to help the maintainer to merge your patches (it's not mandatory).

Back to upstream

In the meantime, it's possible some new commits have landed in upstream.
As maintainer, you receive an email: "Could you merge my branch, please?", so you add the repository to your remote list to fetch the content:

git remote add fork ../fork/
git fetch fork

and create a branch to rebase the contributor work in a separated branch:

git checkout -b fork fork/newfeature
git rebase master (and resolve if necessary)

You can now apply the fast-forward merge on your master branch
git checkout master
git merge fork

You're done with a nice commit history w/o ghost commits.

On the contributor side

Just delete your branch because after a rebase in upstream, your branch is certainly broken so it's time to cleanup:

git branch -D newfeature

Thanks to Staz and Dodji on #gnomefr chan.