Vérifiez que la valeur de la variable "UserspaceHID" soit sur "true" dans le fichier "/etc/bluetooth/input.conf".

Pour commencer, oui, l’arithmétique des pointeurs dans la programmation actuelle, et globalement l’utilisation du langage C, est quelque chose de plus en plus rare, car la majorité des langages sont dits de haut niveau, ils font abstraction du code machine, et leur typage est dynamique.

Toutefois, le langage C a certains atouts (pas de démonstration, ce n’est pas le but de ce billet), et il est ainsi important de produire du code robuste et modulable.

Prenons le cas où vous devez manipuler à travers les paramètres d’une fonction :

• des listes (une dimension) ;
• des matrices/tableaux (deux dimensions) ;
• des volumes (trois dimensions) ;
• voire autant de profondeurs de pointeurs dont vous avez besoin (x dimensions).

(Exemple et démonstration plus bas)

Pour une allocation de mémoire sur une variable faites à partir de pointeurs d’objets, le comportement est :

mytype *my_variable;
my_variable = malloc(sizeof(mytype));

Mais ensuite, si ce n’est plus un seul niveau de pointeurs, mais plusieurs, il faut donc calculer le nombre de pointeurs à mettre : combien d’astérisques à écrire ? est-ce vraiment utile, i.e "void *" ne suffit-il pas ? ce nombre a-t-il un impact ?
Et si on change de type ? par exemple, à l’intérieur d’une structure, vous ne déclarez pas la variable, du coup, il faut aller chercher le type de la variable en question, ce qui n’est pas forcément facile, et si ça change, vous devez manipuler le code.

Voici une solution : utilisez l’idiomatique suivante :

my_var = malloc(sizeof(*my_var));

Il suffit de remarquer qu’il suffit simplement de rajouter un astéristique par rapport à la variable dans le paramètre de gauche, dans le contenu de l’appel sizeof, et c’est tout.

Exemple, vous avez une matrice de "choses", chose pouvant être un entier, un nombre à virgule, un pointeur, une structure, etc, mais que c’est une donnée ici d’un des paramètres de la fonction, voici le résultat :

void myFunction(mytype my_var) {
…
my_var = malloc(sizeof(my_var));
…
}

void main(void) {
mytype **myMatrix;
myFunction(&myMatrix);
…
}

Exemple et Situation :

Prenons le cas où vous avez déjà une liste d’objets, comme une liste de sommets (“vertex/vertices” en anglais) dans un graphe (“graph”) contenant un nombre important de paramètres et d’informations. Recopier le contenu alors que vous souhaitez manipuler l’objet pour lire et créer d’autres ensembles n’est pas le plus efficace, la mémoire s’en alourdi : il suffit d’appeler le pointeur sur l’objet en question.

Déterminons les enfants d’un sommets dans un graphe, avec les arêtes qui les relient (“edge” en anglais) ; on va donc à partir d’un graphe "g" et d’un sommet "v" recevoir une liste de sommets "listChildren", et le nombre d’éléments de cette liste. Comme indiqué en introduction, on ne cherche pas à recopier les données, mais on cherche à recevoir leurs pointeurs. Pareil pour les éléments passés en paramètres en tant que source d’informations.

Remarque : j’évite au maximum d’avoir des variables globales, et je mets en premier dans les paramètres d’une fonction les données qui seront modifiées.
Remarque : pour simplifier la lecture, on pourrait aussi utiliser un “typedef” pour parler de pointeurs sur les différents objets, comme "pgraph" = "graph ", "pvertex" = "vertex ", etc, mais ça devient lourd à utiliser, et ce n’est pas entièrement pratique si on ne l’utilise pas entièrement.

Nous avons en entrée :

• un "graph my_graph" ;
• un "vertex current_vertex" ;
• une liste de pointeurs de sommets "vertex **my_child" ;
• et une valeur de retour, "int nb_children".

La liste des paramètres de la fonction "childrenVertices" ainsi se compose :

• pour le graphe "g" : graph *g ;
• pour le sommet "v" : vertex *v ;
• pour la liste de sommets, nous allons modifier son contenu, il faut rajouter un pointeur dessus : "vertex ***list_children" ;
• et le paramètre de retour sera un entier "int".

int childrenVertices(vertex **list_children, graph g, vertex *v);

À l’intérieur, l’allocation mémoire pour "list_children" sera :
list_children = malloc(nb_vertices sizeof(**list_children));

et son appel sera :
nb_children = childrenVertices(&my_child, &my_graph, &current_vertex);

En conclusion, la fonction "childrenVertices" ne manipule que des pointeurs, ce qui économise beaucoup plus de place par rapport à des données dans des structures (sauf pour les petits types, comme les entiers, qui sont moins volumineux dans une architecture 64 bits (4 octets, soient 32 bits pour un entier relatif "int") que pour un pointeur, 8 octets soient 64 bits en archi 64 bits.

Sauvegarde ici, car oh punaise, je le sens venir, les problèmes que je vais devoir corriger avec cet OS … Si ça ne tenait qu’à moi, je n’y toucherai tout simplement pas.

-------- BEGIN --------
Activer le God Mode : GodMode.{ED7BA470-8E54-465E-825C-99712043E01C}

Lister et Supprimer des applications (Powershell) :
Get-AppxPackage -User UTILISATEUR
Remove-AppxPackage NOMCOMPLETDUPACKAGEADESINSTALLER

Désactiver les fonctions indiscrètes :
Logiciel : Disable Windows 10 Tracking - https://github.com/10se1ucgo/DisableWinTracking/releases
Logiciel : Destroy Windows 10 Spying - https://github.com/Nummer/Destroy-Windows-10-Spying
Logiciel : O&O ShutUp10 - http://www.oo-software.com/en/shutup10 (http://www.libellules.ch/dotclear/index.php?post/2015/11/07/OO-ShutUp10)

Le dossier windows 10 de libellules.ch : http://www.libellules.ch/dotclear/index.php?category/Windows-10

De nombreux articles sur Windows 10 par niko{pik} : http://www.nikopik.com/?submit=&s=windows+10

• http://www.theverge.com/2015/8/23/9191989/windows-privacy-and-you

src : http://korben.info/windows-10-activez-le-mode-god.html
src : http://korben.info/windows-10-comment-desinstaller-candy-crush-ou-dautres-applications-qui-pre-installees.html
src : http://korben.info/windows-10-un-freeware-pour-desactiver-toutes-les-fonctionnalites-un-peu-trop-curieuses.html
src : http://www.libellules.ch/dotclear/index.php?post/2015/08/09/DoNotSpy-10
src : http://korben.info/windows-10-comment-reprendre-le-dessus.html
src : http://www.nikopik.com/2015/08/des-sites-de-telechargement-bannissent-les-utilisateurs-de-windows-10.html
src : http://www.nikopik.com/2015/08/loutil-de-telemetrie-de-windows-10-debarque-aussi-sur-windows-7-et-8-1-via-une-mise-a-jour.html
-------- END --------

Le post en lui-même n'est pas important, mais c'est plutôt les explications et bidouilles sur le système de fichiers derrière /proc.

À savoir, /proc/<pid>/exe est un lien symbolique vers le chemin de l’exécutable, sauf ça reste être un "fd" (file descriptor) tant que le processus n'est pas terminé, ce qui permet de continuer d'exécuter le processus même si son programme n'est plus (virtuellement) sur le disque dur (un fichier n'est pas supprimé tant que des références vers ce fichier sont ouvertes).

Un document en français contenant une liste d'astuces pour modifier les paramètres de télémétrie et de vie privée dans Windows 10.

Sauvegarde au format PNG (avec les commentaires, malheureusement) https://thican.net/~thican/windows_10_debloating_guide-fr.png (2,7 Mo, 1909 x 19068)

Par défaut, Microsoft Windows ne gère pas l'heure en UTC dans le BIOS, rendant la cohabitation difficile entre ce système d'exploitation et un autre.
Pour ma part, j'avais donc l'heure en UTC dans le BIOS, mais j'avais mis UTC dans Windows, ce qui du coup ne m'affichait pas l'heure correctement.

Et pourtant, il existe un « hack », une très simple modification à faire dans le registre pour résoudre ce problème :

• Exécutez l'éditeur de Registre en tant qu'administrateur,
  • détails : "Tous les programmes" → "Accessoires" → clic-droit sur "Invite de commandes" et cliquez sur "Exécuter en tant qu'administrateur", puis, dans la nouvelle fenêtre, tapez "regedit.exe" et appuyez sur "Entrée".
• une fois dans l'éditeur, suivez les dossiers "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation",
• dans ce dossier, créez une nouvelle entrée de type DWORD, nommez-la "RealTimeIsUniversal", et entrez-y la valeur "1",
• redémarrez, ça y est !

Profitez donc du redémarrage pour mettre l'heure en UTC dans le BIOS, indiquez ensuite le bon fuseau horaire, et c'est tout.

Source : un peu partout sur le web.

Si vous avez besoin de bibliothèques en « 32 bits » (dites x86_32) alors que votre système est en x86_64 multilib (amd64), voici un petit tutoriel, très simple à utiliser et qui fonctionne :
1) commencez par exécuter : echo '-abi_x86_32' >> /etc/portage/profile/use.mask
2) lancez la compilation avec ABI_X86="32" en début de ligne :
ABI_X86="32" emerge -vaN1 libX libY libZ

S'il vous arrive souvent d'utiliser votre ordinateur alors qu'il fait nuit, et que vous resentez de la fatigue visuelle (ou même en tant que prévention), découvrez le logiciel RedShift.

Le but de ce petit billet n'est pas concrètement de vous faire découvrir ce logiciel, mais de vous aider à le configurer, pour être fonctionnel rapidement. Les infos sont bien sûr écrites dans le man, mais en attendant de le lire, vu que l'interface graphique est très loin d'être “user-friendly”, voici comment faire :

Avant d'écrire la configuration, il faut déterminer vos coordonnées ; c'est à partir de ces infos que le logiciel changera la « température » des couleurs pour s'adapter à votre environnement. Utiliser donc votre GPS, ou des cartes en ligne comme OpenStreetMap voir Google Maps pour trouver vos coordonnées, c'est à dire la longitude et la latitude.

Avec vos coordonnées, nous allons écrire le fichier de configuration. En se basant sur l'exemple du man, nous allons écrire notre configuration dans ~/.config/redshift.conf :
[redshift]
temp-day=6500
temp-night=3600
location-provider=manual

[manual]
lat=votre_latitude
lon=votre_longitude

Remplacez donc les valeurs votre_latitude et votre_longitude par vos coordonnées. Les valeurs de temp-day et temp-night sont comme elles l'indiquent les « températures » des couleurs de votre écran à utiliser respectivement pendant la journée et pendant la nuit. La valeur 6500K est la température par défaut, sans programme ; pour la soirée, par défaut la valeur est 3600K. Personnellement, je baisse cette valeur à 5700K en journée et à 2700K pendant la nuit.
Comme vous pouvez le remarquer, la valeur 2700K fait sortir visiblement la couleur orange sur les fonds clairs, et quand c'est chaud, c'est bleu. On pourrait penser que c'est contraire à la vie de tous les jours, or en haute température, le bleu est bien plus chaud que le rouge. c'est ce qu'on remarque avec les flammes des gaz.

Maintenant, vous pouvez exécuter le programme, et le mettre en démarrage automatique. Vos yeux vous remercieront.

Quelque chose que j'oublie souvent, alors autant l'avoir ici sous le coude.

Avec une liste d'adresses IPv4, donc sous la forme W.X.Y.Z, chacun pouvant aller de 0 à 255 inclus, sort peut en utilisant ses options mettre dans l'ordre une telle liste :
sort --numeric-sort --field-separator=. --key=1,1 --key=2,2 --key=3,3 --key=4,4

(source : un peu partout sur le net)

Un DIY (Do It Yourself) pour rendre une maison isolée du point de vue de l'énergie électrique, ça fait rêver :-)

11 000 € pour l'ensemble des appareils pour créer l'électricité, ça me paraît raisonnable, mais je me demande si être complètement isolé n'est pas un risque trop élevé, et si ça vaut le coup niveau budget.

Quelques astuces en CSS, en fin de compte très simple, pour centrer correctement des blocks en CSS.

Wouah, mais c'est trop génial ce hack :-)

Cette personne nous montre pas à pas comment elle a modifié et contourné un disque dur pour faire fonctionner une distribution GNU/Linux sur sa partie électronique.

Le saviez-vous ?
PHP – comme d'autres langage – lors de l'évaluation de conditions booléennes, fonctionne en mode "évaluation minimale" (ou appelé "short-circuit evaluation" en anglais http://en.wikipedia.org/wiki/Short-circuit_evaluation).
Grâce à l'ordre des opérateurs booléens, cela permet de ne pas tester l'ensemble des expressions dans une condition.

Exemple :
A && B && C
avec l'opérateur "&&" (AND), B n'est testé que si A est "juste", et C n'est testé que si B est "juste" (sans oublier A).

Par contre, avec "||" (OR), dans l'exemple "A && B || C", c'est "B || C" qui est testé avant A (attention, ce n'est pas valable pour tous les langages), et il faut que B soit "faux" pour que C puisse testé.

Intéressant, une extension pour Firefox qui permet à sa guise d'activer le "http referer".

Pour info, le "http referer" est une donnée contenant l'url de la page actuelle, envoyée par défaut dans les en-têtes HTTP (les requêtes web), et qui a donc pour principale but d'indiquer la page de provenance, pour tracer ou pour éviter certains accès.

(via Mistukarenai http://root.suumitsu.eu/links/?6HSeuA)

Vous utilisez souvent GnuPG pour chiffrer du texte, mais vous voulez vous simplifier la tâche lorsque vous devez utiliser vim avec, et aussi rajouter un peu de sécurité ?
Voici donc le plugin gnupg.vim.

Lorsque je parle de "sécurité", le plugin d'après son auteur désactive des fonctionnalités de vim comme swapfile, viminfo, et undofile, ce qui permet d'éviter de lire les données écrites du fichier en lisant son fichier temporaire, par exemple.

EDIT: le script est disponible sur GitHub, ce qui permet de vérifier son intégrité https://github.com/jamessan/vim-gnupg

EDIT2 (2013-07-31): il est disponible en tant qu'ebuild sous Gentoo \o/ → app-vim/gnupg

Suite à mon petit article (https://links.thican.net/?OIlYuQ) sur le même principe (des requêtes HTTP), mais en utilisant telnet, voici donc une autre version bien plus propre, avec curl.

Pour rappel :
Utilisons donc quelques variables pour simplifier les envois (c'est du bash, au fait)

• host : c'est le nom de domaine du site web à contacter (pour utiliser avec la variable HOST),
• port : le port du serveur distant (port 80 très souvent, doit être un nombre entre 1 et 65 535 inclus),
• url : l'url de la page web à joindre, (sous la forme "/index.html", avec un '/' au début),
• getVars et postVars : la suite de variables qui vont être envoyées au serveur web, dans les requêtes GET et POST. (ces infos doivent être sous la forme "name=toto&code=2&update&field=text") ; dans une requête GET, postVars sera ignorée.

Attention : la variable "host" est obligatoire (le port est par défaut à "80" si la variable est vide).

Requête GET : curl --include http://${host}:{port:-80}/${url}?{getVars}
Requête POST : curl --include --data ${postVars} http://${host}:{port:-80}/${url}?{getVars}

That's it!

Concrètement, la différence entre telnet et curl, elle se réside uniquement dans votre démarche d'apprentissage et de compréhension.
Si vous voulez apprendre, modifier des données pour faire des tests, avoir un contrôle un peu plus poussé sur vos données, utilisez donc telnet.
Par contre, si vous voulez quelque chose qui fasse son boulot, simplement, avec le moins d'erreurs possible car maintenu à jour, sans prise de tête, tournez donc vers curl.

EDIT: une méthode, plus simple et plus "propre" à utiliser, avec curl : http://links.thican.net/?wGhHkw

Si vous avez besoin de tester un serveur web sans utiliser un navigateur web (pour ainsi mieux voir ce qui est concrètement reçu et envoyé), voici un début d'aide :

On va donc utiliser telnet, un logiciel qui permet simplement de se connecter à une machine distant, sur le port souhaité, et d'envoyer simplement des paquets TCP.
Utilisons donc quelques variables pour simplifier les envois (c'est du bash, au fait)

• host : c'est le nom de domaine du site web à contacter (pour utiliser avec la variable HOST),
• port : le port du serveur distant (port 80 très souvent, doit être un nombre entre 1 et 65 535 inclus),
• url : l'url de la page web à joindre, (sous la forme "/index.html", avec un '/' au début),
• getVars et postVars : la suite de variables qui vont être envoyées au serveur web, dans les requêtes GET et POST. (ces infos doivent être sous la forme "name=toto&code=2&update&field=text") ; dans une requête GET, postVars sera ignorée.

Attention : la variable "host" est obligatoire (le port est par défaut à "80" si la variable est vide).

Pour les requêtes GET, voici donc :
{ echo -n -e "GET /${url}?${getVars} HTTP/1.1\nHOST: ${host}:${port:-80}\n\n"; sleep 0.5 } | telnet ${host} ${port:-80}

Pour les requêtes POST, il faut rajouter l'info de la variable "Content-Type: application/x-www-form-urlencoded" (attention, d'après cette page http://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data s'il s'agit d'autres formes de données, mieux vaut modifier le contenu de cette variable), voici donc :
{ length=$(echo -n ${postVars} | wc -c --); echo -n -e "POST /${url}?${getVars} HTTP/1.1\nHOST: ${host}:${port:-80}\nContent-Type: application/x-www-form-urlencoded\nContent-Length: ${length}\n\n${postVars}"; sleep 0.5 } | telnet ${host} ${port:-80}

Voilà, c'est tout, simple non ? ;-)

Remarques :

• "Pourquoi le temps de pause dans telnet (sleep 0.5) ?"
  Pour des raisons qui m'échappent, telnet va semble-t-il trop vite, et il envoit donc un paquet TCP avec le flag "RST" (Reset), ce qui coupe court le serveur distant, ainsi que l'affichage (même si le serveur distant a envoyé les données, telnet ne les affichera pas). Du coup, il se peut que vous tomber sur ce problème, si le serveur distant est long à répondre (grosse requête, trop de trafic, etc.), il faut donc augmenter le temps de pause.
• "Pourquoi mettre un '/' en plus au début dans l'URL ("GET /${url}") ?"
  Les '/' en doublon ne sont normalement pas gênants pour accéder à une ressource (essayez donc des URL avec une suite de '/', ça ne devrait pas poser problème). Effectivement, si le serveur distant ne gère pas correctement ces '/' doublons, il risque de râler, mais en tout cas, si le premier '/' est manquant (exemple "GET index.html"), là, c'est sûr, la requête est mauvaise. Donc, autant en mettre trop que pas assez. ;-)

Résumé :

• signe de ponctuation à « un seul signe » '(' ',' '.' ')', pas d'espace avant,
• signe de ponctuation à « deux signes de ponctuation » '?' ';' '!', un espace avant, et insécable,
• l'apostrophe et le trait d'union, pas d'espace ni avant ni après.

Petite page d'introduction pour chiffrer et signer des courriels dans Mutt à l'aide de GnuPG.