TL;DR;

En complément : http://stackoverflow.com/questions/3146798/why-do-people-put-code-like-throw-1-dont-be-evil-and-for-in-front-of

Via SebSauvage http://sebsauvage.net/links/?lKi0mA

Dans la série "les problèmes que j'ai rencontrés, et qu'avoir la solution est bien pratique", je présente le problème du "parse new line" :

Concrètement, imaginez que vous devez, pour X ou Y raisons, "analyser" (venant de l'anglais "to parse" http://translate.google.fr/translate_t?q=to+parse) les "retours à la ligne" ("new line") pour les modifier en d'autres caractères (comme '\n', textuellement), un simple "sed 's/\n/mon_texte/g'" ne fonctionnera.

Ainsi, merci à StackOverFlow pour la réponse suivante :
sed ':a;N;$!ba;s/\n/mon_texte/g' mon_fichier.txt

Je copie simplement ici l'explication (principalement au cas où le lien meurt) :

This will read the whole file in a loop, then replaces the newline(s) with a space.

1. create a label via :a
2. append the current and next line to the pattern space via N
3. if we are before the last line, branch to the created label $!ba ($! means not to do it on the last line (as there should be one final newline)).
4. finally the substitution replaces every newline with a space on the pattern space (which is the whole file).

Il existe aussi tr :
tr '\n' ' ' < mon_fichier.txt

Mais tr ne remplace que par un SEUL caractère ... dommage.

Pour ceux qui veulent en savoir plus, un commentaire un peu plus bas explique bien mieux http://stackoverflow.com/a/7697604

Si comme moi -- j'étais jeune et insouciant … -- vous ne comprenez pas pourquoi certaines de vos règles iptables ne fonctionnent pas (celles qui n'arrivent pas à bloquer certains maudits botnets qui continuent toujours et encore de vous spammer le port SSH), voici le rappel de la règle d'or d'iptables -- et d'autres outils utilisant les ACL mêmes -- et une commande en bash pour pouvoir ban simplement et facilement une adresse IP :

La règle d'or, c'est celle-ci :
les règles sont lues de haut en bas, et dès qu'une règle correspond à aux informations du paquets, iptables redirige vers la cible. POINT.

Alors, ce n'est pas forcément clair tout de suite, mais on va détailler avec un exemple :

Disons qu'à l'heure actuelle, vous aviez cette configuration :

iptables --list --numeric --verbose (ou -L -nv)

Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
5771 442K ACCEPT all -- lo 0.0.0.0/0 0.0.0.0/0
771K 99M ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED
0 0 DROP all -- 1.2.3.4 0.0.0.0/0
0 0 DROP all -- 8.8.8.8 0.0.0.0/0
69993 5147K fail2ban-SSH tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:22
5765 483K ACCEPT icmp -- 0.0.0.0/0 0.0.0.0/0
2107 118K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:22
432 458K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:25
51 2604 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:80
0 0 REJECT all -- * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
0 0 REJECT all -- 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited

Chain OUTPUT (policy ACCEPT 5 packets, 820 bytes)
pkts bytes target prot opt in out source destination

Chain fail2ban-SSH (1 references)
pkts bytes target prot opt in out source destination
69914 5142K RETURN all -- 0.0.0.0/0 0.0.0.0/0

Je ne vais pas détailler ici les différentes règles, ce sont celles de base, plus fail2ban pour SSH.

Disons que vous souhaitez bloquer l'adresse IP 16.32.64.128 ; sur le web, on trouve :
iptables -A INPUT -s 16.32.64.128 -j DROP

Pour un résultat :
…
432 458K ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:25
51 2604 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 ctstate NEW tcp dpt:80
0 0 REJECT all -- 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
0 0 DROP all -- 16.32.64.128 0.0.0.0/0

Chain FORWARD (policy ACCEPT 0 packets, 0 bytes)
…

Or, problème : si la machine derrière l'IP 16.32.64.128 tente de se connecter au service web, sur le port 80, la 9ème règle répondra donc d'abord à la requête avec la 11ème (en dernière place donc), qui, cette dernière, spécifiait de bloquer complètement tout le trafic en provenance.
Conclusion, c'est l'échec.

Pour résoudre ça, il faut donc que notre nouvelle règle se retrouve avant d'autres règles qui joueraient en sa faveur.

Cette solution existe : c'est l'option --insert (-I, --insert chain [rulenum] rule-specification), à la place de --append (-A),
avec [rulenum] qui indique le numéro de la ligne où la nouvelle règle s'écrira avant (man 8 iptables explique bien mieux que moi).

Du coup, oubliez "iptables -A INPUT -s 16.32.64.128 -j DROP", et faites place à "iptables -I INPUT 3 -s 16.32.64.128 -j DROP"
avec "3", la position de la nouvelle règle, donc juste après "771K 99M ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED". (à adapter à vos besoins bien sûr !)

Ainsi, pour se simplifier la tâche, nous pouvons donc créer cette fonction en bash pour ainsi BAN simplement une adresse ip :

function ban() {
mode=${2:-"DROP"}
iptables --table filter --insert INPUT 3 --source $1 --jump $mode
}

et ça fonctionne comme ça :

ban ip_à_ban

Simple, non ?

Bien sûr, ceux qui l'ont remarqué peuvent spécifier une deuxième option (nommée mode), qui par défaut est DROP, comme REJECT, voire ACCEPT même ; ainsi, en spécifiant ACCEPT, vous pouvez de cette façon autoriser complètement une adresse IP, la vôtre par exemple, lorsque sur un serveur distant, vous voulez ne pas être bloqué par votre firewall ;) (tout le contraire de ban ^^')

C'est magique ! :D

Ah ! Voilà une bonne nouvelle !

Moi qui souhaitait ce FS pour pouvoir l'utiliser sur mes supports amovibles, sur du multi-plateforme, et qui permet d'avoir des tailles de fichier supérieurs à 4Gio (== 2³²), voilà une bonne nouvelle :)

(Maudit Microsoft qui fait exprès de n'implémenter que ces propres FS, juste pour éviter de voir ces "utilisateurs" partir …)

Je trouve que c'est un article très intéressant sur le principe de description d'une image.

Le langage Python étant vraiment agréable, ça me tenterait bien.

Effectivement, ces compteurs électriques dits "intelligents" (c'est vraiment à la mode ce mot) offrent bien des avantages, sur la gestion du réseau électrique, ce qui dans le futur (et dès à présent) est vitale pour une consommation intelligente de l'énergie.

Mais voilà, comme expliqué en détails dans l'article, cet outil peut être un vrai mouchard ; et puis tout ce qui concerne des données transitant par le réseau, il doit y avoir de la sécurité derrière, sinon bonjour les dégâts …

Et un dernier point, je vois mal comment la CNIL peut réellement vérifier les données récoltées par ces boîtiers …

MàJ 2013-09-25: UFC-Que Choisir voit ces nouveaux compteurs d'un mauvais œil. http://links.thican.net/?gtFMNA

Wow, 2,2 millions de Gigaoctets dans 1 gramme d'ADN, ça fait rêver. :-)

Bon, bien sûr, ce n'est pas pour tout de suite qu'un particulier pourra écrire et décoder de l'ADN dans son ordinateur de salon, mais, dans le futur, pourquoi pas …

Toujours agaçant de rechercher cette information, alors je vais la mettre ici :

NOTE : Avec la version d'iptables 1.4.16.3 (en tout cas, supérieur à 1.4.12), le module "state" (par exemple dans "--match state --state <state>") devient obsolète, et est donc remplacé par le module "conntrack", donc pour équivalent, faites --match conntrack --ctstate <state> (voir iptables-extensions(8)). Ainsi, je mets donc les commandes pour la nouvelle version.

L'interface reliée au net sera notée WAN, et celle qui permet donc de relier les machines qui n'ont pas accès au net, sera appelée LAN.

--table nat --append POSTROUTING --out-interface WAN --jump MASQUERADE
--table filter --append FORWARD --in-interface WAN --out-interface LAN --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT
--table filter --append FORWARD --in-interface LAN --out-interface WAN --jump ACCEPT

Ah oui, et bien sûr, il faut activer le transfert de paquets :
Pour du temporaire, jusqu'au prochain reboot : echo 1 > /proc/sys/net/ipv4/ip_forward
Mais sinon, ça se passe dans /etc/sysctl.conf : net.ipv4.ip_forward = 1
(Remarquez la ressemblance entre la hiérarchie net/ipv4/ip_forward et la variable net.ipv4.ip_forward, cela peut vous donner des idées sur certaines config si vous ne trouvez pas d'infos sur le web ;))

Article de Wikipedia : https://en.wikipedia.org/wiki/Network_Address_and_Port_Translation
Autre source, utilisant les mêmes règles : https://serverfault.com/questions/431593/iptables-forwarding-between-two-interface#431607

Pour ceux qui sont intéressés par le Python, ce guide de bonne écriture pourrait leur permettre de mieux réussir leurs projets.

Bon, par contre, je reste récalcitrant : Ce sera toujours des tabulations chez moi, et puis c'est tout !
Ça a l'avantage de prendre moins de place, et aussi de pouvoir sans modifier le code la taille que l'on souhaite.
Et avec les espaces, on fait rapidement des erreurs.

Tiens, une liste d’événements astronomique en 2013 (je me disais bien avoir vu Jupiter récemment).

Vidéo bien faite, j'ai bien aimé.

Générateur off-line de QR-code.

(Via Timo http://lehollandaisvolant.net/?mode=links&id=20130116191736)

Cet article nous rappelle (ou fait découvrir pour certains) que Google est omniprésent dans le web, et envahit de plus en plus notre vie numérique, ce qui par conséquent, donne accès à Google une quantité incroyable de données au sujet de notre vie, pour en faire de l'argent.

Mais malheureusement, il n'est pas simple de quitter Google : le meilleur exemple étant les smartphones, avec Android préinstallé, et la concurrence en ce jour est quasi inexistante (IOS pour les produits de chez Apple, et sinon, des miettes de marché pour les autres).

Bref, il est difficile de nos jours de faire comprendre que le web ne se résume pas à quelles grandes entreprises.

@TODO
Franchement, ça me serait bien pratique, car mutt en ligne de commande, c'est bien, mais bon …
(Encore mieux, ce serait de faire ça en IMAP, pour pouvoir les lire avec un vrai client :-D)

~% mkdir temp
~% cd temp
~/temp% echo le fichier caché > .cache
~/temp% echo le fichier normal > normal
~/temp% tar -cvf ~/archive_dossier.tar .
./
./.cache
./normal
~/temp% tar -cvf ~/archive_etoile.tar *
normal

Déjà, on voit que le fichier .cache N'est PAS archivé.

~/temp% tar -tvf ~/archive_dossier.tar
drwxr-x--- thican/thican 0 2013-01-08 19:17 ./
-rw-r----- thican/thican 18 2013-01-08 19:17 ./.cache
-rw-r----- thican/thican 18 2013-01-08 19:17 ./normal
~/temp% tar -tvf ~/archive_etoile.tar
-rw-r----- thican/thican 18 2013-01-08 19:17 normal

Oui, on vient de confirmer que les fichiers cachés NE sont PAS archivés.

Mais il y a autre chose de différent : le dossier actuel.

~/temp% mkdir ~/temp_dossier
~/temp% ls -ld ~/temp_dossier
drwxr-x--- 2 thican thican 6 8 janv. 19:21 ~/temp_dossier/
~/temp% chmod o=rX ~/temp_dossier
~/temp% ls -ld ~/temp_dossier
drwxr-xr-x 2 thican thican 6 8 janv. 19:21 ~/temp_dossier/
~/temp% cd ~/temp_dossier
~/temp_dossier% tar -xvf ~/archive_dossier
./
./.cache
./normal
~/temp_dossier% ls -la
total 12
drwxr-x--- 2 thican thican 32 8 janv. 19:17 ./
drwxr-x--x 16 thican thican 4096 8 janv. 19:22 ../
-rw-r----- 1 thican thican 18 8 janv. 19:17 .cache
-rw-r----- 1 thican thican 18 8 janv. 19:17 normal

Tiens tiens, les droits sur le dossier actuels ont changés !

~/temp_dossier% mkdir ~/temp_etoile
~/temp_dossier% ls -ld ~/temp_etoile
drwxr-x--- 2 thican thican 6 8 janv. 19:23 ~/temp_etoile/
~/temp_dossier% chmod o=rX ~/temp_etoile
~/temp_dossier% ls -ld ~/temp_etoile
drwxr-xr-x 2 thican thican 6 8 janv. 19:23 ~/temp_etoile/
~/temp_dossier% cd ~/temp_etoile
~/temp_etoile% tar -xvf ~/archive_etoile.tar
normal
~/temp_etoile% ls -la
total 8
drwxr-xr-x 2 thican thican 19 8 janv. 19:24 ./
drwxr-x--x 17 thican thican 4096 8 janv. 19:24 ../
-rw-r----- 1 thican thican 18 8 janv. 19:17 normal

Et là non, les droits N'ont PAS changés.

Bref, "tar ." et "tar *" sont bels et biens différents.

Intéressant.

Franchement, du bon travail !

Bien pratique, tant que GoGole ne change encore une fois ses codes.

(via Sebsauvage : http://sebsauvage.net/links/?ReREvA)

Des petits détails qui font toute la différence ; vous faciliterez ainsi l'expérience utilisateur, et même pour vous (pour éviter les contre-sens).

En résumé, lorsque vous en avez la possibilité, créer des boutons avec un verbe, une action, et dans le champ texte, décrivez l'action qui va se produire selon le choix. Donc, plus besoin de mettre une question, et donc on évite les erreurs de compréhensions ou d'habitudes (regardez les exemples, ce sera plus simple).