So, the long-awaited release of gksu-polkit is here

I’m looking for people who are interested in testing the first release of gksu-polkit. I uploaded the first tarball to http://people.debian.org/~kov/gksu/gksu-polkit-0.0.1.tar.gz. There are also x86 packages available (built on a sid with a lot of experimental stuff, so if you have trouble installing please email me and I’ll have that fixed =P).

For some history and discussion on the whys and hows do take a look at the README which exists inside the tarball (or git repo), and on the small page I wrote about it. For those who want to fiddle with the code, and perhaps help me finding bugs and fixing them, here’s my public git tree:

git://git.debian.org/~kov/gksu-polkit.git

gksu gets pipe capability

One of the features I really wanted to get into gksu-policykit early was working correctly with pipes. With the current gksu you cannot do something such as echo blah | gksu tr a-z A-Z. It is actually very hard to work correctly with input/output with su and sudo bellow. I do think it also has something to do with me not being too clever in UNIX file descriptors at the time I originally planned how gksu works. I did get an email from someone at Sun offering to write support for that who never mailed me again, but anyway…

gksu-policykit is currently able to get all the input and output forwarded to/from the process by using an interface similar to glib’s g_spawn_async_with_pipes. Here’s what we are able to do already:


kov@abacate:~/src/gksu-polkit$ echo test string | ./gksu/gksu-polkit /usr/bin/tr a-z A-Z
TEST STRING
kov@abacate:~/src/gksu-polkit$

It’s impressive to me that all the input and output goes over DBus quite nicely.

PolicyKit rules, and, when error handling bites you

PolicyKit, as I said before, is the authentication/authorization framework that will finally replace the gksu hack with a real solution. I am playing with some test code to be able to perhaps contribute with that goal. Everything was going forward pretty nicely in my tests when I hit a blocker. I spent like two hours trying to figure out the problem. Here’s the code:


sender = dbus_message_get_sender(message);
pk_caller = polkit_tracker_get_caller_from_dbus_name(pk_tracker,
sender,
&dbus_error);
if(dbus_error_is_set(&dbus_error))
{
g_error("Failed to get caller from dbus: %s: %s\n",
dbus_error.name, dbus_error.message);
return NULL;
}

When my mechanism goes to check if the caller is allowed to run the action, I first need to get the caller, of course. That code was always failing with this error message:


** ERROR **: Failed to get caller from dbus: org.freedesktop.DBus.GLib.UnmappedError.CkManagerError.Code0: Unable to lookup session information for process '25594'

It took me a long time, and a lot of code reading on PackageKit to realize the real simple problem with my code: I was assuming that the DBUS error would only be set if polkit_tracker_get_caller_from_dbus_name failed, which is just not the case. The DBUS error was set, but the function actually worked, most probably getting the information it needed from some other thing than ConsoleKit. So that brings us to something like this:


sender = dbus_message_get_sender(message);
pk_caller = polkit_tracker_get_caller_from_dbus_name(pk_tracker,
sender,
&dbus_error);
if(pk_caller == NULL)
{
if(dbus_error_is_set(&dbus_error))
{
g_error("Failed to get caller from dbus: %s: %s\n",
dbus_error.name, dbus_error.message);
return NULL;
}
}

And, voi lá!

O substituto do gksu demorou, mas vem aí!

E já estava na hora! O gksu, embora na época tenha feito uma enorme diferença na usabilidade de desktops GNOME de sistemas não-red hat não parece se encaixar na atual estrutura do desktop livre. As novas estruturas de gerenciamento de dispositivos removíveis foram as primeiras a mostrar uma forma mais inteligente de tratar tarefas que necessitam de maiores privilégios: o que eles fizeram foi separar a política do mecanismo, que aliás é uma das primeiras boas práticas em que se deve pensar ao projetar sistemas.

A idéia é que as aplicações que desenham janelas e permitem que o usuário decida o que quer não precisam de nenhum privilégio maior, e não é bom que se tenha todo o código da GTK+, por exemplo, rodando como root. Uma ferramenta menor, e somente com as dependências realmente necessárias faz o trabalho sujo de, com privilégio de root, executar as tarefas que necessitam dele; no caso dos dispositivos removidos esse é o pmount, mais recentemente o gnome-mount.

Agora esse modelo está sendo trazido de maneira mais geral para os nossos desktops livres, através do PolicyKit. Eu já estou lendo a documentação e os posts de blog para reescrever o gksu para usar o PolicyKit como base. Isso vai fazer com que ele pare de ser um wrapper para su e sudo, finalmente, com um design muito mais elegante. Ainda haverá aplicações que terão de rodar com uid 0 por algum tempo. Eu, particularmente, vou começar desde já a torcer para que o gksu deixe de ser necessário o mais rápido possível =).

Eu vou ao FISL… Debian e devaneios sobre educação

Eu não ia. Tinha resolvido que era melhor focar somente no evento de Maio, no Amazonas, em que vou falar de Debian e TurboGears e na Debconf, para a qual já comprei passagem e estou pleiteando financiamento, inclusive.

Mas aí fiquei sabendo pelo meu chefe que o MDS, onde eu trabalho hoje em dia, vai patrocinar o evento e que terá direito a uma palestra, e fui escalado junto com a Fabiana, desenvolvedora PHP que cordena a equipe de desenvolvimento do Ministério.

A apresentação é sobre um assunto interessante e tem bastante resposta pra ‘show us the code’, embora, como todas as iniciativas de governo que existem, seja bastante ‘marginal’, não indo tão a fundo no conceito do software livre, sendo mais usuário que produtor.

Então poderemos nos ver por POA no FISL! No campo Debian, estou ansioso pela saída da Etch, e pela Debconf. Minha vida debiânica tem sido basicamente manter os pacotes do gksu e TG redondinhos e com traduções atualizadas para a Etch, mas minha cabeça já está borbulhando com idéias para a próxima era do gksu; vou detalhá-las mais aqui em outra ocasião.

Outra coisa que tem estado bastante na minha cabeça é Educação; não é novidade pra quem me conhece que eu sempre pensei muito sobre como aprender e como a educação deveria ser. Postei várias vezes nos meus antigos blogs sobre isso. Por diversas razões tenho pensado muito nisso nos últimos tempos. A idéia principal que gira na minha cabeça ultimamente é que talvez fosse muito melhor se a educação fosse focada em habilidades, ao invés de ser focada em conhecimento.

Por que não ensinar as pessoas a entender e resolver problemas, ao invés de fazê-las decorar métodos de resolução de equações de segundo grau, por exemplo? Não seria mais útil ensinar interpretação de textos de verdade ao invés de obrigar pessoas a decorarem regras de gramática? Estive pensando bem e acho que a única habilidade que nós realmente praticamos durante nossa vida escolar é a de memorizar; bastante alinhada com a realidade que conhecemos na vida profissional, se você pensar bem… de que tipo de habilidade você precisa para fazer certificações e concursos, afinal? =)