Désactivé TLS 1.0 sur Windows Server

Selon le PCI Security Standards Council il serait recommandé de migrer du protocole Transport Layer Security (TLS) version 1.0 vers une version plus récente et cela pour le 30 juin 2018. Présentement, sur mon site web qui roule sous Windows Server 2012 R2, TLS 1.0 est encore disponible.

Dans un article précédent j’avais expliqué comment augmenter la sécurité d’un site web. Celui-ci sera similaire, sauf qu’au lieu d’aller éditer le registre de Windows directement, le logiciel IIS Crypto sera utilisé. Cela va grandement simplifier la tâche.

Il suffit d’ouvrir l’application et de décocher TLS 1.0 dans la sections Protocols:

IIS Crypto 2.0
IIS Crypto 2.0 avec la case à cocher TLS 1.0 vide
Par la suite il faut cliquer sur le bouton Apply et redémarrer le serveur.

Pour vérifier que tout a bien fonctionné, on peut utiliser l’outil SSL Server Test de SSL Labs:

No TLS 1.0
TLS 1.0 n’est plus disponible

Voilà, maintenant votre serveur devrait être plus sécuritaire.

Intégrer Gogs à Jenkins

Gogs (Go Git Service) est une solution Git auto-hébergée codée en Go. Jenkins est un outil d’intégration continue programmé en Java. Ces deux projets à code source ouvert sont tous deux hébergés sur GitHub. Lorsque que combiné ensemble, ils permettent presque un cycle de développement logiciel complet.

Le type de projet à utiliser dans Jenkins est le Multibranch Pipeline car il est le mieux adapté à Git. C’est pourquoi que dans la section Branch Sources lorsque l’on clique sur Add source on doit choisir Git. Vous devez entrer le Project Repository, pour vous simplifier la tâche vous pouvez utiliser le bouton Copy de Gogs. Dans la section Behaviors, appuyez sur le bouton Add et choisissez l’option Configure Repository Browser. Dans la liste de Repository browser, il faut choisir gogs et entrer le URL de la page du projet. Cela fera en sorte qu’à plusieurs places dans Jenkins des liens vers Gogs seront ajoutés.

Liens vers Gogs
Le SHA1 sera un lien vers la soumission dans Gogs

Ceci conclut la première étape. La seconde consiste à pouvoir démarrer des tâches sur Jenkins suite à une soumission. Avant de quitter la page de configuration du projet, dans la section Scan Multibranch Pipeline Triggers on peut cocher l’option Periodically if not otherwise run. Cela va permettre une vérification du dépôt à tous les jours. C’est une protection au cas où Jenkins ou Gogs serait incapable d’effectuer la prochaine étape.

Dans Gogs il faut maintenant choisir votre dépôt et aller dans les Settings. Par la suite, on va dans la section Webhooks, on clique sur Add Webhook et on choisit Gogs.
Entrez ces paramètres:

  • Payload URL: http://jenkinsserver.com/git/notifyCommit?url=http://gogsserver.com/Org/Project.git
    • Org/Project.git = nom du dépôt utilisé dans Jenkins (sensible à la case)
  • Content Type: application/x-www-form-urlencoded
  • When should this webhook be triggered: Let me choose what I need.
  • Cocher les options suivantes:
    • Create
    • Delete
    • Push
  • Active doit être cocher

Pour terminer, appuyer sur le bouton Add Webhook.

Avec cette configuration les branches pourront être ajoutées et supprimées automatiquement dans Jenkins. Si vous avez un fichier Jenkinsfile inclus dans votre projet, les tâches ajoutées à celui-ci pourront être effectuées à chaque soumission. Malheureusement les requêtes de tirage (pull requests) ne fonctionnent pas.

Si vous avez besoin d’aide sur le plugin Git de Jenkins vous pouvez consulter cette page web.

Augmenter la sécurité d’un site web utilisant SSL

Dernièrement je me suis fais présenter l’outil SSL Server Test de SSL Labs. C’est une application en ligne qui permet de tester la sécurité d’une site web. J’avais récemment installé un certificat SSL sur le serveur d’un ami. Il s’agit d’un certificat généré gratuitement par Let’s Encrypt. Donc, je croyais bien obtenir une bonne note. Eh bien… non! J’ai obtenu la note de B.

Voici les deux problèmes qui me limitaient à cette cote.

  • This server supports weak Diffie-Hellman (DH) key exchange parameters. Grade capped to B.
  • This server accepts RC4 cipher, but only with older browsers. Grade capped to B.

Le site web est hébergé sur Windows Server 2012 R2. Donc les prochaines étapes pour régler ces problèmes de sécurité ont seulement été testées avec cette version de Windows. Si vous les appliquez, voici ce qui pourrait arriver:

Cote B vers A-
Cote B vers A-

A- ce n’est pas A ou même A+, mais c’est un bon départ.

Tous ces problèmes peuvent se régler dans l’Éditeur du Registre. On peut le démarrer avec la commande regedit.exe

Pour régler le problème avec Diffie-Hellman on doit aller dans la clef suivante:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SChannel\KeyExchangeAlgorithms
Si elle n’existe pas on doit créer la sous-clef Diffie-Hellman
Dans la clef Diffie-Hellman, on doit créer une valeur DWORD nommé Enabled dont la donnée est 0.

Maintenant passons à l’algorithme de chiffrement RC4 (Rivest Cipher 4) qui est désuet. On doit aller dans la clef suivante:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Ciphers
Il va ensuite falloir créer les trois sous-clefs suivantes: RC4 128/128, RC4 40/128 et RC4 56/128.
Pour chacune de ces clefs, on doit créer une valeur DWORD nommé Enabled dont la donnée est 0.

Registry Editor - SCHANNEL key
Éditeur du Registre – clef SCHANNEL

Vous pouvez maintenant fermer l’Éditeur du Registre et redémarrer votre serveur pour appliquer les modifications.

Si vous désirez annuler ces changements il suffit de mettre la valeur Enabled à 0xffffffff. Vous pouvez aussi simplement supprimer la valeur Enabled.

J’espère que cet article vous aidera à augmenter la sécurité de votre site en évitant d’exposer des méthodologies faibles ou insécures.

Utiliser Gogs comme un service Windows

Dans mon dernier article, j’avais expliqué comment démarrer MiNET comme un service Windows. On avait la chance que la fonctionnalité était intégrée à l’application. Par contre, ce n’est pas toujours le cas.

Cette fois-ci c’est l’application Gogs que j’aimerais utiliser comme service Windows. Gogs (Go Git Service) est une solution Git auto-hébergée codée en Go. Ce projet à code source ouvert hébergé sur GitHub a beaucoup de qualité, la plus grande étant sans doute sa facilité d’installation. Maintenant, il est temps de parler de l’un de ses défauts: il ne peut pas être installé nativement comme service Windows.

La documentation de Gogs nous dirige vers l’application NSSM pour palier à ce problème. NSSM (Non-Sucking Service Manager) se vante de ne pas être médiocre comme les autres outils de ce genre. L’application possède même une interface graphique pour installer, éditer ou supprimer un service créer à partir de NSSM. Par contre, dans cet article, c’est plutôt des lignes de commande que nous utiliserons.

En premier, il faut que le fichier app.ini de Gogs soit modifié pour que le paramètre RUN_USER porte le nom du PC. Pour connaitre le nom, vous pouvez utiliser la commande suivante:

echo %COMPUTERNAME%

Le fichier ini doit être modifié comme ceci:

RUN_USER = NOMDUPC$

Le signe de dollar à la fin du nom est important.

En second lieu, il faut s’assurer que NSSM a été installé dans votre %PATH%. Par exemple, le fichier nssm.exe peut être copié dans le dossier C:\WINDOWS\system32.

Ensuite, on ouvre une fenêtre de terminal et on tape toutes ces commandes:

set gogspath=c:\gogs
set escapepath=^%PATH^%
nssm install gogs "%gogspath%\gogs.exe"
nssm set gogs AppDirectory "%gogspath%"
nssm set gogs AppParameters "web"
nssm set gogs DisplayName "Gogs - Go Git Service"
nssm set gogs Description "A painless self-hosted Git service."
nssm set gogs Start SERVICE_DELAYED_AUTO_START
nssm set gogs AppStdout "%gogspath%\gogs.log"
nssm set gogs AppStderr "%gogspath%\gogs.log"
nssm set gogs AppRotateFiles 1
nssm set gogs AppRotateBytes 1000000
nssm set gogs AppEnvironmentExtra "PATH=%escapepath%;%gogspath%;C:\Program Files\Git\bin"
nssm start gogs

Il est important de changer la ligne 1 pour y inscrire le chemin vers l’application Gogs. La ligne 13 doit aussi être changée si Git n’est pas dans le %PATH%. La dernière ligne va démarrer le service, donc ouvrez un navigateur web et testez que tout fonctionne.

Si vous désirez supprimer le service, c’est cette commande qu’il faut utiliser:

nssm remove gogs

Pour éditer un service déjà installé avec l’interface on utilise cette commande:

nssm edit gogs
NSSM Details
Édition du service Gogs à l’aide de NSSM

En terminant, je veux vous parler de Gitea. Il s’agit d’un fork de Gogs qui semble avoir le vent dans les voiles. Pour l’instant, je préfère encore demeurer avec Gogs, mais je garde un œil attentif sur ce projet.

Utiliser MiNET comme un service Windows

Dans un article précédent j’avais parlé du serveur Minecraft MiNET. Le serveur est facile à démarrer, il suffit de double cliquer sur l’exécutable. Le problème c’est que je veux qu’il roule de façon continue sur mon serveur Windows 2012. Donc, il faut qu’il soit installé comme un service Windows. Cela va masquer la fenêtre de console et faire en sorte que l’application va démarrer même si aucun utilisateur n’est connecté.

Heureusement pour nous, MiNET utilise Topshelf, il s’agit d’une infrastructure logicielle permettant la conception de services Windows en utilisant .NET.

Pour obtenir de l’aide, rien de plus simple, on écrit ceci:

MiNET.Service.exe help

En ce qui a trait au service, voici les paramètres importants:

  • install
  • start
  • stop
  • uninstall

Les noms sont assez explicites et je crois qu’il ne demande pas vraiment d’explication. Donc, pour installer le service on tape ceci:

MiNET.Service.exe install

Les informations par défaut faisaient mon bonheur. Dans la capture d’écran suivante, on peut voir le résultat.

MiNET Service Properties
MiNET Service Properties

Il ne reste plus qu’à démarrer le service avec cette ligne de commande:

MiNET.Service.exe start

Amusez-vous bien à MineCraft en multi-joueurs.
Minecraft

Simuler des évènements de touche sur Android

Dans cet article nous allons voir comment simuler des évènements de touche sur Android dans une application FireMonkey codée en C++. Pour faire cela nous allons utiliser la classe Instrumentation de l’API Android. Malheureusement cette classe n’est pas exposée dans la RTL. La bonne nouvelle est qu’il existe un outil pour générer les fichiers qui nous sont nécessaires. C’est à l’aide de Java2OP.exe que nous allons y arriver. Cette application par ligne de commande sert à générer des fichiers Delphi à partir de bibliothèques Java, d’où le nom Java To Object Pascal (Java2OP).

Donc avec cette commande nous obtiendrons le fichier Androidapi.Instrumentation.pas :

Java2OP.exe -classes android.app.Instrumentation -unit Androidapi.Instrumentation

La première fois que j’ai exécuté la commande, une erreur est survenue me disant que JDK était manquant. En cas de problème, je vous conseille de vous référer à l’aide où il y a une section Dépannage.

Pour commencer, on doit démarrer RAD Studio et créer un nouveau projet multi-périphériques C++Builder. Nous allons insérer un TMemo dans la Form. C’est dans ce contrôle que les touches de clavier simulées apparaitront. On doit bien sûr ajouter le fichier Androidapi.Instrumentation.pas au projet. À la compilation le fichier Androidapi.Instrumentation.hpp sera créé.

La simulation de touche de frappe doit se faire dans un thread, donc il faut aller dans le menu File / New / Other… et choisir Thread Object dans la section C++Builder Files. Vous pouvez donner le nom TInjectInput à la classe. Vous pouvez enregistrer le fichier et le nommer InjectInput.cpp. Dans ce fichier, il faut ajouter les en-têtes suivantes:

#include <Androidapi.JNI.GraphicsContentViewText.hpp>
#include "Androidapi.Instrumentation.hpp" // Fichier généré par Java2OP.exe

Dans l’évènement Execute on ajoute le code suivant:

    while(Terminated == false)
    {
        try
        {
            _di_JInstrumentation Instrumentation = TJInstrumentation::JavaClass->init();

            Graphicscontentviewtext::_di_JKeyEvent KeyEventDown = TJKeyEvent::JavaClass->init(
                TJKeyEvent::JavaClass->ACTION_DOWN, TJKeyEvent::JavaClass->KEYCODE_A);
            Instrumentation->sendKeySync(KeyEventDown);

            Graphicscontentviewtext::_di_JKeyEvent KeyEventUp = TJKeyEvent::JavaClass->init(
                TJKeyEvent::JavaClass->ACTION_UP, TJKeyEvent::JavaClass->KEYCODE_A);
            Instrumentation->sendKeySync(KeyEventUp);
        }
        catch(const Exception &)
        {
        }

        Sleep(5000);
    }

Cela aura comme effet de générer un événement de frappe avec la touche a enfoncée et ensuite un évènement avec la même touche relâchée. La méthode injectKeyEvent aurait aussi pu être meilleure, mais je voulais utiliser KeyEvent. Il est important de mettre le code dans un try/catch car lorsqu’on quitte l’application l’exception suivante est lancée:

java.lang.SecurityException: Injecting to another application requires INJECT_EVENTS permission

Il faut savoir que même si la permission INJECT_EVENTS est accordée, l’exception sera quand même lancée si l’application n’est pas signée.

Dans le fichier .h de la Form on ajoute le code suivant:

//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <FMX.Controls.hpp>
#include <FMX.Forms.hpp>
#include <FMX.Controls.Presentation.hpp>
#include <FMX.Memo.hpp>
#include <FMX.ScrollBox.hpp>
#include <FMX.Types.hpp>
#include "InjectInput.h"
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
    TMemo *Memo1;
private:	// User declarations
    TInjectInput* FInjectInput;
public:		// User declarations
    __fastcall TForm1(TComponent* Owner);
    virtual __fastcall ~TForm1();
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

À la ligne 12 on ajoute l’en-tête. À la ligne 19 on ajoute une propriété privée. Finalement à la ligne 22 c’est le destructeur de Form.

Dans le fichier .cpp de la Form on ajoute le code suivant:

//---------------------------------------------------------------------------
#include <fmx.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.fmx"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    FInjectInput = new TInjectInput(true);
    FInjectInput->Start();
}
//---------------------------------------------------------------------------

__fastcall TForm1::~TForm1()
{
    delete FInjectInput;
}
//---------------------------------------------------------------------------

Dans le constructeur on va créer le thread et le démarrer. On ajoute le destructeur pour libérer la mémoire.

Maintenant, il suffit de choisir le Target Android, compiler et déployer le code. On doit cliquer sur le contrôle TMemo et des a devraient apparaître à toutes les 5 secondes.

Traduction avec l’API MyMemory et CCAN/JSON

Dans cet article nous allons voir comment traduire du texte avec l’API web MyMemory. Je voulais utiliser celui de Google, mais il est payant. MyMemory n’a pas la même qualité de traduction que Google, mais le but est de faire une démonstration et non un produit commercial.

Pour analyser la réponse en JSON, au lieu d’utiliser la classe TJSONObject de la RTL, c’est la bibliothèque CCAN/JSON qui sera utilisée. Cette bibliothèque à code source ouvert est codée en C. Je l’ai choisie car dans une étude comparative sur 41 bibliothèques JSON elle semblait bien classée.

JSON Parsing Time
Temps d’analyse des bibliothèques JSON

J’ai dû exclure toutes celles en C++11, car j’utilise encore principalement le compilateur bcc32. Le facteur principal était simplement la facilité d’intégration. Si ça ne compilait pas dans les minutes suivant le téléchargement, je passais à la prochaine dans la liste.

La première étape est de créer un nouveau projet FireMonkey. Dans la Form il faut insérer un TRESTClient, un TRESTRequest, un TRESTResponse, trois contrôles TEdit, un TComboBox et un TButton.Vous pouvez donner comme texte à votre bouton le mot « Traduire ».

Voici ce à quoi l’interface devrait ressembler:

Il faut ajouter le fichier json.c qui se trouve trouve dans le dossier \ccan\json au projet pour qu’il soit compilé. Je n’ai pas eu de problème pour l’utiliser avec les plateformes Win32, Win64 et OS X.

Dans votre fichier cpp voici l’en-tête à utiliser.

extern "C"
{
    #include "json.h"
}

Il ne faut pas oublier qu’il s’agit de code en C et non C++, c’est pourquoi il faut ajouter un peu plus de code.

Voici le code à ajouter dans votre constructeur pour initialiser les contrôles:

    TListBoxItem* ListItems;

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Anglais";
    ListItems->TagString = L"en";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Chinois (simplifié)";
    ListItems->TagString = L"zh-CN";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Russe";
    ListItems->TagString = L"ru";

    ListItems = new TListBoxItem(this);
    ListItems->Parent = ComboBox1;
    ListItems->Text = L"Latin";
    ListItems->TagString = L"la";

    // On sélectionne le premier item par défaut
    ComboBox1->ItemIndex = 0;

    // Message à afficher quand la propriété Text est vide
    Edit1->TextPrompt = L"Texte à traduire";

    // Le nombre de match par défaut est mis à zéro
    Edit3->Text = L"0";

    // On n'écrit pas dans les champs de résultat
    Edit2->ReadOnly = true;
    Edit3->ReadOnly = true;

Voici le code à ajouter dans l’évènement OnClick du bouton:

    if(Edit1->Text.IsEmpty() == true || ComboBox1->ItemIndex < 0)
    {
        Edit2->Text = "";
        Edit3->Text = "0";
        return;
    }

    String LQuery = Edit1->Text;
    String LTarget = ComboBox1->ListItems[ComboBox1->ItemIndex]->TagString;

    RESTClient1->BaseURL = "http://api.mymemory.translated.net/get" \
        "?q=" + Edit1->Text +
        "&langpair=fr|" + LTarget;

    RESTRequest1->Execute();

    // Conversion en UTF-8
    TBytes LUTF8Array = TEncoding::UTF8->GetBytes(RESTResponse1->JSONText + "0");
    LUTF8Array[LUTF8Array.High] = '\0'; // Le caractère nul de terminaison est requis

    JsonNode* LRootNode = json_decode((char *)&LUTF8Array[0]);
    if(LRootNode != NULL)
    {
        JsonNode* LResponseNode = json_find_member(LRootNode, "responseData");
        if(LResponseNode != NULL && LResponseNode->tag == JSON_OBJECT)
        {
            JsonNode* LTextNode = json_find_member(LResponseNode, "translatedText");
            if(LTextNode != NULL && LTextNode->tag == JSON_STRING)
            {
                TBytes LUTFAnswer;
                LUTFAnswer.Length = strlen(LTextNode->string_);
                memcpy(&LUTFAnswer[0], LTextNode->string_, LUTFAnswer.Length);
                Edit2->Text = TEncoding::UTF8->GetString(LUTFAnswer);
            }
            JsonNode* LMatchNode = json_find_member(LResponseNode, "match");
            if(LMatchNode != NULL && LMatchNode->tag == JSON_NUMBER)
            {
                Edit3->Text = LMatchNode->number_;
            }
        }
        json_delete(LRootNode);
    }

Le texte utilisé par CCAN/JSON utilise l’encodage UTF8, c’est pourquoi il y a des conversions. Sinon le code ressemble étrangement à ce que RAD Studio nous a habitués avec sa classe JSON.

Maintenant il ne reste qu’à exécuter l’application pour la tester.
Traduction macOS

Déboguer sur CyanogenMod avec RAD Studio

Dans un article précédant, datant de novembre 2014, j’expliquais comment déboguer sur la OUYA avec RAD Studio. Plusieurs choses ont changé depuis ce temps. Le plus important étant la vente de OUYA a Razer et le fait que le matériel cessera d’être supporté. Je croyais bien que ma petite boîte grise allait rester pour toujours à l’intérieur de l’un de mes tiroirs, jusqu’à ce que je tombe sur un article expliquant comment faire rouler CyanogenMod sur ma OUYA. CyanogenMod version 11 (CM11) est basé sur Android KitKat 4.4.x. Donc, présentement ma OUYA fonctionne comme Android 4.4.4. C’est ce que l’on peut voir sur la capture d’écran qui suit.

About tablet
Information sur la OUYA et le système d’exploitation

Ma motivation première pour transformer ma OUYA en appareil Android standard n’était pas nécessairement le développement d’applications. Comme beaucoup de gens, c’était de faire fonctionner Kodi version 16.1 (Jarvis). Le reste de l’article va se concentrer par contre sur ma seconde raison.

Pour utiliser RAD Studio avec CM11, il s’agit de faire les étapes habituelles que l’on ferait sur Android. La première étant de faire afficher la section avec les options pour développeur. Pour faire cela on doit aller dans les Settings dans la section About tablet. Ensuite on clique sept fois sur Build number.

Maintenant que la section Developer options des Settings est disponible, il faut s’assurer que les options Android debugging et ADB over network sont activées:

ADB over network
Activation du débogage par le réseau

L’adresse IP et le numéro de port qui se trouve juste en dessous de l’option l’option ADB over network vous seront utiles bientôt. Il faut d’abord se connecter à la OUYA. Pour cela l’application Android Debug Bridge (adb) située dans le dossier /<sdk>/platform-tools sera utilisée. Dans le SDK Manager pour Android on trouve ce chemin dans la section Adb location. Vous devez aller dans ce dossier et taper la ligne de commande suivante:
adb connect 192.168.1.115:5555
Si tout fonctionne le résultat devrait être: connected to 192.168.1.115:5555

Vous pouvez aussi taper cette commande pour voir la liste des dispositifs connectés:
adb devices
Si la liste est vide, c’est que la commande de connexion à échouer.

Ensuite, ouvrez ou créez un nouveau projet de type Multi-Device Application dans RAD Studio. Sélectionnez le Target Android. Dans la section Target de celui-ci, OUYA devrait apparaitre. Si ce n’est pas le cas il faut faire un Refresh.

OUYA Target
Le Target OUYA est sélectionné

Il est maintenant possible de compiler le fichier APK et de tester l’application directement sur la console. Une fois fermée, elle devrait être disponible avec les autres applications.

Si vous voulez simplement installer l’application, vous pouvez utiliser cette ligne de commande:
adb install "C:\Projets\Application\Android\Release\application\bin\application.apk"

Git: Réécrire l’histoire

Encore une fois je vais traiter de la modification des informations d’une soumission. Dernièrement j’ai encore migré plusieurs projets qui étaient sous Subversion vers Git. Donc j’ai dû faire appel à git filter-branch.

Ma première erreur a été de faire des soumissions sans changer le nom du committer / author. Heureusement mon adresse de courriel était la bonne. J’ai donc ouvert une fenêtre de Git Bash pour y coller ce code:

#!/bin/sh

git filter-branch --env-filter '
EMAIL="crayon@server.com"
CORRECT_NAME="Crayon"
if [ "$GIT_COMMITTER_EMAIL" = "$EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
fi
' --tag-name-filter cat -- --branches --tags

Si vous voulez l’utiliser il faut bien sûr changer les variables EMAIL et CORRECT_NAME pour y mettre vos informations.

Mon deuxième problème est survenu suite à l’application de fichiers Patch. La date soumission était celle de l’application de la patch, mais je voulais que ce soit celle où l’auteur avait fait sa soumission. J’ai donc utilisé ce code:

#!/bin/sh

git filter-branch --env-filter '
if [ "$GIT_COMMITTER_DATE" != "$GIT_AUTHOR_DATE" ]
then
    export GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
fi
' --tag-name-filter cat -- --branches --tags

Voici la liste de variables d’environnement mises à votre disposition pour effectuer d’autres tâches:

  • GIT_AUTHOR_NAME
  • GIT_AUTHOR_EMAIL
  • GIT_AUTHOR_DATE
  • GIT_COMMITTER_NAME
  • GIT_COMMITTER_EMAIL
  • GIT_COMMITTER_DATE

Il est important de savoir que si vous roulez ces scripts, l’historique de votre dépôt va être réécrit. Toutes les personnes qui ont un fork ou un clone devront prendre cette nouvelle version.

Ping avec TIdIcmpClient

Dans cet article, je vais vous donner le code pour faire une méthode qui effectue un Ping. Nous utiliserons la classe TIdIcmpClient de Indy.

Voici la déclaration de la méthode:

    bool __fastcall Ping(const String AIP, int ATimeout = 5000);

Le paramètre ATimeout est facultatif et sa valeur par défaut est 5 secondes.

Pour utiliser TIdIcmpClient, il faut bien sûr ajouter le fichier d’en-tête suivant à votre fichier cpp:

#include <IdIcmpClient.hpp>

Voici le code de la méthode:

bool __fastcall TForm1::Ping(const String AIP, int ATimeout)
{
    bool Result = false;

    TIdIcmpClient* LIcmpClient = NULL;
    try
    {
        LIcmpClient = new TIdIcmpClient(NULL);
        LIcmpClient->Host = AIP;
        LIcmpClient->Port = 0;
        LIcmpClient->ReceiveTimeout = ATimeout;
        LIcmpClient->IPVersion = TIdIPVersion::Id_IPv4;
        LIcmpClient->Protocol = Id_IPPROTO_ICMP;

        try
        {
            const String LToSend = " !\"#$%&'()*+,-./0123456789:;<=>?";
            LIcmpClient->Ping(LToSend, 0);
            if(LIcmpClient->ReplyStatus->ReplyStatusType == TReplyStatusTypes::rsEcho &&
                LIcmpClient->ReplyStatus->BytesReceived > 0 &&
                LIcmpClient->ReplyData.Pos(LToSend) > 0)
            {
                Result = true;
            }
        }
        catch(...)
        {
        }
    }
    __finally
    {
        delete LIcmpClient;
    }

    return Result;
}

Si tout fonctionne, la méthode retourne true. Ce n’est pas plus compliqué que cela. Par contre, il est important de dire que ce code est bloquant. Donc, pour ne pas geler l’interface utilisateur c’est important de le rouler dans un thread séparé.