J’ai voulu voir un peu le système de plugin proposé par weechat, (à savoir qu’il supporte beaucoup de langage, tel que perl, ruby, python, lua, tcl) et donc à l’aide de la documentation fournis sur leur site, créer deux petit scripts sans prétention (loin de là!) mais qui peuvent peut être donner des idées à certain, ou même l’envie de s’y plonger.

Pour ce faire, j’ai choisi python comme langage, surtout parce que leur exemple sont fournis avec python, donc ça était plus rapide, mais le choix est libre à chacun.

nocolor

n’étant pas toujours que sur freenode, certain IRC tolère les couleurs d’écritures… ce qui me fait pester à chaque fois, mais comme je vais pas refaire le monde, il est bien plus simple de s’adapter avec un petit script qui surprime toute forme de couleurs, gras, soulignage des messages. (tout en gardant les join/part avec les couleurs régler dans le script). Aussi curieux que ça puisse paraitre, ce n’est pas un paramètre de configuration disponible, ou je n’ai pas trouvé. Voici donc le petit script, sous un classique GPL évidemment.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#   nocolor.py
#   Author nicolas 
 
import weechat
 
SCRIPT_NAME     = "nocolor"
SCRIPT_AUTHOR   = "nicolas "
SCRIPT_VERSION  = "0.1"
SCRIPT_LICENCE  = "GPL3"
SCRIPT_DESC     = "delet user's color"
 
weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION,
                 SCRIPT_LICENCE, SCRIPT_DESC, "", "")
 
def nocolor_cb(data, modifier, modifier_data, string):
    if "privmsg" in modifier_data:
        strnocolor = weechat.string_remove_color(string, "")
        return strnocolor
    return string
 
hook = weechat.hook_modifier("weechat_print", "nocolor_cb", "")

Pas de quoi casser trois pattes à un canard me diriez vous, et vous avez bien raison !
Pour la petite explication, un hook est placer pour modifier la ligne imprimé grâce à un callback (nocolor_cb), et une fonction existante sous weechat permet de supprimer la couleur. Il faut juste noté que la fonction weechat.register n’est pas une coquetterie de ma part, mais une fonction obligatoire pour tout script. Simple, mais cela fait son effect. Le fichier est placer dans ~/.weechat/python/autoload/nocolor.py et peut être loader à chaud par un /python load nocolor.py dans le client IRC.

counter

Autre script, le but est de compter les kicks et glines, stocker se compte dans un fichier ~/.weechat/python/count.var (créer s’il n’existe pas) pour que le compte soit récupérer d’une fois sur l’autre, le compte est affiché directement dans la raison du kick/gline, sous la forme « raison du kick (n°N) ».
Encore une fois, rien de bien compliqué.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# -*- coding: utf-8 -*-
#   count.py
#   Author nicolas 
 
import weechat
import os
import ConfigParser
 
SCRIPT_NAME     = "count"
SCRIPT_AUTHOR   = "nicolas "
SCRIPT_VERSION  = "0.1"
SCRIPT_LICENCE  = "GPL3"
SCRIPT_DESC     = "kick and gline counter"
 
weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION,
                 SCRIPT_LICENCE, SCRIPT_DESC, "", "")
 
home = os.environ['HOME']
path = home + "/.weechat/python/"
var = ConfigParser.RawConfigParser()
 
if os.path.isdir(path):
    os.chdir(path)
 
if os.path.isfile('count.var'):
    var.read('count.var')
    kick = var.getint('count', 'kick')
    gline = var.getint('count', 'gline')
else:
    var.add_section('count')
    kick = 0
    gline = 0
    var.set('count', 'kick', kick)
    var.set('count', 'gline', gline)
    with open('count.var', 'wb') as configfile:
        var.write(configfile)
 
def kick_cb(data, modifier, modifier_data, string):
    global kick
    kick +=1
    var.set('count', 'kick', kick)
    with open('count.var', 'wb')as configfile:
        var.write(configfile)
    string = "%s (n°%s)" % (string, kick)
    return string
 
def gline_cb(data, modifier, modifier_data, string):
    weechat.prnt("", modifier_data)
    global gline
    gline +=1
    var.set('count', 'gline', gline)
    with open('count.var', 'wb')as configfile:
        var.write(configfile)
    string = "%s (n°%s)" % (string, gline)
    weechat.prnt("", string)
    return string
 
hook_kick = weechat.hook_modifier("irc_out_kick", "kick_cb", "")
hook_gline = weechat.hook_modifier("irc_out_gline", "gline_cb", "")

Pour la petite explication, la 1èr moitié concerne le fichier de count.var, voir s’il existe, sinon il est créer grâce à ConfigParser. Ici sont défini deux callback non plus sur le print, mais sur la commande directement (kick, gline) pour avoir le callback correspondant.

Conclusion

C’est sans prétention, que je partage ces deux « plugin » pour weechat, qui ne serviront peut être à personne, mais, qui sait, peuvent aider pour l’élaboration d’autre extensions. (heureusement que le ridicule ne tue pas, j’ai un peu l’air ridicule avec ces deux scripts à deux balles :þ)

Mais avant d’aller plus loin, je tiens d’ores et déjà à remercier toutes les personnes qui m’ont soutenu et lu, au long de divers articles.

Le premier constat que je peux faire, c’est je pense avoir tenu même ligne, c’est à dire un mélange d’actualité linuxienne pouvant être plus insolite ou anecdotique pour paraitre dans les grands médias spécialisé sur le domaine tout en gardant une spécialité pour Arch Linux, ainsi que des tutoriels et pense bêtes, et comme je l’avais prévenu, un peu de programmation, le tout je pense sans tomber dans des travers de sensationnalisme qu’on peut trouver dans certains blogs sur Linux à plus grand trafic. Je ne voulais pas faire des billets d’humeur ou bien même sur des sujets tels que Hadopi, de toute façon bien d’autres personnes s’en s’ont charger au travers du net (parfois même un peu trop je trouve).

Autre point sur lequel je suis content, c’est mon français, et plus particulièrement mon orthographe. Bien que je fasse encore énormément de fautes, je pense avoir progresser, et cela grâce à l’écriture sur le blogue. Il y avait un énorme travail à faire sur ce point là, et le chemin est encore long, mais je m’implique pour faire moins de fautes, et apprendre les règles simples du français.

Vous n’aurez pas manqué de remarquer une baisse dans la parution des articles, et c’est un fait. D’une part cela prend du temps, tout en demandant une certaine dose de patience et de courage. Je regrette de ne pas publier plus souvent, et je ne compte pas laisser de côté ce blogue. sachant que certain article demande du temps à rédiger, pour regrouper la documentation, mettre en page et tout ça…

Quelques chiffres traditionnel de circonstance pour Nic0′s Sphere :

• 127 Articles
• 254 Commentaires
• Entre 100 et 200 visites par jour dépendant un peu de l’activité du blog

Certains trouveront ces chiffres très dérisoire, surtout pour les blogues à gros trafic, mais pour sûr je prends plaisir à le faire, et c’est ce qui compte, sujet après sujet.

En dernier point, j’aimerai remercier une fois encore ceux aillant soutenu, lu ou même contribuer de près ou de loin à ce blog. Et j’espère sincèrement publier un peu plus prochainement.

Explication que je me permet de traduire ici pour qui l’anglais rebute un peu.

Récemment, On m’a demandé souvent pourquoi il n’y a pas eu de magazine ces deux derniers mois. Je pense que je vous doit une explication. Nous avions programmé un numéro spécial le mois dernier, mais les personnes avec que je travaillais on lâché au dernier moment, et je me suis retrouvé sans contenu. C’est arrivé souvent ces derniers temps, et je dois admettre que j’en ai un peu mare de ça. Comme je l’ai déjà dit souvent dans le passé, monter le magazine (et même l’ancienne newsletter) demande du travail et du temps, pour plus d’une personne. Toute fois, malgré mes appels constants à la contribution, je n’ai toujours pas plus d’une ou deux soumission par mois. J’ai fait tout ce que j’ai pu pour en facilité la communauté et rendre le processus plus facile. (jeter un œil sur la page de wiki de l’ALM par exemple), mais les retours ne sont pas loin d’être nul. Et encore, on me demande constamment quand sera la prochaine sortie, ou pourquoi j’ai manqué un mois. Si la moitié des personnes qui m’ont demandé à propos de la prochaine sortie du magazine avait mis un peu de leur temps à écrire un court article, et bien peut être que le prochain magazine serait déjà sortie. Mais la vérité, c’est que je n’ai juste pas le temps d’écrire la totalité du magazine moi même tout les mois. Donc… à partir de maintenant, le magazine sera sortie se fera au rythme des contributions, aussi souvent que j’ai de quoi sortir un numéro. Je me restreindrai à écrire un article par numéro si besoin, en plus des sections habituelle, (devland, interviews, software…) et je laisse le reste au soins de la communauté. En d’autre termes, à tout ceux qui continu de me demander ce que devient l’ALM… si vous voulez le voir, contribuez !
– Ghost1227

À bon entendeur… et comme toujours, si vous souhaitez participer au magazine, il suffit de suivre les démarches décritent sur cette page de wiki.

Les sauvegardes de bases SQL ne déroge pas à cette règle, que ce soit sur un PC personnel, ou sur un serveur, il est toujours important de faire des sauvegardes, et comme on n’a pas forcément envie de se connecter au phpmyadmin à chaque fois pour le faire (ça serait fait une fois dans le moi de cet sorte :þ), voici une petite astuce très simple à mettre en place.

Si comme moi, vous aimez bien séparer les bases, en créant un user spécifique pour une application donnée, pour réduire l’utilisation de l’user root sur les bases, le petit script suivant devrait faire votre affaire. Il vous permet également d’obtenir les différentes sauvegardes dans des fichiers propre à chaque user. La syntaxe est très simple, sans avoir besoin d’explication.

#!/bin/sh
 
mysqldump -uwordpress -pmonpass --all-databases > backup.wp.sql
mysqldump -uforum -pmonpassquitu --all-databases > forum_back.sql

Autant dire un jeu d’enfant !
Avec bien sûr en argument :

• -u : user de la base à sauvegarder.
• -p : pass correspondant à l’user.

Il vous reste à rendre exécutable se script, et d’en restreindre l’accès comme tout fichier sensible, avec un chmod 700.

Pour l’automatiser le tout, un petit cron (tout simple avec la fréquence d’exécution voulu), et là encore pas besoin de plus d’explication pour se faire, sinon, des tutoriels sont disponible facilement là dessus.
On pourrait amélioré le script en faisant des logs tournante sur plusieurs jours, car là, elle sont automatiquement effacé.

Pour sûr les choses on évolué de tel sorte que maintenant, n’importe qui peut utiliser et installer une distribution Linux, sans risques. Plus besoin de connaissances pour installer, utiliser, administrer Linux.

Comme les réputations sont toujours tenaces, Linux reste dans les esprits des non-initiés comme quelque chose de compliqué, fastidieux et/ou non-aboutit. Linux accessible pour tous est maintenant devenu une réalité, il suffit de lire quelques débats enflammés pour s’en convaincre. Paradoxal parfois même le fait de promouvoir l’esprit des Logiciels Libres au plus grand nombre, et d’un autre côté décrier les pratiques de distributions dites grand public à rendre accessible leurs produits. Cette évolution n’est pas sans diviser les opinions de la communauté, à savoir si c’est bien d’automatiser les installations, configurations, et l’administration. Mais que cela en déplaise certain, l’évolution va vers une vulgarisation de Linux. Il ne devient pas rare de lire des réflexions du genre « même ma grand-mère utilise Linux maintenant », (non pas sans un petit coup de main des petits enfants certainement). On peut souligner les installeurs automatiques rendant l’installation de Linux accessible à quelques clicks près, le tout cohabitant simplement avec Windows en dual-boot.

Une des grandes force de Linux est sa diversité, si tel ou tel chose ne te plaît pas sur ton PC, pas de problème tu peux prendre autre chose, c’est vrai pour les logiciels, mais aussi pour les distributions elle-même, on en dénombre une quantité impressionnante, mais ça en fait aussi sa faiblesse, comme les discussions enflammé du pourquoi tel ou tel distribution est meilleur ou je ne sais quoi encore, me faisant pensé à un titre d’un article de je ne sais plus quel site (ça pourrait être phoronix tient) stipulant : « Et si le premier danger de Linux venait de sa communauté elle-même ». Ça peut en faire une faiblesse aussi dans le sens qu’a trop diversifier, à forker à tout va, ou réécrire des applications déjà existante dans d’autre langages, pour apporté au final pas grand chose si ce n’est une division du potentiel des programmeurs, et des exemple de cela il y en a à la pelle…

Linux est un peu un cas unique dans les système d’exploitation Libre, que se soit chez *BSD ou Solaris, il n’y a pas des centaine de distributions, et ne fait certainement pas débats aussi virulents au sein de leur communauté.

Il serait difficile de parler de distributions grand public sans nommer Ubuntu et dérivée. Pour beaucoup, ce sera la distribution de transition d’un système propriétaire vers Linux, mais ce n’est pas la seul possibilité, pour ne citer que PCLinuxOS par exemple, mais beaucoup choisiront Ubuntu, peut être plus pour sa notoriété et sa communauté (documentation et forums) que pour des raisons vraiment techniques. Il peut être parfois difficile de parler d’Ubuntu sans tomber dans les travers cité plus haut, à savoir ne pas tomber dans des discussions polémiques et sans fin, du bien ou du mal des choix de directions prisent d’Ubuntu/Canonical.

En conclusion, (d’un bavardage s’éloignant un peu du titre), oui Linux devient accessible à tout le monde, et l’évolution ira dans ce sens inévitablement, expliquant peut être la croissance du nombre d’utilisateurs sous GNU/Linux, et oui les conflits au sein même de Linux n’est pas près de s’arrêter !

Comme il est toujours plaisant d’en avoir un retour, et que en plus quelques demandes de nouvelles fonctionnalités ont été faites, j’ai réouvert mon IDE favoris (vim :þ) pour apporté ces nouvelles fonctionnalités.

Un merci à bacardi55 et hobbestigrou pour avoir essayé Twitturse, pour leur retour, et leur soutient au projet.

Pour cette version 0.1.1, quelques nouveautés (ça reste une béta je suppose, bien que je ne l’ai pas indiqué…)

• (c)lear : permet d’effacer tout les tweets, en ne gardant que le dernier ;
• (f)ollow et (u)nfollow : permet de suivre ou laisser une personne ;
• (h)elp : en cas de trou de mémoire, une petite page résument les touches s’affiche ;
• Lorsqu’une petite fenêtre est ouverte (pour écrire un tweet pas exemple) elle ne se trouve plus effacé au bout d’un moment, le rafraîchissement des status est bloqué ;
• Lorsque les status son rafraichit, il ne sélectionne plus le dernier, mais reste sur celui sélectionné ;
• Le temps de rafraîchissement des status est parsé à partir du fichier de configuration, s’il n’est pas indiqué, il sera par défaut à 60 secondes ;
• Et je crois que c’est tout, c’est déjà pas mal :)

Pour un aperçu, avec screenshots, regarder le billet précédent.

L’installation n’a pas beaucoup changer par rapport à la dernière fois :

wget http://src.nicosphere.net/twitturse/twitturse-0.1.1.tar.bz2
tar xvf twitturse-0.1.1.tar.bz2
cd twitturse
./configure --prefix=/usr
make
sudo make install

Ainsi qu’un petit changement dans le fichier de configuration, .twitturserc dans la racine du home :
login "pseudotwitter"
passwd "mot_de_pass_twitter"
refresh "60"
Mais il reste compatible avec l’ancienne version puisque refresh n’est pas obligatoire.

Voilà, je crois que tout est dit pour cette nouvelle version de Twitturse, bon tweets à tous !

Mais rapidement on vient à en regretter qu’il ne fait pas un usage d’une bibliothèque ncurses, utilisant ainsi de façon optimisé l’espace disponible dans la console, ainsi qu’une meilleur édition des tweets.

Lorsque je me suis mis à twitter, je me suis mis quasiment aussitôt à la recherche d’un client ncurses, et ne trouvant pas, je m’était donc « rabattu » sur TTYter.

ÉDIT: Une nouvelle version avec plus de fonctionnalité est disponible, lire ce billet pour plus de détails.

Dans l’optique d’apprentissage du langage C, rien de tel que la pratique. Je me suis mis en tête, l’idée de faire un client twitter ncurses, pour le moment vraiment très basique, le tout écrit en langage C (avec les bibliothèque ncurses, curl et libxml2). Et comme je commence à obtenir quelque chose d’un peu près fonctionnel, non pas sans (nombreux) bugs ! Je me lance à présenter ce petit projet sans grande prétention à qui veut y jeter un œil, le tout sous une licence on ne peut plus classique, la GPLv3. Pour son nom, Twitturse, ben… heu… j’avoue que je ne l’ai pas trouvé dans un moment de créativité débordante.

Twitturse n’utilise que peu de dépendance, et des classiques qui sont certainement déjà installer sur votre PC,

• ncurses : installer par défaut sur quasiment tout les système UNIX.
• curl & libxml2: disponible tout les deux dans [extra] sur Arch Linux, mais sûrement déjà installer sur votre système tellement elles sont courantes.

Les fonctionnalités

Elles sont relativement réduite, mais pour moi qui ne suit pas un gros utilisateur de Twitter, ça me suffit pour un usage quotidien, oui oui, je l’utilise. En gros vous obtenez une liste de tweets navigable. Vous pouvez soit obtenir plus de détail sur le tweet sélectionné, pour le moment pas vraiment plus de détail que ça, mais par la suite j’en mettrais plus (avec espace ou entrer), soit le retweeter (avec la touche ‘r’). Et bien sûr vous pouvez envoyer un tweet.
Voilà en gros les trois fonctions : envoyer un tweet, retweeter, voir les détails d’un tweet.
Alors bien sûr, ça ne va pas loin, pas de système de recherches poussé, même pas le moyen de suivre une personne, si le courage m’en prends et qu’il n’y ait pas trop de bugs dans ce qui est déjà en place, je pourrais par la suite implémenté plus de fonctions.
Mais dans l’immédiat, twitturse me permet de suivre tranquillement mes tweets quand même.

Voici les traditionnels screenshots pour donner une idée de ce qu’est Twitturse :

Screenshot de Twitturse

Installation et Usage

Je n’ai pas mis de paquet disponible sur AUR pour les Archers, car, bien que ce ne soit pas difficile je n’ai pas voulu encombrer AUR avec une version qui reste encore expérimental. Par la suite, si jamais j’obtiens quelque chose de pas trop buggé pourquoi pas le mettre sur AUR effectivement pour une installation encore plus facile. Cependant, l’installation n’est pas des plus compliqué, il suffit de suivre cette démarche : (et libre à vous de l’installer avec un PKGBUILD de votre convenance)
wget http://src.nicosphere.net/twitturse/twitturse-0.1.0-beta.tar.bz2
tar xvf twitturse-0.1.0-beta.tar.bz2
cd twitturse
./configure --prefix=/usr
make
sudo make install

Pour fonctionner veuillez mettre dans la racine de votre home .twitturserc contenant les indications suivante:
login "pseudotwitter"
passwd "mot_de_pass_twitter"
Ce devrait être suffisant pour fonctionner.

À partir de là :

• Enter ou Espace : voir le tweet courant.
• t : permet d’écrire un tweet (echape pour annuler).
• r : retweet le tweet courant.

Pour les désagréments et bugs connu, parfois l’affichage au lancement ne se fait pas correctement (pas souvent cela dit, et juste le fait de relancer peut arranger cela), l’application par en segfault si la connexion internet est coupé (pas encore de gestion de timeout avec curl), et un soucis d’affichage pendant une petite seconde lors de l’envoi d’un (re)tweet. Je vais essayé d’arranger tout cela si possible dans une version futur.

Un dernier petit mot pour ceux suivant ce blog, et qui n’auront pas manqué de remarqué un ralentissement dans le rythme de parution de billet, et il est vrai que ces derniers temps, j’ai écris plus de lignes de C que des lignes sur mon blog, non pas que l’envie sois partie, mais le temps consacré à la programmation est juste plus importante. Je vais quand même essayer de refaire des parutions plus fréquente prochainement.

Bon tweets à tous.

L’avantage, c’est de ne pas avoir besoin de parcourir la file pour toutes actions dessus, et également utile lorsqu’une application peut demander indépendamment de filer ou défiler.

EDIT Après en avoir discuté, le code ci dessous n’est pas totalement fonctionnel dans l’état, et c’est vrai qu’il ne libère pas la mémoire comme il devrai, je vais revoir ça au plus vite :þ
REÉDIT Voilà, c’est corrigé, normalement ça devrais être bon cette fois ci. (merci à Tuxce pour son aide)

Comme je voulais m’exercer sur les files, et normalement on reverra cette file dans un prochain billet avec toujours une application. Il est bon d’avoir les deux pointeur, et d’écrire l’algorithme pour que la file soit opérationnelle pour enfiler/défiler, sans la parcourir à chaque fois. Comme d’habitude, j’ai essayé de commenter le code pour qu’il soit suffisamment clair à parcourir.

Ce que fait cette application :
Elle enfile les éléments à partir d’un fichier « file.txt » (au même endroit que l’exécutable) pour pouvoir la défiler après, en défilant le contenu sur le terminal. Dans cette application, le file/défile se fait de façon séquentiel, c’est à dire l’un après l’autre, mais pourrait être réutiliser pour une application non-séquentiel. (si je ne me suis pas trompé :þ, mais comme je vais l’utiliser plus tard, je confirmerai par la suite).
Il est certain que cela pourrait être amélioré.

Voilà, (que de blabla…) place au code !

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct node_t
{
    char *buffer;
    struct node_t *next;
} node_t;
 
typedef struct file_t
{
    node_t *first;
    node_t *last;
    int count;
} file_t;
 
file_t* initFile (file_t *file);
node_t* initNode (node_t *node);
int enfileNode (node_t *node, file_t *file);
node_t* defileNode (file_t *file);
void freeNode (node_t *node);
void freeFile (file_t *file);
 
int main (void)
{
    /* On déclare et initialise l'indispensable pour créer une file
     */
    file_t *file = NULL;
    file = initFile(file);
    /* On déclare et initialise l'indispensable pour ouvrir le fichier.
     */
    FILE *fichier = NULL;
    fichier = fopen ("file.txt", "r");
    char buffer[BUFSIZ];
 
    if (fichier != NULL) {
        while (fgets (buffer, BUFSIZ, fichier) != NULL) {
            /* Création d'une node */
            node_t *node = NULL;
            node = initNode(node);
 
            if ( (node->buffer = strndup (buffer, BUFSIZ)) == NULL) {
                fprintf(stderr, "Erreur avec strndup\n");
            }
 
            if (enfileNode (node, file) != 0)
                return EXIT_FAILURE;
 
        }
        fclose(fichier);
    } else {
        fprintf (stderr, "Ouverture de fichier impossible\n");
        return EXIT_FAILURE;
    }
    while (file->count != 0) {
        file->first = defileNode (file);
    }
 
    freeFile (file);
 
 
    return EXIT_SUCCESS;
}
/* Fonction permettant d'initialiser les différents éléments
 * des pointeurs qui servent à repérer la position du début et fin
 * de la file, plus un compteur du nombres d'éléments présent.
 */
file_t* initFile (file_t *file)
{
    file = malloc (sizeof (file_t));
    file->first = NULL;
    file->last = NULL;
    file->count = 0;
    return file;
}
/* De même avec un node de la file, on l'initialise.
 */
node_t* initNode (node_t *node)
{
    node = malloc (sizeof (node_t));
    node->buffer = NULL;
    node->next = NULL;
    return node;
}
/* Fonction enfilant la node, si la liste est vide, la node correspond 
 * au début et à la fin de la liste.
 */
int enfileNode (node_t *node, file_t *file)
{
    if (file->count == 0) {
        file->first = node;
        file->last = node;
    } else {
        file->last->next = node;
        file->last = node;
    }
    file->count++;
    return 0;
}
/* Et on défile la liste en écrivant dans le terminal le résultat.
 * si la liste devient vide (dernier élément défilé) on réinitialise
 * la file.
 */
node_t* defileNode (file_t *file)
{
 
        node_t *buffnext = file->first->next;
 
        /* la donnée de la node n'est que redirigé sur une sortie standard,
         * mais on pourrait facilement la rediriger vers un fichier ou toute
         * autre sortie (sock par exemple)
         */
        printf("%s", file->first->buffer);
 
        freeNode(file->first);
        file->first = buffnext;
        file->count--;
        if (file->count == 0) {
            file->first = NULL;
            file->last = NULL;
        }
 
    return file->first;
}
/* Utilitaire pour libérer la node et la file en fin d'usage.
 */
void freeNode(node_t *buffer)
{
  free(buffer->buffer);
  free(buffer);
}
 
void freeFile(file_t *file)
{
    free(file->first);
    free(file->last);
    free(file);
}

En soit le bot ne fait rien de spécial, c’est uniquement l’implémentation des fonctionnalités de bases, mais l’ajout de quelques fonctionnalité serait facile à partir de ce code.

J’espère avoir commenté suffisamment et pas codé trop comme un cochon pour rendre la compréhension du code facile. Bien que mes billets sur la programmation n’attirent jamais de commentaires, je suis preneur de tout suggestions d’amélioration sur le fond comme sur la forme, c’est aussi par la critique qu’on apprend. Le code est sous GPL, en gros, faites en ce que vous voulez du moment que l’auteur de départ est gardé. Le bot ne fonctionnera que dans un environnement Linux (PC ou serveur) mais l’adaptation pour un environnement Windows n’est pas compliqué à faire.

ÉDIT: depuis la publication de ce code, il a encore changé dans le fonctionnement général (voir mon commentaire tout en bas de page pour plus de détail.

Trêve de bavardage, passons aux choses sérieuses !

bot.conf

Tout d’abord, le fichier de configuration devant être nommé « bot.conf » et se trouvant au même endroit que l’exécutable pour qu’il fonctionne correctement, en soit, rien de très original dans se fichier et je ne pense pas qu’il y ait besoin de plus de commentaires :þ

1
2
3
4
5
6
7
8
9
10
11
12
13
14

############################################
#   Fichier de configuration pour CBot
#       Nic0 (25/04/10)
############################################
 
host "irc.freenode.net"
port "6667"
# Ne pas utiliser de caractère spéciaux autre
# que ceux autoriser sur l'irc.
nick "CBot"
ident "CBot"
realname "Nic0's Bot"
# les salons doivent être séparer par des virgules
salon "#archlinux,#archlinux-fr"

main.c

Bien que le code aurait pu être splitté en plusieurs fichier facilement, pour une meilleurs disposition ici, j’ai garder tout dans un seul fichier, là non plus, normalement pas besoin d’autre commentaire que ceux qui sont dans le code. Bonne lecture à ceux s’y lançant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325

/***********************************************************
*
*       CBot v0.2       (26/04/10)
*
*   by Nic0 <nicolas.caen at gmail.com>
*   Si vous redistribuez ce code, merci de ne pas effacer
*   ces données, et de rajouter les vôtres. (GPL)
*
************************************************************/
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
 
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
 
#define MAXBUFF 512
#define NBR_ELEMENT 6
 
#define ERROR fprintf (stderr, \
        "%s:%d Error (%d) : %s\n", \
        __FILE__, __LINE__, \
        errno, strerror(errno))
 
struct Configuration
{
    char *host;
    int port;
    char *nick;
    char *ident;
    char *realname;
    char *user;
    char *salon;
};
 
int initSocket (int *sock, struct sockaddr_in *sockname, 
                struct hostent *host_address, struct Configuration *config);
int initSocketConnect (int *sock, struct Configuration *config);
int socketAction (int *sock, char *buffer);
int pong (int *sock, char *buffer);
int getConfiguration (struct Configuration *config);
int extractConfig (char *element);
char *concatString (char *str1, char *str2);
void freeStruct (struct Configuration *config);
 
int main (void)
{   
    struct sockaddr_in sockname;
    struct hostent *host_address;
    struct Configuration config;
    int sock = 0;
 
    if ((getConfiguration (&config)) == 1)
        return EXIT_FAILURE;
 
    if ((initSocket (&sock, &sockname, host_address, &config)) == 1)
        return EXIT_FAILURE;
 
    if (initSocketConnect (&sock, &config) == 1) {
        close (sock);
        return EXIT_FAILURE;
    }
 
    freeStruct (&config);
 
    while(1) {
        char buffer [2048] = {0};
        if ((recv(sock, buffer, sizeof(buffer) - 1, 0)) == -1) {
            ERROR;
            close (sock);
            return EXIT_FAILURE;
        }
        printf("%s", buffer);
 
        if ((socketAction (&sock, buffer)) == 1)
            ERROR;
    }
 
    return EXIT_SUCCESS;
}
 
/*  Fonction permettant de créer la socket et de la connecter au serveur IRC.
 */
int initSocket (int *sock, struct sockaddr_in *sockname, 
                struct hostent  *host_address, struct Configuration *config)
{
/*  Obtention de l'adresse de la machine distante à partir de l'host.
 */
    if ((host_address = gethostbyname (config->host)) == NULL) {
        ERROR;
        return 1;
    }
 
/*  Création d'une socket.
 */
    if ((*sock = socket (PF_INET, SOCK_STREAM, 0)) == -1) {
        ERROR;
        return 1;
    }
 
/*  Connexion de la socket au server distant
 */
    sockname->sin_family = host_address ->h_addrtype;
    sockname->sin_port = htons (config->port);
    memcpy ((char *) &(sockname->sin_addr.s_addr), host_address->h_addr, host_address->h_length);
 
    if ((connect (*sock, (struct sockaddr *) sockname, sizeof (struct sockaddr_in))) == -1) {
        ERROR;
        return 1;
    }
    return 0;
}
 
/*  Fonction permettant d'envoyer les paramètres de bases pour rejoindre un salon, avec
 *  le choix du pseudo et identifiant
 */
int initSocketConnect (int *sock, struct Configuration *config)
{
    if ((send(*sock, config->nick, strlen(config->nick), 0)) != -1)
        if ((send(*sock, config->user, strlen(config->user), 0)) != -1)
            if ((send(*sock, config->salon, strlen(config->salon), 0)) != -1)
                return 0;
    ERROR;
    return 1;
}
 
/*  Fonction envoyant la réponse au ping
 */
int pong (int *sock, char *buffer)
{
    buffer[1] = 'O';
    if ((send(*sock, buffer, strlen(buffer), 0)) == -1) {
        ERROR;
        return 1;
    }
    return 0;
}
 
/*  Fonction traitant le buffer pour savoir quel action on doit lui associer.
 *  Ici, seul la réponse au Ping est traité et le cas de fermeture de la socket
 *  par le serveur distant.
 *  Pour rajouter des fonctionnalité au bot, 
 *  c'est ici qu'il est le plus simple de le faire.
 */
int socketAction (int *sock, char *buffer)
{
    if (strncmp(buffer, "PING :", 6) == 0) {
        if ((pong(sock, buffer)) ==1) {
            close(*sock);
            return 1;
        }
    }
 
    if (strncmp(buffer, "ERROR :Closing Link:", 20) == 0) {
        close (*sock);
        return 1;
    }
	return 0;
}
/*  Fonction permettant de récupérer les données lu dans le fichier de configuration
 *  Chaque éléments reconnu est stocké dans la structure Configuration, 
 *  Il lui est rajouté dans cette fonction le nécessaire pour être envoyer directement
 *  dans la socket (une fois sortie de cette fonction, tout est prêt à l'emploi.
 *  Si un # est rencontré en 1er caractère, on considère que c'est un commentaire
 *  et est alors exclu.
 */
int getConfiguration (struct Configuration *config)
{
    FILE *fichier;
    char filebuff[MAXBUFF] = {0};
    int nbrElement = 0;
 
    fichier = fopen ("bot.conf", "r");
    if (fichier != NULL) {
        while ((fgets (filebuff, MAXBUFF, fichier)) != NULL) {
 
            if (filebuff[0] == '#')
                continue;
 
            if ((strncmp (filebuff, "host", 4)) == 0) {    
                if ((config->host = (strdup(strchr (filebuff, '"')))) != NULL)
                    if (extractConfig(config->host) == 0) {
                        nbrElement++;
                        continue;
                    }
                ERROR;
                return 1;
            }
 
            if ((strncmp (filebuff, "port", 4)) == 0) {
                config->port = 0;
                char *tmp = NULL;
                if ((tmp = strdup (strchr (filebuff, '"'))) != NULL)
                    if (extractConfig(tmp) == 0)
                        if ((config->port = atoi(tmp)) != 0) {
                            nbrElement++;
                            free(tmp);
                            continue;
                        }
                ERROR;
                return 1;
            }
 
            if ((strncmp (filebuff, "nick", 4)) == 0) {
                char *tmp = NULL;
                config->nick = strdup ("NICK ");
                if ((tmp = strdup (strchr (filebuff, '"'))) != NULL)
                    if (extractConfig (tmp) == 0)
                        if ((concatString (config->nick, tmp)) != NULL)
                            if ((concatString (config->nick, "\r\n")) != NULL) {
                                nbrElement++;
                                free(tmp);
                                continue;
                            }
                ERROR;
                return 1;
            }
 
            if ((strncmp (filebuff, "ident", 5)) == 0) {
                if ((config->ident = (strdup(strchr (filebuff, '"')))) != NULL)
                    if (extractConfig(config->ident) == 0) {
                        nbrElement++;
                        continue;
                    }
                ERROR;
                return 1;
            }
 
            if ((strncmp (filebuff, "realname", 8)) == 0) {
                if ((config->realname = (strdup(strchr (filebuff, '"')))) != NULL)
                    if (extractConfig(config->realname) == 0) {
                        nbrElement++;
                        continue;
                    }
                ERROR;
                return 1;
            }
 
            if ((strncmp (filebuff, "salon", 5)) == 0) {
                char *tmp = NULL;
                config->salon = strdup ("JOIN ");
                if ((tmp = strdup (strchr (filebuff, '"'))) != NULL)
                    if (extractConfig (tmp) == 0)
                        if ((concatString (config->salon, tmp)) != NULL)
                            if ((concatString (config->salon, "\r\n")) != NULL) {
                                nbrElement++;
                                free(tmp);
                                continue;
                            }
                ERROR;
                return 1;
            }
        }
        fclose (fichier);
    }
    else {
        ERROR;
        return 1;
    }
    if (nbrElement == NBR_ELEMENT) {
        if ((config->user = strdup("USER ")) != NULL)
            if ((concatString (config->user, config->ident)) != NULL)
                if ((concatString (config->user, " \"localhost\" \"irc_server\" :")) != NULL)
                    if ((concatString (config->user, config->realname)) != NULL)
                        if ((concatString (config->user, "\r\n")) != NULL)
                            return 0;
        ERROR;
        return 1;
    }
    else {
        fprintf (stderr, "The configuration file doesn't seem to contain enought or to much data\n");
        return 1;
    }
    return 0;
}
/*  Utilitaire: lorsque l'élément en question est lu dans le fichier de configuration
 *  il apparait sous la forme "element", cette fonction enlève donc les "" pour ne laisser
 *  que l'élément.
 */
int extractConfig (char *element)
{
    int i = 0;
    do {
        element[i] = element[i+1];
        i++;
    }while (element[i+1] != '"' && i <= 1000);
 
    if (i >= 1000) {
        fprintf(stderr, "An error has occured in the configuration file, a double-quote is missing\n");
        return 1;
    }
    element[i] = '\0';
    return 0;
}
/*  Utilitaire permettant de concaténer deux chaine de façon dynamique
 */
char *concatString (char *str1, char *str2)
{
    char *result;
    int len1, len2;
    len1 = strlen(str1);
    len2 = strlen(str2);
 
    if(NULL == (result = realloc (str1, (len1 + len2 +1) * sizeof *result)))
        return (NULL);
 
    memcpy (result + len1, str2, len2 + 1);
    return result;
}
/*  Une fois les informations envoyé, on libère la structure.
 */
void freeStruct (struct Configuration *config)
{
    free(config->host);
    free(config->nick);
    free(config->ident);
    free(config->realname);
    free(config->user);
    free(config->salon);
}

L’avantage de ce code, c’est de ne pas avoir grand chose dans la fonction main, l’initiation, la connexion et les réponses au ping se font dans des fonctions à part, permettant une meilleur maniabilité du code que si tout était dans la fonction main.

La prochaine étape sera de le rendre encore un peu plus malléable, en lisant les paramètres de connexion dans un fichier de configuration plutôt que directement dans le code source.

À partir de là, il est facile d’implémenter des fonctionnalités au bot, pour qu’il réponde à diverse commande.

Le code n’est prévu que pour Linux et ne fonctionnera pas sur Windows, mais le principe restant le même, il peut servir d’exemple. (fonctionnant sur les serveur sous Linux)

Pour le faire fonctionner, recopier le texte dans un fichier « main.c » et bien sûr un :

gcc main.c -o bot

EDIT: La prochaine version (avec fichier de configuration) qui reprend une partie de ce code sera amélioré dans son ensemble. (disponible sur ce billet)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

/***************************************
*       IRCBOT
*           Nic0 (24/04/10)
****************************************/
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
 
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
 
#define PORT 6667
#define HOST "irc.freenode.net"
 
#define ERROR fprintf (stderr, \
        "%s:%d Error (%d) : %s\n", \
        __FILE__, __LINE__, \
        errno, strerror(errno))
 
int initSocket (int *sock, struct sockaddr_in *sockname, struct hostent *host_address);
int initSocketConnect (int *sock);
int socketAction (int *sock, char *buffer);
int pong (int *sock, char *buffer);
 
int main (void)
{   
    struct sockaddr_in sockname;
    struct hostent *host_address;
    int sock = 0;
 
    if ((initSocket (&sock, &sockname, host_address)) == 1)
        return EXIT_FAILURE;
 
    if (initSocketConnect (&sock) == 1)
    {
        close (sock);
        return EXIT_FAILURE;
    }
 
    while(1)
    {
        char buffer [2048] = {0};
        if ((recv(sock, buffer, sizeof(buffer) - 1, 0)) == -1)
        {
            ERROR;
            close (sock);
            return EXIT_FAILURE;
        }
        printf("%s", buffer);
 
        if ((socketAction (&sock, buffer)) == 1)
            ERROR;
    }
 
 
    return EXIT_SUCCESS;
}
/*  Fonction permettant de créer la socket et de la connecter au serveur IRC.
 */
int initSocket (int *sock, struct sockaddr_in *sockname, struct hostent *host_address)
{
/*  Obtention de l'adresse de la machine distante à partir de l'host.
 */
    if ((host_address = gethostbyname (HOST)) == NULL)
    {
        ERROR;
        return 1;
    }
 
/*  Création d'une socket.
 */
    if ((*sock = socket (PF_INET, SOCK_STREAM, 0)) == -1)
    {
        ERROR;
        return 1;
    }
 
/*  Connexion de la socket au server distant
 */
    sockname->sin_family = host_address ->h_addrtype;
    sockname->sin_port = htons (PORT);
    memcpy ((char *) &(sockname->sin_addr.s_addr), host_address->h_addr, host_address->h_length);
 
    if ((connect (*sock, (struct sockaddr *) sockname, sizeof (struct sockaddr_in))) == -1)
    {
        ERROR;
        return 1;
    }
    return 0;
}
 
/*  Fonction permettant d'envoyer les paramètres de bases pour rejoindre un salon, avec
 *  le choix du pseudo et identifiant
 */
int initSocketConnect (int *sock)
{
 
    char *nick = "NICK ircbot\r\n";
    char *user = "USER Haz \"localhost\" \"irc_server\" :Nic0 s Bot\r\n";
    char *join = "JOIN #ubuntu,#archlinux,#linux\r\n"; 
 
    if ((send(*sock, nick, strlen(nick), 0)) == -1)
    {
        ERROR;
        return 1;
    }
 
    if ((send(*sock, user, strlen(user), 0)) == -1)
    {
        ERROR;
        return 1;
    }
 
    if ((send(*sock, join, strlen(join), 0)) == -1)
    {
        ERROR;
        return 1;
    }
    return 0;
}
/*  Fonction envoyant la réponse au ping
 */
int pong (int *sock, char *buffer)
{
    buffer[1] = 'O';
    if ((send(*sock, buffer, strlen(buffer), 0)) == -1)
    {
        ERROR;
        return 1;
    }
    return 0;
}
/*  Fonction traitant le buffer pour savoir quel action on doit lui associer.
 *  Ici, seul la réponse au Ping est traiter, et le cas de fermeture de la socket
 *  par le serveur distant.
 *  Pour rajouter des fonctionnalité au bot, 
 *  c'est ici qu'il est le plus simple de le faire.
 */
int socketAction (int *sock, char *buffer)
{
    if (strstr(buffer, "PING :") != NULL && buffer[0] == 'P')
    {
        if ((pong(sock, buffer)) ==1)
        {
            close(*sock);
            return 1;
        }
    }
 
    if (strstr(buffer, "ERROR :Closing Link:") != NULL && buffer[0] == 'E')
    {
        close (*sock);
        return 1;
    }
	return 0;
}

• Les jeux vidéo ;
• Les drivers / support matériels.

Pour les drivers, on le sait, et on y fait attention, comme pour le choix d’une imprimante. Alors que pour windows un « CD d’installation » est fournis en général avec le matériel. Pour Linux, il faut trouver le bon driver, pour la plupart des cas cela ne pose pas de problème, mais si le périphérique est un peu trop exotique, il y a un risque de ne pas trouver de pilote pour le faire tourner.

Pour les jeux, c’est bien connu aussi que Linux ne supporte pas tout les jeux, que pour les faire tournés faut soit wine soit playonlinux. Beaucoup de jeux sont quand même supporté, suffit de voir la liste fournis par les deux applications, mais d’une part, passer par de l’émulation (plus ou moins) n’est pas forcément une bonne chose niveau performance, de l’autre part, tout les jeux ne sont pas supporté, même si les plus courant le sont, je ne suis pas forcément amateur de ce que la majorité des personnes veuille jouer. Il existe bien sûr des jeux prévu nativement pour Linux, et sans vouloir dénigrer l’excellent travail fournis par les développeurs, ces jeux ne sont pas à la hauteur de certains jeux commerciaux, et ne possèdent pas non plus les moyens financier des grosses industries du jeux vidéos, et même si le répertoire de jeux natif sous Linux grandis, le choix reste encore limité aux plus classique.

Il peut y avoir d’autres raisons je suppose poussant à l’utilisation de Windows, comme certain logiciels professionnels ne tournant qu’avec Windows, même si bien souvent c’est une fausse raison car l’alternative sérieuse existe, mais c’est plus que tel ou tel logiciel est imposé par l’entreprise.

Pour en revenir à mon cas, c’est pour les jeux que j’ai décidé de remettre Windows, bien que je ne sois pas un gros joueur, pouvoir m’assurer de pouvoir faire fonctionner un jeu out-of-the-box, ne pas choisir un jeu en fonction de sa compatibilité avec Linux, mais juste prendre un jeu qui me fait plaisir, c’est quand même important. Bien sûr je comprends les valeurs des Logiciels Libres et tout ça, mais je ne suis pas au point de boycotter toute technologie propriétaire si elle présente un large intérêt par rapport aux alternatives libres. Même si retrouver Windows fait drôle au début, j’espère même en avoir un nouveau regard dessus avec toute ses choses que j’ai appris grâce à Linux.

Techniquement, l’installation s’est passé plutôt simplement et sans aucune perte de données, j’ai retrouvé mon CD de Vista, avec sa licence. Un truc curieux à l’installation quand même, j’ai deux disques durs, le but étant de mettre Windows sur le deuxième, et sur une partition à part. Lors de l’installation, il m’a reconnu correctement les deux disques dures et les partitions, mais lorsque j’ai choisi la partition (formaté en ntfs) un « Windows ne trouve aucun volume système conforme aux critères d’installation » le plus curieux c’est qu’il m’a suffit de débrancher le 1èr DD, pour ne mettre que celui prévu pour Windows, et ça fonctionné… C’est là certain mystère de Windows, dès l’installation, après avoir rebrancher tout ça, réarranger mon Grub, et quelques drivers réinstaller, c’est une installation qui s’est fait sans difficulté vraiment.

Me voilà donc avec un nouvel OS sur mon PC, Arch Linux restant mon OS principal et de tout les jours. Peut être que la prochaine fois, se sera au tour d’un *BSD d’avoir une petite place sur mon disque dur pour changer des machines virtuels. Les avis sur la question peuvent différer mais n’est-ce-pas limiter l’utilisation et la capacité de mon ordinateur que de ne pas pouvoir avoir accès à tout les jeux existant ?

Remercions catwell, gyo et Nic0 pour la traduction et la relecture. Mais pour être honnête je n’ai pas participé autant que d’habitude.

Pour prendre votre copie de l’Arch Linux Magazine, c’est par là, en français ou en anglais.

Le mois dernier nous avions une version un peu réduite de l’ALM, ce qui était surtout un appel à la communauté pour la contribution. Je dois dire que son appel à plutôt bien fonctionné, pas mal de contributeurs se sont montré sur freenode (#archlinux-magazine) pour apporter différentes contributions. C’est donc un retour à une publication « normal » cette fois ci.

Le numéro d’avril étant sortie pour le 1er avril, le magazine était disponible avec une particularité, celle d’être complètement à l’envers, rendant la lecture difficile, mais avec quelques lignes de commandes, ou des astuces, il est possible de remettre le PDF dans le bonne ordre. Dès le lendemain, la version normal fut mis à disposition.

Sans plus attendre, un aperçu du sommaire :

• Editorial
• Côté Dev.
• Un point sur le Schwag
• Contribution de la communauté
• ArchCon 2010
• Critique du Asus UL30A CULV
• Photos de bureau

Bonne lecture à tous.

Pour ceux souhaitant avoir un aperçu des nouveauté de Xorg 1.8.0, vous pouvez lire ce billet, X.Org Server 1.8 Release Candidate 2 qui est toujours d’actualité.

L’annonce est faite par Jan de Groot, un développeur d’Arch Linux, sur la mailing liste [arch-dev-public].

« Il y a un nouveau dépôt pour les paquets de xorg-server 1.8. Comme cette sortie demande de nouveaux drivers et de nouvelles configurations, j’ai décidé de les mettre dans leur propre dépôt pour ne pas casser testing pour la plupart des utilisateurs. Les paquets ont été compilés avec testing, mais comme cette nouvelle version ne dépend plus d’OpenSSL, cela devrait fonctionner avec core+extra. Le kernel 2.6.33 de testing est recommandé à cause de DRI dans cette version. »
– Jan de Groot

(source, mailing list)

Pour ceux voulant se lancer dans l’utilisation, quelques recommandation quand même, savoir ce que vous faites, suivre la mailing liste pendant cette période de transition, et si votre xorg-server est tout cassé, ben… ne pas venir pleurer (trop fort) sur le forum :þ. Mais bon après tout, c’est un peu l’esprit d’Arch Linux, de se lancer dans ce genre d’aventures.

C’est donc à vos risques et périls que vous pouvez activer le dépôt de la façon suivante, dans le pacman.conf, à mettre au dessus des dépôts de testing et community-testing :

[xorg18]
Include =/etc/pacman.d/mirrorlist

Comme expliqué dans le billet précédant, c’est avec son lot de changement qu’apporte xorg 1.8, tel que la suppression complète d’HAL, et l’apparition d’un répertoire de configuration /etc/X11/xorg.conf.d/
Attention tout de fois, pour le moment, il n’y a pas encore de driver nvidia de disponible.
EDIT : Il s’agit ici du driver proprio nvidia ici, toute fois, ceux étant avec le driver nouveau pour nvidia ne devrait pas poser de soucis. (plus de détail sur la ML)

Jan de Groot conseil la lecture de cette documentation pour les changements de configuration.

Je ne conseil donc cette expérimentation qu’aux archers avertis, mais pour ceux souhaitant faire le pas, amusez vous bien et bon courage :þ

Comme sûrement beaucoup de personnes, je me suis cherché un client pour ne pas passer par leur site, et avoir ça sous la main avec une application stable et fonctionnel, bien incorporé dans mon bureau.

Je me suis d’abord tourné vers Pino, qui en soi est très satisfaisant. Mais comme pour la plupart de mes applications, je me suis mis à chercher un client, soit ncurses ou au moins en console.

Je n’ai pas trouvé d’applications en ncurses proprement dite, alors ça ne veux pas dire qu’il n’en existe pas, peut être que j’ai mal chercher, et si quelqu’un en a une sous la main je suis preneur, ou si quelqu’un se sent le courage d’en coder une :þ. À défaut, c’est sur le client TTYtter que je me suis penché, un client en mode console uniquement, écrit en perl et en 4’000 lignes de code plutôt bien commenté.

Exemple de screenshot de ttytter (repris sur le net)

L’avantage de ce client, c’est qu’il est suffisamment complet pour en avoir un usage régulier, offrant bien plus que la simple possibilité d’envoyer un « tweet ».
Des fonctions de recherches avancées sont en effet disponible, et un peu près tout ce qu’un client tel que pino pourrait proposer en GUI. Il est possible de suivre, rechercher une personnes, voir ses tweets, ses statistiques, rechercher sur des tags, possibilité de raccourcir les URI, support des notifications, support SSL, et plus encore. Les commandes sont également instinctive.

Pour les commandes de bases :

• /refresh : pour forcé la mise à jour des tweets (automatique normalement).
• /again : remontre les tweets.
• /again pseudo : montre les derniers tweets d’une personne spécifique.
• /whois pseudo : montre des stats sur la personne.
• /ruler : permet d’afficher une petite règle pour savoir si on ne dépasse pas les 140 caractères.
• /follow et /leave (+pseudo): pour suivre et son contraire.
• /rt : retweet.
• /help : affiche l’écran d’aide.
• Bien d’autres encore…

par exemple, un /whois nic0sphere retourne (en plus de l’avatar en asciiArt, voir plus loin)

Nic0 (nic0sphere) (f:18/13) (u:35)
"Passionné d'informatique et de GNU/Linux, bloggeur sur le Libre."
URL:            http://www.nicosphere.net
Location:       Normandie
Picture:        http://a3.twimg.com/profile_images/772151641/avatar_normal.jpg

Au niveau de la configuration, cela se passe dans un classique fichier .ttytterrc. En suivant le site officiel, et quelques fichier trouver par ci par là, j’en suis pour le moment à ça:

vim ~/.ttytterrc

user=nic0sphere:***pass***
pause=auto
vcheck=1
ansi=1
hold=15
newline=1
slowpost=7
readline=1
wrap=1
avatar=lynx -source %U | djpeg -pnm | ppmascii -photo -x2 -winx=4

La dernière ligne nécessite l’installation d’un petit programme en perl. Placé dans /usr/bin/ppmascii avec les droits d’exécution approprié. Cela permettra lors de la commande /whois, d’obtenir l’avatar de la personne en asciiArt, qui je dois dire est plutôt amusant. Le rendu de l’avatar en asciiArt diffère d’un avatar à l’autre, le miens, n’étant pas très contrasté, n’est pas des plus révélateur de la capacité du programme. Je n’ai pas mis de notification, mais c’est un choix personnel, il est possible de le rajouter. (on peut placer le programme ailleurs, en modifiant la commande suivant « avatar »)

Pour le plaisir, j’ai fait un screenshot de mon avatar, avec le rendu réel en console, pour bien l’apprécier, le mieux c’est de prendre un peu de recule (comme dans tout les AsciiArt).

Screenshot de mon avatar en AsciiArt

Plutôt simple d’utilisation, mais suffisamment fonctionnel quand même, TTYtter ne prend pas de place et est léger, agréable donc à l’utilisation. Pour moi, c’est adopté. La seul chose qui me reste à trouver comment faire, c’est de mettre les différents pseudo dans une couleur spécifique, car pour le moment, ils n’apparaissent qu’en gras. (dès que je trouve je met ça là :þ)

Bon tweets à tous, et bon week-end pascal :)

EDIT: Pour aller plus loin dans la configuration et les explications je conseille la lecture du billet de Logive. Notamment pour une gestion en multi-session, et gestion de tags plus affiné. Une bonne lecture en tout cas pour approfondir le sujet.

À qui ce n’est pas arrivé d’ouvrir un fichier de configuration, chercher une ligne, réfléchir comment la modifier pour l’avoir correctement… et… au moment de modifier, s’apercevoir qu’on est qu’en simple user, et donc sans les droits d’écriture requis pour sauvegarder le fichier.

En tout cas, ce genre d’anecdote m’est déjà arrivé, et je ne dois pas être le seul.

Comme j’utilise très souvent mon éditeur de texte favori Vim, dont je ne connais pas toutes les astuces, loin de là, c’est en lisant cet article de tuxradar, que la solution toute simple est exposé.

Lorsque vous avez votre fichier ouvert, et même effectuer les changements, alors que vous ne pouvez normalement pas sauvegarder le fichier car n’avez pas les droits requis, et donc en accès read-only, il suffit de rentrer la commande suivante :

:w !sudo tee %

Pour les explications :

• :w – classique, c’est pour écrire le fichier.
• !sudo – appel de la commande sudo.
• tee – la sortie de la commande write (:w) est redirigé en utilisant la commande tee. % désignant l’actuel nom de fichier. En gros, la commande tee est utilisé en root pour prendre la sortie et l’écrire dans le fichier repésenté par %.

Cette manipulation résulte à un avertissement, disant que le fichier a été modifier, ainsi que le tampon dans Vim et propose de recharger le fichier : (C)harger le fichier ou (L)oad the file si c’est en anglais.

Voici une astuce efficace, car très simple à se souvenir, et pouvant être bien utile, évitant quelques « oups, oublier d’ouvrir le fichier en root ».

Et c’est dans la globalité de son fonctionnement que Yaourt a été revu. On peut dire qu’un gros travail a été fournit par Tuxce (le co-auteur de yaourt) en collaboration avec Wain (le fondateur de yaourt).

La différence notable pour l’utilisateur est avant tout la vitesse ! En effet, la vitesses des recherches est grandement améliorée, très agréable donc à l’utilisation de mon yaourt préféré.

Voici le changelog complet pour cette dernière version, consultable sur cette page :

version 0.9.3 (26/03/10) version à 99,9% de Tuxce

• VITESSE! yaourt utilise une application externe (package-query de tuxce) pour les requêtes sur alpm et aur
• Traduction Italienne de Vincezo et en Turc de Samed
• Propose de surpprimer un paquetage si il est en conflit avec….
• Meilleure détection des commandes à utiliser avec sudo
• Meilleur support du chemin du lockfile de la db pacman
• Correction d’erreur d’utilisation d’un shell différent en tant que root
• Correction de la détection de ‘provides’ dans les PKGBUILD
• Passage à rsync pour correction du téléchargement des sources des paquetages de community
• Pas besoin des privilèges root pour savoir quels paquetages sont à mettre à jour
• Nouvelle option diffeditor dans yaourtrc pour pacdiffviewer

Une bonne nouvelle pour notre yaourt national, et une bonne occasion pour remercier tuxce et wain pour le travail fournis. Pour ceux souhaitant réagir sur le développement de yaourt, un thread est disponible sur le forum d’ArchLinux.fr.

Et comme on dit par ici, yaourt c’est bon, mangez-en !

Dans son apogée c’était un magazine influant, distribué sur Internet, avec des sorties régulières, et de réputation à égale avec le magazine 2600 (papier cette fois).


D’une part Phrack diffusait des articles vraiment intéressant et technique, mais c’est aussi une vision de la scène international de hacker, en faisant partie intégrante de son histoire. Une approche de l’histoire de « l’underground » ne peut être faite sans cité Phrack, ainsi que Knight Lightning et Taran King, les fondateurs de Phrack.

Malheuresement, les contributions ont été moindre , et les sorties peu fréquente depuis la fin des années 90, avec en moyenne un numéro par an, le dernier numéro étant sortie en juin 2009. Tout les numéros sont disponible gratuitement, et ce depuis le tout premier, datant quand même de novembre 1985, et sont téléchargeable en tar.gz ( pas de .zip bien sûr :þ ).

Mais Phrack survit et le fait savoir !

Phrack lance un appel à la contribution, tout en confirmant un nouveau numéro, #67, pour cet été dont la date est fixé au 11 juillet 2010. Bien sûr ça laisse le temps de voir venir, mais c’est toujours bon de les savoir actif. Pour ceux suivant un peu (même de loin), un changement niveau de l’équipe notable est fait puisque The Circle of Lost Hackers se retire laissant de bels contributions dans les numéros 64, 65 et 66.

Pour anecdote, Gentoo dispose d’un paquetage « phrack » disponible avec portage, permettant de télécharger une partie ou l’intégralité des numéros de Phrack !

Bonne lecture à ceux qui se lance dans la lecture d’anciens numéros.

En effet, selon ce communiqué de presse, les téléchargements d’Opera ont plus que doubler en moyenne en Europe, et les chiffres sont éloquent.

Following the introduction of the Choice Screen in Europe, Opera Software is experiencing a dramatic uptake on downloads of its latest browser, Opera 10.50. After the Choice Screen launch in early March, on average, more than half of the European downloads of Opera’s latest browser come directly from the Choice Screen.

Opera met l’accent sur le fait que la moitié de leur chargement proviennent de cet écran laissant le choix entre les divers navigateurs.

Une fois n’est pas coutûme pour moi de faire un billet si court, mais l’information ne vaux pas non plus de grosses explications.

Bien sûr, pour nous français, ça fait un peu loin pour y aller, mais rien n’empêche de jeter un petit coup d’œil aux conférences déjà prévues, de plus, quelques demandes de rediffusion vidéo ont étaient faite pour que ceux ne pouvant s’y rendre puissent quand même suivre les conférences, en anglais of course.

Les conférences sont détaillées, en anglais, sur une partie du site canadien, normalement réservé au shwag (les goodies pour ceux qui ne connaissent pas).
Si vous voulez tout savoir de suite, c’est par ici le programme !
Un petit aperçu du programme (traduction partiel de la page cité ci-dessus) :

Arch Linux Projets

Présenté par Dan McGee

Il y a beaucoup de pièces de puzzle qui s’assemblent pour faire tenir debout une distribution et la rendre active. Bien que Arch Linux ait une des plus petite équipe de développement des distributions Linux « connu », nous avons pas mal de projet sous développement. Du site web à l’initscript, en passant par les outils de management des dépôts. Cette conférence va essayer de montrer quelques projets d’ArchLinux.

Vous pouvez également être intéressé par cette conférence si vous cherchez à contribuer à ArchLinux, mais si vous n’êtes pas sûr par où commencer. Venant d’un gars qui est devenu développeur grâce à son travail sur pacman, j’espère que cela va aussi montrer comment s’investir et gagner le respect des développeurs actuel, et éventuellement devenir un membre d’un projet.

Dan est un développeur d’ArchLinux depuis 3 ans, et est le dev principal de pacman, mais également des contributions diverses que se soit sur le site, ou le serveur.

Hacking Pacman

Présenté par Dan McGee

Une pièce critique de toutes distributions est les paquets et la façon dont elle les prend en charge. Alors que certains manageurs de paquets peuvent être frustrant, les archers trouvent que pacman va droit au but et fait vraiment ce que l’on en veut de lui. Cette conférence va regarder brièvement comment pacman fonctionne sur un haut niveau, puis descendre dans ses entrailles, pour voir ce qu’il fait et comment il le fait. Nous pouvons aussi voir les makepkg et autres scripts. Le plus important, je vais vous montrer comment le développement fonctionne si vous êtes intéressé pour vous y investir, ou voulez une fonctionnalité particulière qui n’existe pas encore.

Goggles Music Manager

Présenté par Sander Jansen

En 2010 et sur ArchLinux, il existe des tonnes de players, alors pourquoi devriez vous choisir Goggles Music Manager ? Pourquoi développer encore un autre player ? Et pourquoi les gens cherche encore le player « parfait » ? Je vous montrerai comme l’utiliser, comment organiser sa collection de musique avec. Je montrerai aussi quelques nouveautés et fonctionnalités intéressantes qui sont en développement. Nous regarderons aussi derrière la scène, et discuterons de mes motivations à l’avoir développer, du design et du choix des composants qu’il dépend.

Uzbl

Présenté par Dieter Plaetinck

Uzbl est très différent des autres navigateurs web (même des « légers »). Je décrirai l’idée du design et de l’implémentation d’Uzbl, j’expliquerai la philosophie derrière cela, ainsi que quelques exemples pratique de comment l’intégrer dans votre bureau.

AIF: Arch Installation Framework

Présenté par Dieter Plaetinck

Depuis aout 2009, AIF s’occupe d’installer le système d’ArchLinux sur votre ordinateur. Un installeur est quelque chose un peu délicat dans la façon dont il doit faire l’installation, et c’est sujet à des opinions divergentes. Dans cette conférence sera expliqué les choix du design, les détails de son implémentation, et plus important: un aperçu des fonctionnalités et comment les utiliser.

Puis un peu plus en profondeur sur comment l’interaction et l’automatisation de l’installation fonctionne. Puis, des sujets comme lvm, encryption, installation imprévu et customiser l’installeur selon vos besoins. En gros, tout ce que vous devriez savoir sur l’installation du système d’Arch, et les plans pour le futur.

Autres

• Discussion autour de KDE (par Troy Unrau)
• ArchLinux dans le milieu professionnel (par Jason Chu)
• Présentation d’un LiveCD d’ArchLinux (par Matt Wood)
• Autres…

Des conférences qui peuvent être intéressantes à suivre, et j’espère également qu’ils diffuseront les vidéos des diverses conférences. Un pas de plus vers la domination du monde d’ArchLinux ! :þ

Une occasion de regarder quelques nouveautés que les développeurs de Xorg nous réservent.

Les articles auxquels je fais référence sont écrit en anglais, mais de la bonne lecture pour aller plus loin dans les explications.

Le premier changement est dans leur fonctionnement de développement, puisque Xorg server 1.8 sera le premier a suivre un processus tout comme le noyau de Linux, chaque développeur s’occupe de leurs codes dans leur propre branche, et c’est par une demande de « pull » que le code est mergé dans la branche principal (master).(voir article) Ce qui leurs permettent d’avoir un meilleur contrôle sur le cycle développement entre autre, mais une meilleur gestion dans l’ensemble aussi. (voir LWN 2eme partie)

De la version 1.4 à 1.7 Xorg a utilisé HAL pour plusieurs raisons en input (uniquement input, pas d’output), comme trouver les périphériques lors du démarrage, ou encore lorsqu’un d’eux est branché à chaud. Comme le projet HAL n’est plus maintenu, Xorg le remplace par udev, comme ils l’expliquent sur cette page de wiki.

L’apparition d’un dossier /etc/X11/xorg.conf.d dans lequel sera stocké les fichiers de configuration relatifs aux périphériques sera un changement notable pour l’utilisateur, tout de fois, le comptabilité du bon vieux xorg.conf sera quand même maintenu si les nouveaux fichiers ne sont pas présent, comme le précise cet article. (et si le cœur vous en dit de voir le patch du changement de conf).

Une autre nouveauté de ce xorg est le support du protocole DRI 2.2, ce qui devrait permettre de supporter des extensions supplémentaire de OpenGL/GLX tel que SGI_video_sync, OML_swap_control et SGI_swap_interval, SGI_swap_control, SGIX_swap_barrier, etc…

Des changements qui semblent prometteur, et une version finale qui ne devrait plus trop tarder.