Ubuntu Algérie

ubugnu

Edition: Après presque un an depuis l'écriture de ce billet, j'ai voulu installer ce thème donc je suis revenu ici, je me suis alors rendu compte que j'avais oublié un truc (l'étape 4), voila, je m'en excuse auprès de mes lecteurs et lectrices.

Hi,

Today I'm gonna tell you how to transform your Ubuntu desktop to a v... Euuuh désolé j'ai continué sur ma lancée :-D

Bon, pour les amateurs des thèmes Dark comme moi voila le meilleur thème Dark que je n'ai jamais vu, ce genre de thème est habituellement très moche vue le contraste qu'il offre: du pure blanc sur du pure noir!!! Mais celui là croyez moi, il est vraiment différent, voila tout de suite un avant goût:

Comme vous pouvez déjà le voir, ce n'est pas de l'amateur...

Même vos applications revêtiront le costume Dark :-) Voila pour Lyx

Gimp ...

et le tableur ....

et le lanceur d'applications Alt+F2 ...

même Google se met au Dark ...

En fait, et bien que le cœur du sujet soit le thème en lui même, je vais vous proposer une multitude de solutions qui combinées, chez moi, ont donné l'aspect que je souhaitais à mon bureau, et je sais que mes attentes sont celles de nombreux Ubuntéros qui trouvent que le bureau Gnome est beaucoup trop sous-exploité question look...

Voici les étapes:

Si vous utilisez un thème pour FF3.x je vous conseille de d'abord revenir au thème original, vous pourrez à la fin revenir vers votre thème préféré.

Installer gtk2-engines-ubuntulooks

Le thème en question utilise les icônes d'un autre, ces icônes sont vraiment bien faits, mais malheureusement le thème qui va avec n'est pas à la hauteur, quoi qu'il en soit, ces icônes s'imbriquent de façon remarquable au thème que je vais vous présenter. Voici le lien vers le thème contenant les icônes (choisissez le premier par exemple), téléchargez le et installez le (faites un glisser-déposer dans la fenètre de "Apparences")

Téléchargez ici et installez le thème (faites un glisser-déposer dans la fenètre de "Apparences").

Je ne sais pas si vous êtes de mon avis mais le panel (tableau de bord) ne sert pas à grand chose, surtout si vous avez un petit écran comme moi, si vous avez remarqué sur ma première capture je l'ai totalement viré, j'ai trouvé un moyen pour ouvrir toutes les applications que je veux en une fraction de seconde (à prendre au sens figuré bien sure :-)), je vais en parler dans la suite, mais il subsistait trois problèmes: Où mettre la liste des fenêtres ouvertes et la zone de notification? Où mettre le menu?
La réponse est:
- Pour les fenêtres j'avais le choix d'tiliser un dock (comme AWM) que j'avais déjà, mais j'ai voulu quelque chose de plus discret, la solution je l'ai trouvé dans Screenlets cet outil offre de nombreux widgets qui ne marchent malheureusement pas toujours très bien (c'est pas non plus catastrophique rassurez vous) j'ai choisis d'utiliser la liste de fenêtres et de la configurer pour qu'elle apparaisse discrètement horizontalement à droite de l'écran (Opacity=0.6)
- Pour le menu (et du même coup pour la zone de notification) j'ai remarqué que quand le thème est installé la hauteur de la barre du Panel peut être réduite plus que d'habitude (les icônes étant devenus plus petits) j'ai décidé donc de la rétrécir (décochez étendre auto.) , d'y mettre le menu et la zone de notification, et de la mettre quelque part où elle ne gêne pas et où elle est toujours visible, je peux aussi la déplacer comme je le veux si elle me gêne.

Pour un lancement rapide et intuitif d'applications, de fichiers ou de répertoires un seul mot : Gnome-Do . Une fois mis en marche, il vous suffit d'utiliser la combinaison de touches Super+Espace (Super c'est celle avec un logo Windows dessus) et de taper ce que vous voulez (je vous laisse le découvrir tout seul car c'est très intuitif comme outil, vous verrez qu'il se familiarise avec vos habitudes au fur et à mesure que vous l'utilisez)

Un terminal en une seule pression de touche c'est possible, Guake-Terminal est fait pour ça, installez le, activez le (menu::accessoires::GuakeTerminal) puis appuyez sur F12 pour l'enclencher, je préfère le régler pour qu'il recouvre tout l'écran, mais vous faites ce que vous voulez :-)

Mon terminal je l'aime comme ceci:

Où j'ai viré la barre de menu, et rendu le background transparent.

J'espère que je n'ai rien oublié :-D (ah oui revenez à votre thème d'origine de Firefox, si par hasard le texte des boutons de menu est blanc, suivez ... 10 :-p)

Alors si le texte dans le menu de Firefox est illisible faites ceci:
- Tapez about:config dans la barre d'adresse.
- Clique droit::nouvelle chaîne de caractères
- Nommez la ui.menutext et donnez lui la valeur #000000

J'espère encore n'avoir rien oublié!!!

{Au cas où ...}

ubugnu

What is the point of hosting such files on Google and not on another server?

I think this question needs no response, the purpose is to take advantage of the very generous bandwidth of Google to display our html or our images, to load our scripts or css stylesheets.
After a long search for the miraculous solution, and after having tested everything: Google sites, Google docs, javascript and css encapsulations on images, ...etc I finally found the ultimate solution.

In fact the two solutions Google sites and Google docs are not permanent, since the links to the files change from time to time, such that we find ourselves forced to update the source code of our site each day! Also, the links used make redirections, which translates into a larger load times for our pages.

The solution of encapsulated script (hidden) in an image is also not very clean, in fact I noticed a big slowdown in the browser when evaluating a heavy script with eval() function.

The final solution is to use Google Code to store files and get a direct link (without redirection, permanent, and mainly mime-typed ). Here's how it can be done:

Create your Google Code project:

Go to http://code.google.com/hosting and click Create a new project, give a name, a summary and a description to the project, then choose Subversion in Version control system and anything in Source code license then click on Create project button, once the project is created, you will find yourself in the Project Management page, go to the Source tab and note the link of the project directory, it will look like this: https://ubugnu.googlecode.com/svn/trunk/ and will be next to svn checkout.
To be able to put files in that directory you will need a password (otherwise anyone can tinker with your project), to get the password click googlecode.com password just below the link, note also that password.
Connect to the project via svn and host files on Google by synchronizing the project directory with a local directory

We will need the subversion package, install it with:
```
ubugnu@ubugnu-laptop:~$ sudo apt-get install subversion
```
Once the package is installed, here is what we'll do: Create a local directory which will be an exact copy the project directory and which you can synchronize at any time, ie edit the files locally, then synchronize the files so that Google files are also modified. That's how you create a copy of the project directory:
```
ubugnu@ubugnu-laptop:~$ svn checkout "https://ubugnu.googlecode.com/svn/trunk/" ubugnu
```
This command will create a directory called ubugnu which is an exact copy of that which is on the server, and as it is empty, my local directory will also be so.
We will add a file (eg javascript) in our local directory then "spread" the change to the Google server, for example:
```
ubugnu@ubugnu-laptop:~$ cd ubugnu
ubugnu@ubugnu-laptop:~$ touche test.js
ubugnu@ubugnu-laptop:~$ cp /var/www/test.js ./test.js
ubugnu@ubugnu-laptop:~$ svn add ./test.js
```
We will need to link to svn a text editor, nano would be best suited:
```
ubugnu@ubugnu-laptop:~$ export SVN_EDITOR=nano
```
You can put your favorite editor instead of nano (eg gedit)
Now that our local directory ubugnu has been changed, one must propagate this change to the server with:
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.js --username ubugnu
```
I put my Google nickname (put yours, it is the one contained in your gmail email address)
A page will then appear in the text editor that you previously selected, save (Ctrl+o) and quit (Ctrl+x), then type the letter "c" (continue to) in the terminal and press enter.
The terminal will then ask you the password of the administrator (root), type it, then it will ask for the password to access the project directory on Google, type the one you noted earlier and submit. Bravo, the file has been placed on the Google server.
To check, click the Source then Browse and finally Trunck links, you'll see the file test.js, click it, then in the page that appears click on view raw file at the bottom right. The link you get is the one you can use in your source codes, it is quick and permanent.

Go back and notice that the MIME-type file is text/plain (below view raw file) that is plain text, which is not a problem for a javascript file but can affect interpretation of other extensions (css for example)
Changing the mime-type of files depending on their format:

So as I said, mime-type can be problematic when it comes to files for which the browser checks the mime-type, try for example a css file on the server and include it in a page you will see that it will have no effect (it will not be interpreted) because its mime-type is the default text/plain, so we must change it.

For our example, we will not use a css file but an html file, create an html file locally and put in a little html code:
```
ubugnu@ubugnu-laptop:~$ touch test.html
ubugnu@ubugnu-laptop:~$ nano test.html
```
And put
```
<html> 
<body> 
<h2>it works</h2> 
</body> 
</html> 
```
Now we propagate the change with commit
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.html --username ubugnu
```
We go as earlier to Source::Browse::trunck and click on test.html, then on view raw file and we note that the page appears in source code, meaning that the browser has not parsed the html code, simply because it considers the file as raw text because its mime-type is text/plain.
Here is how to fix this:
```
ubugnu@ubugnu-laptop:~$ svn propset svn:mime-type text/html ./test.html
```
then propagate againe
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.html --username ubugnu
```
Refresh the page test.html, you will see that the code is now parsed (Here is an example) :-)
if we had wanted to host for example a css file, it should have been
```
ubugnu@ubugnu-laptop:~$ svn propset svn:mime-type text/css ./test.css
```

ubugnu

Quelle est l'utilité d'héberger de tels fichiers sur Google et non pas sur un autre serveur?

Je crois que cette question n'a pas besoin de réponse, l'utilité est qu'on profite de la très généreuse bande passante de Google afin d'afficher nos pages html ou nos images, de charger nos scripts javascript ou nos feuilles de style css.
Après une longue recherche de la solution miraculeuse, et après avoir tout testé: Google sites, Google docs, encapsulation de script javascript et feuille de style css dans une image, ...etc j'ai fini par trouver la solution ultime.

En effet les deux solutions Google sites et Google docs ne sont pas permanentes, vu que les liens vers les fichiers changent de temps en temps, résultat on se retrouve forcé de mettre à jour le code source de notre site chaque jour! Ce qui n'est pas très pro. Aussi, les liens utilisés font une redirection, ce qui se traduit par un temps de chargement plus grand pour nos pages.

La solution du code encapsulé (caché) dans une image est quant à elle pas très propre, en effet j'ai remarqué un grand ralentissement du navigateur au moment de l'évaluation d'un code lourd avec la fonction eval().

La solution finale est donc d'utiliser Google code pour stocker ses fichiers et avoir un lien direct (sans redirection, permanent et surtout mime-typé). Voici comment on fait:

Créer son projet Google code:

Allez à la page http://code.google.com/hosting et cliquez sur Create a new project, donnez un nom, un sommaire et une description au projet, puis choisissez Subversion dans Version control system et n'importe quoi dans Source code license puis appuyez sur le bouton Create project, une fois le projet créé, vous vous retrouverez dans la page de gestion du projet, allez dans l'onglet Source et notez le lien du répertoire du projet, il ressemblera à ceci: https://ubugnu.googlecode.com/svn/trunk/ et se trouvera juste après svn checkout.
Pour pouvoir mettre des fichiers dans ce répertoire vous aurez besoin d'un mot de passe (sinon n'importe qui pourra bricoler dans votre projet), pour avoir ce mot de passe cliquez sur googlecode.com password juste en dessous du lien, notez aussi ce mot de passe.
Se connecter au projet via svn et héberger ses fichiers sur Google en synchronisant le répertoire du projet avec un répertoire local

On aura besoin du paquet subversion, installez le avec:
```
ubugnu@ubugnu-laptop:~$ sudo apt-get install subversion
```
Une fois le paquet installé, voila ce qu'on va faire: créer un répertoire local qui sera la copie conforme du répertoire du projet et qu'on pourra synchroniser à tout moment, c'est à dire modifier les fichiers en local, et après synchroniser pour que les fichiers sur Google soient aussi modifiés. Voila comment on crée une copie du répertoire du projet:
```
ubugnu@ubugnu-laptop:~$ svn checkout "https://ubugnu.googlecode.com/svn/trunk/" ubugnu
```
Cette commande va me créer un répertoire nommé ubugnu qui sera l'exacte copie de celui sur le serveur, et comme ce dernier est vide, mon répertoire local le sera aussi.
On va ajouter un fichier (par exemple javascript) dans notre répertoire local pour après le "propager" vers le serveur de Google, par exemple:
```
ubugnu@ubugnu-laptop:~$ cd ubugnu
ubugnu@ubugnu-laptop:~$ touche test.js
ubugnu@ubugnu-laptop:~$ cp /var/www/test.js ./test.js
ubugnu@ubugnu-laptop:~$ svn add ./test.js
```
Nous aurons besoin d'associer à svn un éditeur de texte, par exemple nano serait le mieux adapté:
```
ubugnu@ubugnu-laptop:~$ export SVN_EDITOR=nano
```
Vous pouvez mettre votre éditeur préféré à la place de nano (par exemple gedit)
Maintenant que notre répertoire local ubugnu a été modifié, on doit propager cette modification vers le serveur avec:
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.js --username ubugnu
```
ou j'ai mis mon pseudo Google (mettez à sa place le votre, c'est celui contenu dans votre adresse email gmail)
Une page s'affichera alors dans l'éditeur de texte que vous aviez préalablement choisis, sauvegardez là et quittez, puis tapez la lettre "c" (pour continue) dans le terminal et validez.
Le terminal vous demandera alors le mot de passe de l'administrateur (root), tapez le, alors il vous demandera le mot de passe d'accès au répertoire du projet sur Google, tapez celui que vous avez noté tout à l'heure et validez. Bravo, le fichier vient d'être mis sur le serveur de Google.
Pour le vérifier, cliquez sur l'onglet Source puis sur Browse et enfin sur trunck, vous verrez le fichier test.js, cliquez dessus, puis dans la page qui s'affiche clqiuez sur view raw file en bas à droite. Le lien que vous obtiendrez est celui que vous pourrez utiliser dans vos codes sources, il est rapide et permanent.

Revenez en arrière et remarquez que le mime-type du fichier est text/plain (en dessous du lien view raw file) c'est à dire du texte brute, ce qui n'est pas un problème pour un fichier javascript mais peut l'être pour d'autres extensions (css en l'occurrence)
Changer le mime-type des fichiers selon leur format:

Donc comme je l'ai dis, le mime-type peut être problématique quand il s'agit de fichiers pour lesquels le navigateur vérifie le mime-type, essayez par exemple de mettre un fichier css sur le serveur et de l'inclure dans une page, vous verrez qu'il n'aura aucun effet car son mime-type est par défaut text/plain, il faudra le changer.

Pour notre exemple, on ne va pas utiliser un fichier css mais un fichier html, créons un fichier html en local et mettons y un peu de code html:
```
ubugnu@ubugnu-laptop:~$ touch test.html
ubugnu@ubugnu-laptop:~$ nano test.html
```
et on met
```
<html> 
<body> 
<h2>it works</h2> 
</body> 
</html> 
```
Maintenant on propage cette modification avec commit
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.html --username ubugnu
```
On va comme tout à l'heure dans l'onglet Source::Browse::trunck et on clique sur test.html, on clique après sur view raw file et on remarque que la page apparait en code source, c'est à dire que le navigateur n'a pas parsé le code html, simplement parce qu'il considère le fichier comme du texte brute car son mime-type est texte/plain.
Voici donc comment réparer cela:
```
ubugnu@ubugnu-laptop:~$ svn propset svn:mime-type text/html ./test.html
```
puis on repropage
```
ubugnu@ubugnu-laptop:~$ svn commit ./test.html --username ubugnu
```
Actualisez la page test.html, vous verrez que le code est maintenant parsé (voici un exemple) :-)
Si on avait par exemple voulu héberger du css, on aurait dû faire
```
ubugnu@ubugnu-laptop:~$ svn propset svn:mime-type text/css ./test.css
```

ubugnu

Avis à tous les blogueurs Algériens, une initiative fort intéressante et proposée par SecDZ dans son blog suggère de programmer des "DZ blog days", en gros, il s'agit de se mettre d'accord pour parler d'un même sujet tous au même temps dans une même journée et chacun sur son blog et à sa manière. Pour plus d'information, voir le billet original.

ubugnu

Pour ceux qui téléchargent régulièrement des fichiers depuis megaupload voici un script bash qui vous permettra de lancer le téléchargement beaucoup plus et sans passer par un navigateur:

ubugnu@ubugnu-laptop:~$ echo "Entrez le lien:";read l;a=(`wget -qO- $l | grep -oP "(http.*gencap\.php\?.*\.gif|\"\w{20}\"|\w{100,})" | tr -d "\""`);wget -qO /tmp/c ${a[2]};echo "Entrez le captcha:";(eog /tmp/c &);read c;kill `pidof eog`;echo "Attendez 46 secondes avant le début du téléchargement...";wget -c `wget -qO- --post-data="captchacode="${a[0]}"&megavar="${a[1]}"&captcha="$c $l | grep -P "id=\"downloadlink\"" | grep -oP "(((http)\://){1}\S+)" | grep "megaupload.com\/files" | tr -d "\"" && sleep 46`

Si vous ne voulez pas taper ce script bash à chaque fois, créez un alias (une commande qui le représente) en modifiant le fichier /etc/bash.bashrc en ajoutant:

alias mega='.... ici le script ...'

Maintenant vous n'aurez qu'à taper mega dans un terminal pour lancer le script.

ubugnu

Bonne nouvelle pour les diffuseurs Algériens de publicité AdSense, Google a annoncé que les paiements des revenus AdSense vers l'Algérie peuvent être faits dorénavant via Western Union, une méthode qui prend moins de 24 heures, et où on peut encaisser ses revenus directement dans une agence postale locale.

Cette nouvelle méthode de paiement était très attendue par les diffuseurs Algériens, qui voyaient souvent leurs chèques Google refusés par les banques locales, ainsi, certains se retrouvaient avec plusieurs centaines d'euros coincés...

Seul couac, le très fort pourcentage que WU prend!

Pour bénéficier de cette nouvelle offre, modifiez dans Mon compte la méthode de paiement dans votre interface de gestion de AdSense, aussi, assurez vous que le nom du bénéficiaire correspond exactement à celui qui est écrit sur votre pièce d'identité nationale (que vous utiliserez pour retirer l'argent).
Pour retirer l'argent il vous faut fournir quatre informations dans une fiche qu'on vous donneras dans le guichet:

- Votre nom complet (pensez à ramener une pièce d'identité).

- Les coordonnées de l'émetteur : Google Inc. 1600 Amphitheatre Parkway, Mountain View, California 94043, USA. N° de téléphone : 650-253-4000.

- Le montant de votre paiement: vous le trouverez sur votre page "Historique des paiements".

- Votre numéro MTCN (Money Transfer Control Number): vous le trouverez en cliquant sur le lien "détails" en regard de la ligne Paiement émis, sur votre page "Historique des paiements".

[pour plus d'informations https://www.google.com/adsense/support/bin/answer.py?answer=65789]

Je ne sais pas pour vous mais moi je dis ... ça se fête ;-)...

ubugnu

Voilà, après un longue absence et une promesse que j'ai faite à SecDZ (que je ne suis pas sûr pouvoir arriver à tenir ;-)) je reviens pour vous parler de comment faire des requêtes cross-domain avec du code javascript très simple et sans attendre l'arrivée des nouvelles générations de XMLHttpRequest (Level 2).

Le cross-domaine simplement expliqué: Il s'agit de pouvoir faire des requêtes vers le site siteB.com à partir de code javascript chargé dans le navigateur à partir d'un site siteA.com.Il existe bien la méthode AJAX, mais qui ne permet de faire que des requêtes vers le même site (pour des questions évidentes de sécurité).Faisons un test grandeur nature, notre siteA.com est mon site ubuntudz.com et le site vers lequel on va faire des requêtes est ubugnu.com, le script javascript de cette page (émanant de siteA.com) doit être capable de faire des requêtes vers siteB.com et faire des modifications sur cette page suivant la réponse de siteB.com.

+ =

Dans cet exemple, javascript va faire une requête vers un autre site (siteB.com) et récupérer le résultat de l'addition, puis l'afficher dans la case adéquate, et ce sans passer par AJAX, car avec AJAX on n'aurait pu faire cette opération (erreur)Cette astuce est utile quand on veut profiter de la bande passante de Blogger par exemple pour le coté statique du site, et déléguer les tâches dynamique pour un autre site moins généreux en bande passante.Maintenant voila les scripts JS et PHP, le truc, c'est de créer une fonction JS qui inclut des codes JS, le serveur répondra par du vrai code JS selon les paramètres passés.


<script>
function include(src) {
    var html_doc = document.getElementsByTagName('head').item(0);
    var js = document.createElement('script');
    js.src = src;
    js.type = 'text/javascript';
    js.defer = true;
    html_doc.appendChild(js);
}
    function cal(a,b) {
    include("http://www.ubugnu.com/ubuntudz/?a="+a+"&b="+b);
}
</script>

<input id='a' style='width:20'> + <input id='b'' style='width:20'> = <input id='c'' style='width:20'> <input type='submit' onClick='cal()' value='calculer'>


<?
echo "document.getElementById('c').value=";
echo $_GET['a']+$_GET['b'].";";
?>

ubugnu

La modification des fichiers PDF peut être classée en deux catégories distinctes:

Une modification globale: ajouter/supprimer des pages, fusionner des documents, ajouter des mots clés ou un auteur, ... etc
Une modification locale: qui consiste à changer du contenu (texte ou image).

Je vais vous présenter ici les deux meilleurs applications que j'ai trouvé parmi toutes celles que j'ai testé:

Pour la modification globale il s'agit de pdftk dont j'ai déjà parlé ici
Pour la modification locale la meilleur application que j'ai trouvé et qui marche à merveille est Inkscape (sudo apt-get install inkscape), et voici comment on fait:

Ctrl+O pour ouvrir le fichier PDF qu'on veut manipuler.
Il vous proposera alors d'importer le fichier PDF, laissez les options telles quelles et validez.
Zoomez à 100% pour pouvoir bien distinguer les choses.
Cliquez sur la partie du texte que vous voulez modifier.
Allez dans menu->texte->texte et police.
Dans la boîte qui apparait, essayez de trouver la police qui ressemble à celle du texte que vous voulez modifier.
Cliquez sur l'onglet Texte et faites votre modification puis sur Appliquer.
Sauvegardez votre document et le tour est joué.

ubugnu

Si vous êtes comme moi accro de la météo et que vous voulez à chaque instant savoir ce qui se passe au dessus de vos têtes vous êtes tombés au bon endroit.

Ce qu'on va faire c'est créer une petite application qui récupèrera pour nous des animations satellites et les affichera à l'écran.Créer un dossier caché pour stocker les images, dans votre dossier personnel faites:
```
ubugnu@ubugnu-laptop:~$ mkdir .meteo
```
Créer l'application (si vous préférez utilisez gedit au lieu de nano, ou ce que vous voulez)
```
ubugnu@ubugnu-laptop:~$ sudo nano /usr/bin/myweather
```

Mettre dedans:

#!/usr/bin/env bash
wget -qO $HOME/.meteo/sat.gif "http://www.sat24.com/image.ashx?country="$1; eog $HOME/.meteo/sat.gif

Rendre le fichier exécutable:

ubugnu@ubugnu-laptop:~$ sudo chmod +x /usr/bin/myweather

Vous pouvez maintenant utiliser l'application en lui passant l'argument de la région dont vous voulez l'animation satellite, par exemple pour l'Algérie et la France, les commandes sont respectivement:
```
ubugnu@ubugnu-laptop:~$ myweather afdz &
ubugnu@ubugnu-laptop:~$ myweather fr &
```
(le & c'est pour mettre le processus en arrière-plan pour pouvoir récupérer votre terminal)
Maintenant vous pouvez par exemple mettre en exécution cette commande au démarrage du système (Menu>Système>Préférences>Applications de démarrage), mieux encore, vu que les images satellite changent d'heure en heure, vous pouvez programmer une tâche planifiée avec crontab pour afficher l'animation satellite chaque 2 heures par exemple.

Voici une liste des arguments possibles:


eu: Image satellite de l'Europe et une partie de l'Afrique du nord.
afaf: Image satellite de l'Afrique complète.
afdz: Image satellite de l'Algérie.
fr: Image satellite de la France.
alps: Image satellite des Alpes.
nl: Image satellite des Pays-Bas.
de: Image satellite de l'Allemagne.
sp: Image satellite de l'Espagne.
sp: Image satellite du Portugal.
gr: Image satellite de la Grèce.
it: Image satellite de l'Italie.
pl: Image satellite de la Pologne.
scan: Image satellite de la Scandinavie.
tu: Image satellite de la Turquie.
gb: Image satellite de la Grande-Bretagne.
gb: Image satellite de l'Irlande.
afce: Image satellite des îles Canaries.
afng: Image satellite de l'Afrique centrale.
aftd: Image satellite du Tchad.
afcg: Image satellite du Congo.
afeg: Image satellite de l'Égypte.
afet: Image satellite de l'Éthiopie.
afcm: Image Satellite du Cameroun.
afis: Image satellite du Proche-Orient.
afly: Image satellite de la Libye.
afmg: Image satellite du Madagascar.
afmo: Image satellite du Maroc.
afbw: Image satellite de la Namibie.
afsa: Image satellite de l'Arabie Saoudite.
afso: Image satellite de la Somalie.
afsd: Image satellite du Soudan.
aftz: Image satellite de la Tanzanie.
aftn: Image satellite de la Tunisie.
afwa: Image satellite de l'Afrique de l'ouest.
afzm: Image satellite de la Zambie.
afza: Image satellite de l'Afrique du sud.

ubugnu

La Deuxième GNU/LINUX Install Party en Algérie

Après le vif succès qu’à rencontré la première GNU/Linux install party et l’intérêt qu’il lui a été porté, le club scientifique et culturel OpenMinds, le Centre des Ressources Informatiques (CRI) de l’Université des Sciences et de la Technologie Houari Boumediene (USTHB) et le Campus numérique Francophone d’Alger organisent la deuxième

GNU/LINUX INSTALL PARTY

Cette deuxième GNU/LINUX Install Party en Algérie aura lieu le Mercredi 30 juin 2010 de 09h00 à 17h00 au niveau du village universitaire de l’USTHB.

L’entrée est libre ! Venez découvrir GNU/LINUX ! Apportez votre ordinateur des bénévoles vous aideront à installer GNU/LINUX sur vos machines. Des CDs UBUNTU vous seront également offerts.

Des conférences et ateliers sur l’utilisation quotidienne des logiciels libres sur un ordinateur "libéré" seront organisés tout au long de la journée.

Si vous hésitez encore sachez que GNU/LINUX est un système d’exploitation LIBRE :
Disponible et gratuit pour tous
Sécurisé et invulnérable aux virus
Rapide, stable et performant
Riche en logiciels
Compatible avec vos équipements

Pour vous faciliter l’accès à l’USTHB, demandez une invitation sur http://www.openmindsclub.org/index.php/insc-ip2.html

PS : Vous serez tenus informés de toute information complémentaire

ubugnu

Bonjour,
Il y'a quelques mois j'ai eu besoin d'encapsuler tout mes scripts, css et images dans une seul image, puis appeler cette image avec AJAX, et extraire le tout pour l'insérer dans le document. Je ne sais pas si ça va servir mais c'est intéressant de voir que ça marche ;-)

Donc, pour le tester, créez un dossier sur un serveur, mettez tout vos scripts, css et images (vous pouvez les mettre à la racine, dans des dossiers,...etc comme vous voulez), éventuellement numérotez vos scripts 1.js, 2.js, ... etc au cas ou l'un doit être inclus avant l'autre.
Mettez dans la racine du dossier une image nommée js.png, c'est elle qui va intégrer les scripts et les css.Mettez dans la racine du dossier ce script PHP:


<? 
// embed images as data:image/gif;base64,... 
function read_from_file ($file) {
    $handle = @fopen($file, "r");
    $data = '';
    if ($handle) {
        while (!feof($handle)) {
            $buffer = fgets($handle, 4096);
            $data .= $buffer;
        }
        fclose($handle);
    }
    return rtrim($data);
}
function write_to_file ($file, $data) {
    $fp = fopen($file, "w");
    fwrite($fp, $data);
    fclose($fp);
}
function lReplace($m) {
    echo "  : image ".$GLOBALS['dn'].'/'.$m[1].'.'.$m[3]."  base64 encoded in".$GLOBALS['fn']."<br>";
    return "data:image/gif;base64,".base64_encode(read_from_file($GLOBALS['dn'].'/'.$m[1].'.'.$m[3]));
}
function lParse($dirname,$file) {
    $GLOBALS['dn'] = $dirname;
    $GLOBALS['fn'] = $dirname."/".$file;
    $path = $dirname."/".$file;
    $data = read_from_file($path);
    write_to_file($path,preg_replace_callback('/([^\'\(\."\s]*)(\.)(gif|jpg|bmp|png)/i',lReplace,$data));
}
function read_dir1($dirname,$i) {
    $j=$i+1;
    $ind="";
    while($i) {$ind .= '__';$i--;}
    if (is_dir($dirname))
    $dir_handle = opendir($dirname);
    if (!$dir_handle)
    return false;
    while($file = readdir($dir_handle)) {
        if ($file != "." && $file != "..") {
            if (!is_dir($dirname."/".$file)) {
                echo $ind.$dirname."/".$file."<br>";
                if(preg_match('/.(\.)(css|js)/',$file)) {lParse($dirname,$file);}
            }
            else
            read_dir1($dirname.'/'.$file,$j);
        }
    }
    closedir($dir_handle);
    return true;
} 
read_dir1('.',0);


// embed css and js in an image 
function store($d,$f) {
    if(preg_match('/.(\.)(js)$/',$f)) $GLOBALS['data_js'] .= read_from_file($d."/".$f);
    if(preg_match('/.(\.)(js)$/',$f)) $GLOBALS['data_js'] .= "\n\n";
    if(preg_match('/.(\.)(css)$/',$f)) $GLOBALS['data_css'] .= read_from_file($d."/".$f);
    if(preg_match('/.(\.)(css)$/',$f)) $GLOBALS['data_css'] .= "\n\n";
}
$ord = 1;

if($ord) {
    function reador_dir($dirname,$i,$max) {
    $j=$i+1;
    $ind="";
    while($i) {$ind .= '__';$i--;}
    if (is_dir($dirname))
    $dir_handle = opendir($dirname);
    if (!$dir_handle)
    return false;
    while($file = readdir($dir_handle)) {
        if ($file != "." && $file != "..") {
            if (!is_dir($dirname."/".$file)) {
                if(preg_match('/(\d){1,2}(\.)(js)$/',$file,$m) && $m[1]>$max) {$max=$m[1];}
            }
            else
            $max = reador_dir($dirname.'/'.$file,$j,$max);
        }
    }
    closedir($dir_handle);
    return $max;
    }

    function storord($dirname,$i) {
        if (is_dir($dirname))
        $dir_handle = opendir($dirname);
        if (!$dir_handle)
        return false;
        while($file = readdir($dir_handle)) {
            if ($file != "." && $file != "..") {
                if (!is_dir($dirname."/".$file)) {
                    if(preg_match("/$i(\.)(js)$/",$file)) {store($dirname,$file);echo "store($dirname/$file)<br>";}
                }
                else
                storord($dirname.'/'.$file,$i);
            }
        }
        closedir($dir_handle);
        return false;
    }

    echo "max is ".reador_dir('.',0,1)."<br>";
    $i=1;
    while($i<reador_dir('.',0,1)+1) {storord('.',$i); $i++;}
}
function read_dir2($dirname,$i,$ord) {
    $j=$i+1;
    $ind="";
    while($i) {$ind .= '__';$i--;}
    if (is_dir($dirname))
    $dir_handle = opendir($dirname);
    if (!$dir_handle)
    return false;
    while($file = readdir($dir_handle)) {
        if ($file != "." && $file != "..") {
            if (!is_dir($dirname."/".$file)) {
                if(preg_match('/.(\.)(css|js)$/',$file) && !$ord) {store($dirname,$file);echo "store($dirname/$file)<br>";}
                elseif(preg_match('/.(\.)(css|js)$/',$file) && !preg_match('/(\d){1,2}(\.)(css|js)$/',$file)) {store($dirname,$file);echo "store($dirname/$file)<br>";}
            }
            else
            read_dir2($dirname.'/'.$file,$j,$ord);
        }
    }
    closedir($dir_handle);
    return true;
} 
read_dir2('.',0,$ord); 
write_to_file ("js.png", read_from_file("js.png")."\n[JS]".$GLOBALS['data_js']."\n[CSS]".$GLOBALS['data_css']); 
?>

Lancez ce script PHP, vous remarquerez qu'a la fin la taille de l'image aura considérablement augmenté, maintenant, dans la page qui doit inclure ce que vous avez encapsulé dans l'image, mettre le code javascript suivant:


<script>

function get_js (url) {
    var request = false;
    if(window.XMLHttpRequest) {
          request = new XMLHttpRequest();
          if(request.overrideMimeType) {
              request.overrideMimeType('text/xml');
          }
    } else if(window.ActiveXObject) {
          var versions = ['Microsoft.XMLHTTP', 'MSXML.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.7.0', 'Msxml2.XMLHTTP.6.0', 'Msxml2.XMLHTTP.5.0', 'Msxml2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP'];
          for(var i=0; i<versions.length; i++) {
              try {
                  request = new ActiveXObject(versions[i]);
              } catch(e) {}
          }
    }
    xmlHttpReq = request;
    xmlHttpReq.open("GET",url, false);
    //xmlHttpReq.onload = load_image(xmlHttpReq.responseText);
    xmlHttpReq.send(null);
    return xmlHttpReq.responseText;
}

function ress(resp,type) {
    var b1 = resp.indexOf('[JS]') + 4;
    var b2 = resp.indexOf('[CSS]') + 5;
    var delb = b2-b1-5;
    if(type=="js") return resp.substr(b1,delb);
    if(type=="css") return resp.substring(b2);
}

var resp = get_js('js.png','js');
var html_doc = document.getElementsByTagName('head').item(0);
var js = document.createElement('script'); js.textContent = ress(resp,'js'); html_doc.appendChild(js);
var sty = document.createElement('style'); sty.textContent = ress(resp,'css'); html_doc.appendChild(sty); 
</script>

Voila, maintenant vous pouvez utiliser le javascript et le css avec les images comme si vous l'avez inclue directement.
J'espère que j'ai été claire :-)

ubugnu

Si par erreur le grub n'apparait plus (une de ces erreurs étant d'installer Windows) ou par chance Windows n'apparait plus dans grub ;-) voila les étapes à suivre pour réparer tout ça:

Bootez avec un 9.10 liveCD
Montez la partition dans laquelle est Ubuntu, et cherchez son chemin .... généralement c'est un truc du genre /media/hy756kb89KJ-Bkh9987bk-UJHG
Regardez dans quelle disque dur est installé Ubuntu, si vous n'en avez qu'un seul ça sera /dev/sda

Ouvrez un terminal et faites:

ubugnu@ubugnu-laptop:~$ sudo grub-install --root-directory=/media/hy756kb89KJ-Bkh9987bk-UJHG /dev/sda

Redémarrez vous verrez que vous avez le grub mais pas avec Windows dans la liste.
Entrez dans Ubuntu (l'installé pas le liveCD) et faites les commandes suivantes:
```
ubugnu@ubugnu-laptop:~$ sudo chmod u+w /boot/grub/grub.cfg
ubugnu@ubugnu-laptop:~$ sudo nano /boot/grub/grub.cfg
```
(si vous préfèrez gedit au lieu de nano) et ajoutez ça avec les "menuentry"s:
```
menuentry "Windows XP" {
  set root=(hd0,1)
  chainloader +1
}
```
Dans mon cas, Windows est dans sda1 (premier disque dur partition 1) j'ai mis (hd0,1), vous changez cette ligne selon votre cas, par exemple si Windows est dans:
```
sdb2 -> (hd1,2)
sda5 -> (hd0,5)
```

Voila j'éspère que c'est claire comme un ecran de la mort de Windows ;-)
PS: pour savoir sur quelle partition est installé quoi, utilisez par exemple Gparted

ubugnu

Cette méthode est très simple mais néanmoins complète et efficace, ce qu'il nous faut c'est:

Un serveur: c'est le PC qui va se connecter à internet et partager cette connexion avec l'autre (les autres) PC (PCs), il doit être équipé de deux cartes réseaux (ou plus).
Le client: c'est le PC qui va recevoir la connexion internet depuis le serveur (on peut aussi avoir plusieurs clients)

Donc supposons qu'on ait un serveur équipé de deux cartes réseaux et ayant une connexion à internet activée + un client ayant une carte réseau, tout d'abord, on doit établir un réseau entres les deux machines, pour ce, je vais vous diriger vers un précédant billet mais avant, il faudra savoir détecter quelle carte réseau reçoit internet pour en déduire laquelle servira au partage (sera reliée à l'autre PC), on tape:

ubugnu@ubugnu-laptop:~$ ifconfig

dans un terminal, vous aurez un ensemble d'interfaces qui peuvent avoir les noms: lo, eth0, eth1, ...., ppp0, ppp1, ... etc, repérez celle qui porte une adresse IP, par exemple dans mon cas c'est:

eth0    Link encap:Ethernet  HWaddr 99:0e:JK:i9:65:17  
        inet adr:192.168.1.2  Bcast:192.168.1.255  Masque:255.255.255.0
        adr inet6: fe80::20e:7bff:fef6:6513/64 Scope:Lien
        UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
        Packets reçus:8759 erreurs:0 :0 overruns:0 frame:0
        TX packets:8802 errors:0 dropped:0 overruns:0 carrier:0
        collisions:0 lg file transmission:1000 
        Octets reçus:5836792 (5.8 MB) Octets transmis:2145823 (2.1 MB)

J'en conclut donc que c'est l'autre carte réseau eth1 qui servira pour le partage de connexion.
Remarque: Dans mon cas j'utilise mon modem comme routeur/serveur DHCP qui a attribué l'adresse IP (locale) 192.168.1.2 à ma carte réseau eth0, si vous utilisez votre modem comme Bridge et avez configuré votre connexion internet vie l'utilitaire pppoeconf vous aurez surement une interface ppp0 comme seule interface ayant une adresse IP (public dans ce cas) au lieu de eth0, vous aurez donc deux autres interfaces eth0 et eth1 (les deux cartes réseau) toutes deux sans adresse IP! alors comment distinguer laquelle est utilisée pour la connexion? Voici une méthode:
Détecter celle qui est reliée à internet: Débranchez celle qui est reliée à l'autre PC et ne laissez que celle qui reçoit l'internet, puis tapez la commande:

ubugnu@ubugnu-laptop:~$ watch ifconfig

Et surveillez quelle interface a le paramètre "Packets reçus" qui change, ce sera elle par laquelle transitent les paquets internet, supposons que c'est eth0, donc ça sera eth1 qui sera reliée à l'autre PC. Bien sûr, rien n'interdit d'échanger les deux...

Une petite récapitulation:

On cherche quelle est l'interface qui reçoit internet ça peut être: (interface de connexion)
- ppp0: si vous avez configuré votre connexion en utilisant pppoeconf
- eth0 ou eth1 sinon
On cherche quelle est l'interface qui servira à partager internet vers l'autre PC (interface de partage), ça sera soit eth1 ou eth0 selon qu'on ait trouvé eth0 ou eth1 comme interface de connexion

Donc, je vais supposer le cas que je juge le plus répandu parmi mes lecteurs, à savoir:

Interface d'entrée de l'internet: ppp0 (interface de connexion)
Interface de sortie: eth1 (interface de partage)

Bien sûr, dans tout ce qui suit, vous changerez ppp0 et eth1 par ce que vous avez trouvé en suivant ma précédente présentation. Notez tout ça sur un bout de papier.

Je vous dirige donc comme promis vers mon billet qui parle de comment créer un réseau entre deux PCs, une remarque importante, vu que dans mon cas c'est eth1 qui sera utilisée pour relier les deux PC je devrais donc remplacer la ligne:

ubugnu@ubugnu-laptop:~$ sudo ifconfig eth0 192.168.0.1

(pour le pc principal par exemple) par

ubugnu@ubugnu-laptop:~$ sudo ifconfig eth1 192.168.0.1

(pour le pc principal par exemple) dans le billet vers lequel je vous ai dirigé.
Ici le PC principal c'est notre serveur.
À la fin, faites un ping de part et d'autre pour vérifier que la liaison est bien établie, si c'est le cas, on peut continuer.

Coté Serveur:

Maintenant que les deux PC sont bien reliés, on doit rediriger les paquets (dans le serveur) de l'interface de connexion (ppp0) vers l'interface de partage (eth1), pour ce, on commence par indiquer quelle interface servira d'interface de partage.
Allez au Moniteur de connexion réseau, il doit être dans le tableau de bord, si ce n'est pas le cas; faites Alt+F2 et tapez nm-applet pour le faire apparaitre.Clique droit dessus, puis allez à "Modification de connexions", clique droit sur l'interface de partage (dans mon cas eth1) et choisissez "Partager avec d'autres ordinateurs". L'interface devrait disparaitre de la liste après cette opération.
Maintenant, on doit autoriser la redirection des paquets internet de l'interface de connexion (ppp0) vers l'interface de partage (eth1) en ajoutant des règles dans l'iptables, tapez dans la console:

ubugnu@ubugnu-laptop:~$ sudo iptables -A FORWARD -i ppp0 -o eth1 -s 192.168.0.0/24 -m conntrack --ctstate NEW -j ACCEPT 
ubugnu@ubugnu-laptop:~$ sudo iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT 
ubugnu@ubugnu-laptop:~$ sudo iptables -A POSTROUTING -t nat -j MASQUERADE

La première règle sert à autoriser les paquets initialement transmis entre les deux interfaces, la deuxième sert à autoriser les connexions ainsi établies, la troisième établit le NAT (Network Adress Translation)
Il faut maintenant modifier deux fichiers, on utilisera nano:

ubugnu@ubugnu-laptop:~$ nano /proc/sys/net/ipv4/ip_forward

mettez 1 (le chiffre 1) et enregistrez avec Ctrl+o puis quittez avec Ctrl+x, puis:

ubugnu@ubugnu-laptop:~$ nano /etc/sysctl.conf

et ajoutez à la fin les lignes:

net.ipv4.conf.default.forwarding=1
net.ipv4.conf.all.forwarding=1

enregistrez et quittez.
(cette dernière opération n'est plus nécessaire dans les versions 9+)

Coté client:

Pour le client, il suffit de lui indiquer d'utiliser comme passerelle par défaut le serveur, dans notre cas le serveur à comme IP 192.168.0.1 (et le client 192.168.0.100 selon le précédent billet), donc, chez le client taper la commande:

ubugnu@ubugnu-laptop:~$ sudo route add default gw 192.168.0.1

À ce point la connéxion devrait être activée chez le client, pour s'en assurer on va pinger l'adresse IP de google.com:

ubugnu@ubugnu-laptop:~$ ping 209.85.227.99

Vous remarquerez qu'il y'a des temps de réponse, donc c'est bon. Seulement voila, si vous essayez de pinger google.com en utilisant son nom de domaine:

ubugnu@ubugnu-laptop:~$ ping google.com

vous n'aurez aucune réponse, c'est parce que le client n'a encore aucun serveur DNS à interroger pour traduire les noms de domaine en adresses IP, la même chose arrivera dans votre navigateur préféré si vous essayez.
Ce qui arrive, c'est que le client essais d'interroger la passerelle par défaut (en l'occurrence notre serveur) pour le DNS, or, on n'a pas configurer le serveur pour router les requêtes DNS, il y'a deux solutions:

Retour au serveur:

Soit
Installer dnsmasq:

ubugnu@ubugnu-laptop:~$ sudo aptitude install dnsmasq

qui va justement router les requêtes DNS (rediriger), il lui faut quelques modifications, on l'arrête d'abord:

ubugnu@ubugnu-laptop:~$ sudo /etc/init.d/dnsmasq stop

puis on édite don fichier de configuration avec nano:

ubugnu@ubugnu-laptop:~$ sudo nano /etc/dnsmasq.conf

en y mettant:

interface=eth1
dhcp-range=192.168.0.100,192.168.0.250,72h

Puis on le redémarre avec:

ubugnu@ubugnu-laptop:~$ sudo /etc/init.d/dnsmasq start

Soit (de préférence)
Transformer le serveur en une serveur DNS en installant bind9:

ubugnu@ubugnu-laptop:~$ sudo apt-get install bind9

Configurons le:

ubugnu@ubugnu-laptop:~$ sudo nano /etc/bind/named.conf.options

Recopiez ce qui suit

options {
directory "/var/cache/bind";
// If there is a firewall between you and nameservers you want
// to talk to, you may need to fix the firewall to allow multiple
// ports to talk. See http://www.kb.cert.org/vuls/id/800113
// Écouter les requêtes venant que de la boucle interne. Si vous voulez que BIND
// écoute en IPv6, dé-commentez la ligne listen-on-v6 { ::1; } ou mettez listen-on-v6 { any; }
listen-on { 127.0.0.1; }; 
// listen-on-v6 { ::1; };
auth-nxdomain no; # conform to RFC1035
recursion yes;
// Votre serveur BIND DNS permet la récursion et servira de cache que pour les
// requêtes locales
allow-recursion { 127.0.0.1; };
allow-query-cache { 127.0.0.1; };
// Pour cacher la version du serveur Bind DNS aux éventuels scans extérieurs
version "Version non disponible!";
// Rediriger toutes les réquêtes DNS vers les serveurs DNS
// publiques de Google : les fameux 8.8.8.8 et 8.8.4.4
//forwarders { 8.8.8.8; 8.8.4.4; };
//forward only;
};

et redémarrez le serveur DNS

ubugnu@ubugnu-laptop:~$ sudo /etc/init.d/bind9 restart

Et le tour est joué.

Remarque: vous pouvez même utiliser ce serveur DNS pour le serveur lui même, pourquoi donc? Quand vous tapez un adresse internet, votre navigateur interroge les serveurs DNS de votre FAI (fournisseur d'accès internet), ça peut prendre plusieurs secondes, alors qu'en utilisant votre propre machine comme serveur DNS, les interrogations passées seront stockées en mémoire cache, et dès la deuxième requête DNS, le temps de réponse passera de plusieurs secondes à une milliseconde!!! C'est sûr qu'on ne s'en en passerait pas...
Pour rendre aussi votre serveur s'interroger lui-même quand il s'agit de DNS, pour ce, changer le fichier:

ubugnu@ubugnu-laptop:~$ sudo nano /etc/resolv.conf

Vous y trouverez les IPs des serveurs DNS de votre FAI, remplacez les par l'adresse IP locale nameserver 127.0.0.1
Maintenant, même le serveur utilisera son serveur DNS embarqué pour les résolutions des noms de domaines.

EDIT: (automatiser l'opération)
Que faire quand on redémarre? On ne vas pas à chaque fois refaire les mêmes opérations comme même! On va créer des commandes de connexion, il n'y aura qu'a taper ces deux simples commandes sur les deux machines à chaque fois qu'on veut partager la connexion.

Sur le serveur:

ubugnu@ubugnu-laptop:~$ sudo nano /usr/bin/share-connection

et on met dedans:

ifconfig eth1 192.168.0.1
iptables -A FORWARD -i ppp0 -o eth1 -s 192.168.0.0/24 -m conntrack --ctstate NEW -j ACCEPT
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A POSTROUTING -t nat -j MASQUERADE

Après on rend le script exécutable:

ubugnu@ubugnu-laptop:~$ sudo chmod +x /usr/bin/share-connection

Sur le client:

ubugnu@ubugnu-laptop:~$ sudo nano /usr/bin/share-connection

et on met dedans:

ifconfig eth0 192.168.0.100
route add default gw 192.168.0.1

Après on rend le script exécutable:

ubugnu@ubugnu-laptop:~$ sudo chmod +x /usr/bin/share-connection

Maintenant à chaque fois qu'on voudra partager la connexion, on tapera sur les deux machines la commande: # sudo share-connection

ubugnu

2010 GA6, c'est le nom de cet astéroïde, passera à 359,000 Km de la terre, autant dire, un distance comparable à une tête d'épingle à l'échelle cosmologique! Pour comparaison, il sera plus près de nous que ... la lune!!!
Si sa trajectoire avait dévié d'un millimètre il y'a des années, il se pourrait qu'il allait entrer en collision avec la terre aujourd'hui! El hemdou lil'Allah.
Il mesure 11 mètres, c'est pas beaucoup mais assez pour raser une ville et faire des milliers de morts. Les scientifiques assurent qu'il n'y a aucune chance pour qu'il entre en collision avec la terre. Peu importe, tant que ce n'est pas moi qui ais fais les calculs, je scruterais le ciel cette nuit pour observer ce merveilleux phénomène, et prendre mon vaisseau spatial si je vois qu'il s'approche trop près :-)
Il sera au plus près à 23h06 GMT donc n'oubliez pas de jeter un coup d'œil vers les étoiles ce soir ;)

ubugnu

Bonjour,
Sur mon laptop je n'avais aucune possibilité d'écrire les deux caractères < et >, une situation plutôt gênante surtout pour quelqu'un qui écrit plein de scripts... Je n'allais comme même pas copier/coller à partir du code source HTML de pages internet ces deux caractères! Voila la méthode donc que j'ai trouvé pour redéfinir des touches du clavier.

Détecter le "keycode" des touches que l'on veut redéfinir, pour ce, exécuter xev
```
ubugnu@ubugnu-laptop:~$ xev
```
cliquer sur le petit carreau qui apparait et presser la touche dont vous voulez connaitre le keycode, un tas d'informations apparaitront dans le terminal, repérer seulement le nombre que désigne keycode, par exemple en pressant "f" je vois "keycode 77". J'ai pressé deux autres touches que je n'utilise jamais (et que je veux donc utiliser pour les caractères < et >) et j'ai eu 100 et 102.
Créer un fichier caché sous le nom de xmodmaprc dans le dossier personnel:
```
ubugnu@ubugnu-laptop:~$ nano ~/.xmodmaprc
```
et y mettre les keycodes associés aux caractères qu'on veut leur attribuer, par exemple pour moi:
```
keycode 102 = less
keycode 100 = greater
```
sauvegarder avec Ctrl+o et quitter avec Ctrl+x

Activer avec

ubugnu@ubugnu-laptop:~$ xmodmap ~/.xmodmaprc

Et le tour est joué ;-)

Au redémarrage, Ubuntu nous demandera quel fichier xmodmap on veut utiliser, cliquer sur "Charger", cocher sur "Ne plus jamais afficher ce message" puis sur "Valider".
La chose importante à noter est qu'on ne doit pas mettre les caractères directement dans le fichier xmodmap si ce sont des caractères spéciaux, dans mon cas j'ai mis "less" et "greater" pour désigner < et >, voici quelques exemples:

| bar
/ slash
\ backslach
_ underscore

ubugnu

Salut,
Voici un petit programme dédié à Linux que j'ai fais et qui permet d'envoyer en un seul clique (ou raccourci) ses messages Websms gratuits depuis le Terminal (la Console).Pour ceux qui travaillent beaucoup sur leur Terminal (et comme moi peut être y lisent même les infos) ce petit programme est fait pour eux :-)
En plus j'ai mis un système d'annuaire, comme ça, plus besoin de se souvenir des numéros, seuls les noms suffisent.
Voila comment installer:

ubugnu@ubugnu-laptop:~$ wget -O websms "http://docs.google.com/uc?id=0B5HrmereKixnYTM0YThmNjgtYzBjNS00MmFhLTlmYWItMTMxOWZhZGMwOGQ2&export=download"
ubugnu@ubugnu-laptop:~$ chmod +x websms
ubugnu@ubugnu-laptop:~$ ./websms

Vous devrez spécifier le numéro de téléphone et le mot de passe pour que le programme les stocke dans un fichier de configuration pour les utiliser à chaque fois.Vous n'aurez après qu'à taper la commande:

ubugnu@ubugnu-laptop:~$ websms

pour envoyer rapidement des SMSVous pourrez aussi spécifier par exemple un nom:

ubugnu@ubugnu-laptop:~$ websms zaki

Ou envoyer depuis un autre compte:

ubugnu@ubugnu-laptop:~$ websms -n

Changer le compte par défaut:

ubugnu@ubugnu-laptop:~$ websms -c

Ou ajouter des noms à l'annuaire:

ubugnu@ubugnu-laptop:~$ websms -a

Voila amusez vous en attendant le patch ;-)
Remarque: Au cas où le lien dans la commande wget ne marche pas, téléchargez le programme d'installation depuis ce lien et renommez le fichier en websms puis passez à la deuxième commande chmod

ubugnu

La réponse à toutes ces questions c'est MaxiVista... Bon d'accord c'est un logiciel pour Windows, mais il marche parfaitement sous Ubuntu (Linux) en utilisant WINE.
Ça consiste à cloner l'affichage d'un écran ou carrément l'étendre à deux écrans de deux machines ayant une connéxion TCP/IP entre eux. On pourra alors travailler sur un environnement multi-moniteurs (jusqu'à 4) avec la possibilité de faire glisser des fenêtre entre eux. Cool non?! :-)
Ceci est possible entre deux machines indépendement de leur systèmes d'exploitation, par exemple j'ai réussis à le faire marcher entre un XP et un Ubuntu.
L'installation est assez simple, téléchargez le fichier d'installation, il y'a le serveur (l'écran qui va être cloné ou étendu) et le client (l'écran qui va être utilisé comme extension ou pour le clonage), le programme s'installe d'abord sur le serveur, puis il créera un autre programme qui devra être déplacé et exécuté sur le client, pas besoin de spécifier les adresses IP, les deux processus se reconnaitront sur le réseau tout seuls comme des grands :-).
On peut basculer entre les mode clonage (miroir) et étendu en cliquant par la droite sur l'icône qui apparait dans la zone de notification de serveur (qu'il soit Windows ou Linux), aussi, je vous conseille de mettre dans options:

Taille des paquets maximale.
Taille des blocs minimale
Compression minimale (charge sur le réseau plutôt que sur le processeur vu que c'est un LAN)

Remarques:

Pour avoir le mot de passe envoyer un email à ubugnu dans gmail.com
Pensez à changer l'année avant l'installation, mettre 2000 par exemple, à la fin vous pourrez remettre la bonne.
Le programme ne supporte pas encore l'accélération matérielle, donc oubliez les jeux...

ubugnu

Pour ce faire, reliez les deux PC avec un câble croisé (les couleurs des fils de part-et-d'autre du câble ne se trouvent pas du même coté, pour comparaison, la câble reliant votre PC au modem est un câble droit, les couleurs sont dans le même de part-et-d'autre du câble), identifiez les deux interfaces représentant les deux cartes réseau des deux PC (avec un ifconfig sur chaque PC) normalement toutes deux s'appellent eth0 (sauf si sur l'un des PC -ou les deux- vous avez deux cartes réseau, il faudra reconnaitre la carte avec sa marque ou tout autre indice, par exemple si l'autre sert à la connexion internet, vous lui verrez attribuée une adresse IP dans la commande ifconfig), donc supposons que nos deux cartes réseau portent tout deux le nom eth0, on tapera sur les deux PC les commandes:

ubugnu@ubugnu-laptop:~$ sudo ifconfig eth0 192.168.0.1

(pour le PC principal par exemple)

ubugnu@ubugnu-laptop:~$ sudo ifconfig eth0 192.168.0.100

(pour l'autre PC, vous pouvez mettre n'importe quoi à la place de 100 sauf 0 et 1)
Faire un petit test, par exemple pinger la premier à partir du deuxième:

ubugnu@ubugnu-laptop:~$ ping 192.168.0.1

Si vous avez un temps de réponse c'est bon.
Voila maintenant vous avez une connexion TCP/IP entre les deux PC (un réseau) vous pouvez par exemple accéder au serveur Apache de l'un à partir de l'autre, l'une des utilisations que j'en fais c'est pour transférer les fichiers, en effet je met un lien symbolique dans le dossier /www vers la racine /:

ubugnu@ubugnu-laptop:~$ sudo ln -s / /var/www/root

de ce fait j'aurais accès à tout les fichiers présents à partir de Apache, par exemple en tapant dans le navigateur http://192.168.0.1/root/

ubugnu

Google ne finira pas de nous surprendre, afin de rendre le web plus sûr, voila qu'ils mettent Skipfish sur le marché, à part le fait que cette application ait été créée par un grand hacker (travaillant chez Google), elle a la particularité d'être écrite en C, donc très bas niveau, donc pas trop de ressources consommées et plus de rapidité (d'ailleurs beaucoup plus je le confirme), je ne vais pas lister ici les types de vulnérabilités que ça peut détecter, je vous laisse un lien (disons que c'est un big super-crawler autodidacte qui déniche tout type de faille) mais voila comment on l'installe et utilise:

ubugnu@ubugnu-laptop:~$ wget "http://skipfish.googlecode.com/files/skipfish-1.11b.tgz "
ubugnu@ubugnu-laptop:~$ tar zxvf "skipfish-1.11b.tgz"
ubugnu@ubugnu-laptop:~$ sudo apt-get install libidn11-dev 
ubugnu@ubugnu-laptop:~$ sudo apt-get install libssl-dev 
ubugnu@ubugnu-laptop:~$ cd skipfish 
ubugnu@ubugnu-laptop:~$ make 
ubugnu@ubugnu-laptop:~$ cp dictionaries/default.wl skipfish.wl 
ubugnu@ubugnu-laptop:~$ ./skipfish -o resultat "http://www.monsite.com"

Vous aurez à la fin un fichier index.html bien structuré dans le répertoire "resultat", attention, il vaut mieux l'ouvrir avec http:// plutôt qu'avec file:/// à cause de certaines security policy dans les navigateurs, en effet ce fichier comprend du js.

ubugnu

Bon comme tout le monde, quand j'ai testé Chrome browser pour la première fois j'ai été ébahi par sa rapidité, à tel point que j'ai pensé ne plus jamais réutiliser Firefox... après quelques mois, je le pense toujours mais il arrive parfois que Chrome devienne très très lent! Selon moi voici les causes:

Chaque tab est un processus à lui tout seul.
Le flash sous Chrome c'est processeur en surchauffe assuré!
Par défaut des captures d'écran des 8 sites les plus visités apparaissent à chaque ouverture d'un nouveau tab (qui s'en sert?!!)
À chaque fois qu'on commence à taper un adresse ou un mot clé Chrome va chercher parallèlement sur Google et dans l'historique des correspondances... et ça ne fait vraiment pas bon ménage. Surtout si comme moi vous n'avez pas purgé l'historique et la cache depuis longtemps car vous avez besoin de garder une trace de ce que vous avez fais.

Et voici de possibles solutions:

La seule solution c'est de ne pas ouvrir beaucoup trop de tabs.
Utilisez FlashBlock, très simple, il n'y aura qu'a cliquer sur un flash pour le débloquer.
Désactivez l'affichage de ces captures et si vous n'en avez pas besoin, désactivez aussi l'affichage de l'historique proche, pour ce, cliquez sur la petite flèche qui pointe vers le bas, en haut à droite.
Faire une recherche sur le net à chaque fois qu'on tape une lettre dans la barre d'adresse est vraiment inutile à mon avis, surtout si dans ma majorité des cas on ne veut accéder qu'a un url stocké dans l'historique, donc il vaut mieux désactiver cette option dans Outils::Options::Options Avancées et décochez "Afficher des suggestions pour les ...".

Maintenant, un navigateur à qui on n'a pas fait un purge depuis longtemps est forcément lent (historique et cache trop gros) donc si vous n'avez pas besoin d'eux il vaut mieux purger de temps en temps avec Outils::Options::Données Personnelles puis cliquez sur "Effacer les données de navigation" (Choisissez comme même de conserver les mots de passes et les cookies qui ne font pas de mal). Maintenant si vous avez absolument besoin de garder votre historique et votre cache mais que comme même vous voudriez avoir l'occasion d'utiliser un Chrome léger la solution c'est d'ouvrir une autre session (voir plus bas)
Pour ouvrir une autre session, tapez dans votre terminale (ou Alt+F2): google-chrome --user-data-dir=/tmp/iubhfiuzv & Où j'ai fais exprès de mettre un dossier quelconque dans /tmp/ pour qu'il soit détruit après automatiquement, si vous avez besoin de garder la trace de votre travail sur cette nouvelle session créer le dossier de session dans votre répertoire personnel, e.g:

ubugnu@ubugnu-laptop:~$ google-chrome --user-data-dir=/home/moi/.sess1 &

(j'ai mis un . avant le nom du répertoire pour qu'il soit caché et ne pollue pas le dossier personnel) bien sûr si vous voulez réutiliser cette session après il faudra spécifier le même nom de répertoire.
Une dernière info, il est possible de passer dans une nouvelle session en un clin d'œil (si par exemple vous voulez accéder à un site avec un autre login), ça s'appelle incognito et ça vous ouvre une nouvelle fenêtre en utilisant le raccourci clavier Ctrl+Shift+N

ubugnu

Bonjour,
Si on a des fichiers qu'on ne veut surtout pas voir tomber entre les mains de quelqu'un d'autre (briefing d'une opération commando, plans d'un missile balistique, ...) alors la meilleur solution est de brouiller ce fichier avant de le supprimer. En effet, vous devez savoir que lorsqu'on supprime un fichier, ce dernier reste sur le disque dur, il perd seulement son "ticket" de présence sur le disque dur ce qui le rend vulnérable à tout nouveau fichier créé (il peut être créé au dessus de lui) ... mais entre temps, il peut être récupéré. Pour être sûr qu'on ne le récuperera pas, il faut le brouiller, sous Linux c'est très simple: on érit aléatoirement des 0 sur ce fichier N fois avec la commande shred:

ubugnu@ubugnu-laptop:~$ shred -z -u -n 10 missile.pdf

shred : faire un petite chirurgie au fichier missile.pdf
-n 10 : repasser 10 fois sur le fichier
-u : tuer le fichier après l'opération (le supprimer)
-z : recouvrir le corp pour le cacher (mettre un tapis de zéros sur le fichier)

On peut même le faire pour une partition commplète:

ubugnu@ubugnu-laptop:~$ shred /dev/sda1

ubugnu

C'est un système semblable à celui du partage des fichiers sauf que là ce n'est plus des packs antivirus ou des Windows piratés qu'on partage mais de la télé en live! La meilleur application que j'ai pu trouver ne marche que sous Windows, mais rassurez vous, ça roule parfaitement sous WINE ;-)

Primo il vous faut WINE:
```
ubugnu@ubugnu-laptop:~$ sudo apt-get install wine
```
Bon ça je crois que vous l'aviez déjà.
Deuxio on télécharge l'application (un .exe) iciAprès l'installation, ajoutez les serveurs suivants:
```
fanshoptv.no-ip.info
tracker.tvants.com
tracker2.tvants.com
```
Faites une recherche de la chaine que vous désirez, une fois trouvée, double-cliquez sur elle puis cliquez sur "non" dans la fenêtre qui apparait, un Streaming démarrera sur le port 16900 e, extension .asf, la première chaine sera dans mms://localhost:16900/1.asf vous pourrez y accéder par totem (fichier::ouvrir emplacement) ou mieux encore par VLC [sudo apt-get install vlc pour installer] (fichier::ouvrir un flux réseau) en mettant l'adresse précédente.

ubugnu

Pour ceux qui ne peuvent attendre jusqu'à la sortie officielle le 29 Avril 2010, voila une version beta qui promet des changements.Nouveautés:

Design
Noyau 2.6.32-14.20
Gestionnaire de démarrage Plymouth, plus beau, plus fluide.
Spectaculaire avancé dans le temps de démarrage, en partie aussi grâce à l'abandon du HAL.
Dernières versions de Gnome ou de KDE.
Pilote NVIDIA.
Plus de Gimp (malheureusement!).
Intégration de PiTiVi (montage vidéo).
...

Installation:

http://cdimage.ubuntu.com/releases/lucid/beta-1/ (Ubuntu Desktop and Server) http://uec-images.ubuntu.com/releases/lucid/beta-1/ (Ubuntu Server for UEC and EC2) http://cdimage.ubuntu.com/ports/releases/lucid/beta-1/ (Ubuntu ARM) http://cdimage.ubuntu.com/kubuntu/releases/lucid/beta-1/ (Kubuntu Desktop and Netbook Remix) http://cdimage.ubuntu.com/xubuntu/releases/lucid/beta-1/ (Xubuntu)

ubugnu

Nouvelle approche dans la lutte de Microsoft contre les hackers: utiliser un juge pour couper l'herbe sous les pieds de ceux qui veulent lui nuire.

Microsoft a obtenu d'un juge la décision de couper les liens entre des ordinateurs infectés et les centres de commandes d'un virus nommé Waledac. La décision du juge a permis à Microsoft de désactiver des noms de domaines par lesquelles les pirates passaient pour donner des instructions aux ordinateurs infectés par le virus.Selon Microsoft, le virus Waledac a infectés des centaines de milliers d'ordinateurs de par le monde. Ce dernier infecte les ordinateurs via des courriels ou des liens malveillants. Une fois infectée, l'ordinateur est sous le contrôle du pirate qui peut l'utiliser pour envoyer des pourriels (spams) ou explorer le contenu du disque dur. Le réseau d'ordinateurs infectés serait responsable de l'envoi de plus d'un milliard et demi de pourriels quotidien.Microsoft précise que son action judiciaire permet de bloquer temporairement le virus en coupant le cordon qui le lie au centre de commandement. Il reste aux possesseurs d'ordinateurs infectés de procéder à l'élimination du virus via un antivirus.
Source: echosdunet.net

ubugnu

Salut,
Pour pouvoir surfer sur des réseaux d'entreprises, d'écoles ou d'universités il faut activer le DHCP:
Editer le fichier /etc/network/:

ubugnu@ubugnu-laptop:~$ sudo gedit /etc/network/interfaces

Et remplacer la ligne "iface eth0 inet manual" par "iface eth0 inet dhcp"
Enregistrer et relancer le réseau avec:

ubugnu@ubugnu-laptop:~$ sudo /etc/init.d/networking restart

Bon surf :o)

ubugnu

Décidément tonton billou n'arrêtera jamais de nous surprendre! Après la très médiatisée faille de IE6+ dont se sont (apparemment) servi les chinois pour lancer la plus grande opération de piratage publique de tout les temps (Aurora operation) contre pas moins de 20 compagnies et institutions (dont Google, Adobe ou The Washington Post), voici que maintenant Microsoft déclare que l'un de ses ingénieurs a détecté, le jour même de la publication du très attendu patch pour IE6+, une faille qui se trouve sous Windows depuis ... 17 ans!!!
Cette faille qui affecte les systèmes 32 bits est née de la mise en route en 1993 d'une machine virtuelle (la VDM) pour que Windows supporte les anciennes applications 16 bits, rien que ça!
Les versions affectées sont: Windows 2000, Windows XP, Windows Vista, Windows 7, Windows Server 2003, Windows Server 2008 et Windows Server 2008 R2! Bref toutes les versions qu'un jeune entre 20 et 30 ans a utilisé pendant une longue période de sa vie!
Mais bon, voyons le bon coté des choses, on a réussi à découvrir cette faille lorsqu'elle a eu 17 ans, heureusement, car dans un an ça serait devenue une ... faille majeure!!! :-)
Aucun patch n'est disponible (sauf désactivation de la VDM), moi j'ai un super patch pour vous: PASSEZ À LINUX, PASSEZ À UBUNTU!

ubugnu

Un seul paquet: pdftk il vous permettra de manipuler des fichiers PDF à votre guise, voici quelques exemples de ce que vous pourrez faire:

Fusionner des fichier PDF
Diviser un ou plusieurs fichier PDF en des groupes de une ou plusieurs pages afin par exemple de les réarranger dans un nouveau fichier.
Faire pivoter une ou plusieurs pages
Décrypter/crypter des fichiers PDF
Appliquer un filigrane de fond ou un timbre/cachet d'avant-plan
Lire/écrire/changer le "metadata" d'un fichier PDF (auteur,date de création,...)
Attacher des fichiers à un fichier PDF ou à se pages
Depaqueter un fichier PDF (pour récupérer des images, figures, graphes,...)
Exploser un fichier PDF en toutes ses pages
Réparer un fichier PDF endommagé

Pour installer pdftk exécuter la commande

ubugnu@ubugnu-laptop:~$ sudo apt-get install pdftk

Voici quelques exemples d'utilisation:

Décrypter un fichier PDF en un fichier non crypté:

ubugnu@ubugnu-laptop:~$ pdftk secured.pdf input_pw foopass output unsecured.pdf

Crypter un fichier PDF:

ubugnu@ubugnu-laptop:~$ pdftk 1.pdf output 1.128.pdf owner_pw foopass

Fusionner deux fichiers PDF en un seul:

ubugnu@ubugnu-laptop:~$ pdftk in1.pdf in2.pdf cat output out1.pdf

Enlever une page d'un fichier PDF

ubugnu@ubugnu-laptop:~$ pdftk in.pdf cat 1-12 14-end output out1.pdf

Réparer un fichier PDF

ubugnu@ubugnu-laptop:~$ pdftk broken.pdf output fixed.pdf

Exploser un fichier PDF en toutes ses pages:
```
ubugnu@ubugnu-laptop:~$ pdftk in.pdf burst
```

Récupérer la metadata d'un fichier PDF dans un fichier texte

ubugnu@ubugnu-laptop:~$ pdftk in.pdf dump_data output report.txt

Pivoter une page de 90° (dans cet exemple la première page dans le sens des aiguilles d'une montre)
```
ubugnu@ubugnu-laptop:~$ pdftk in.pdf cat 1E 2-end output out.pdf
```

Voila il y a bien sure mille et une façon de faire tout ce que vous voulez grâce à la panoplie de fonctions et argument qu'offre cette commande, le meilleur moyen de trouver la bonne commande est bien sur de jeter un coup d'œil dans la doc

ubugnu@ubugnu-laptop:~$ pdftk -h

ou

ubugnu@ubugnu-laptop:~$ man pdftk

dimanche 24 octobre 2010

mercredi 20 octobre 2010

Create your Google Code project:

Connect to the project via svn and host files on Google by synchronizing the project directory with a local directory

Changing the mime-type of files depending on their format:

Créer son projet Google code:

Se connecter au projet via svn et héberger ses fichiers sur Google en synchronisant le répertoire du projet avec un répertoire local

Changer le mime-type des fichiers selon leur format:

lundi 18 octobre 2010

vendredi 15 octobre 2010

samedi 9 octobre 2010

jeudi 26 août 2010

mercredi 16 juin 2010

lundi 14 juin 2010

vendredi 11 juin 2010

lundi 3 mai 2010

dimanche 18 avril 2010

samedi 10 avril 2010

Coté Serveur:

Coté client:

Retour au serveur:

Sur le serveur:

Sur le client:

jeudi 8 avril 2010

mercredi 7 avril 2010

mercredi 31 mars 2010

mardi 23 mars 2010

lundi 22 mars 2010

dimanche 21 mars 2010

Installation:

mardi 2 mars 2010

mardi 16 février 2010

samedi 23 janvier 2010

vendredi 22 janvier 2010