Code – Page 4 – Unicoda

Cover Picture Background

I wanted to display a picture in the background of a page for a project of mine. I’ve already used this solution twice. It works good and looks really great.

Here is the code using the property background-size from CSS3.

body {
  /*Full picture in the background.*/
  background: url(background.jpg) no-repeat center center fixed;
  -webkit-background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  background-size: cover;
}

So, as an example, this is the original picture I’ve used.

And this is how it looks when used as a cover picture in my project Orchestre.

[SQL] Count results from stored procedure (without return)

It’s been a while since I haven’t used SQL. Now that I’m using it on a daily basis at work, I may write a little more about SQL than before. So here is an article the aim of which is to show how to find the number of results returned by a stored procedure. It’s in fact a problem which can be easily solved.

So let’s say we have a table containing animals names. Nothing fancy, just something like this:

name
----
Cat
Dog
Rabbit

That’s it for the table. Now we need a stored procedure, so let’s assume we have one : findNameLike which take letters as parameter and returns animals names beginning with these letters.

EXEC findNameLike @beginWith = N'C'

Cat.
Yes, the above call will return Cat.

So, if we want to know how much results were found, we will just write the following code:

DECLARE @numberOfMatch INT
EXEC findNameLike @beginWith = N'C'
SELECT @numberOfMatch = @@ROWCOUNT

The number of results is now available in variable numberOfMatch.

That’s it.
But maybe you also don’t want the stored procedure to return results when you call it. So we need to modify our code a little so that results will be stored in a temporary table and thus not returned, but rather stored in the table.

DECLARE @numberOfMatch INT
DECLARE @tmpTable TABLE (
    name VARCHAR(25)
)

INSERT INTO @tmpTable 
EXEC findNameLike @beginWith = N'C'
SELECT @numberOfMatch = @@ROWCOUNT

I think we’re done here. In a few lines, we’re able to count the results from a stored procedure as well as suppressing its return.

[Java] Parse json file

Back in may 2013, I was working on a school project concerning mobile networks. So this is what I wrote one year ago while I was fighting with handover algorithm and research papers.

I’m currently building a project to simulate handover decision process in GSM/UMTS. To be able to perform the simulation, I need some parameters like mobile gain, loss, coordinates as well as informations about antennas. I’ve chose to provide these parameters to the program using a json file. So I needed to find a way to get informations from the file and parse the json in java.

I used a JSON-Java library to initialized data. Here is the code needed to parse the json belove. The jsonStr variable contains our json file as a string.

JSONObject obj = new JSONObject(jsonStr);
JSONObject objMobile = obj.getJSONObject("mobile");
JSONArray arrayPath = objMobile.getJSONArray("path");

cro = obj.getDouble("cro");
rxLevAccMin = obj.getDouble("rxlevaccmin");
msTxPwrMaxCCH = obj.getDouble("msTxPwrMaxCCH");

//Initialize Mobile Station
for(int i = 0; i < arrayPath.length(); ++i) {
 JSONObject el = arrayPath.getJSONObject(i);
 journey.add(new Coordinate(el.getInt("x"), el.getInt("y")) );
}
mobileStation = new Mobile(objMobile.getDouble("gain"),
 objMobile.getDouble("loss"), objMobile.getDouble("classPower"),
 journey, objMobile.getBoolean("voice"), 6, -102, journey.get(0));

//Initialize Antennas
JSONArray arrayAntenna = obj.getJSONArray("antenna");
for(int j = 0; j < arrayAntenna.length(); ++j) {
 JSONObject el = arrayAntenna.getJSONObject(j);
 Coordinate position = new Coordinate(el.getInt("x"), el.getInt("y"));
 antennaList.add(new Antenna(el.getInt("type"), position, 
 el.getDouble("gain"), el.getDouble("loss"), el.getDouble("power"),
 el.getDouble("frequency"), el.getDouble("coef")));
}

Once our json string has been parsed to a json object, we can extract data using:

getJSONObject
getJSONArray
getBoolean
getInt
getDouble

Here is the json file:

{
  "rxlevaccmin": -96, 
  "cro": 0.0, 
  "msTxPwrMaxCCH": 33, 
  "mobile": { 
    "gain": 0, "loss": 0, 
    "classPower": 33, 
    "voice": false, 
    "path": [ 
      {"x": 11, "y": 0}, 
      {"x": 14, "y": 0}, 
      {"x": 16, "y": 0}, 
      {"x": 18, "y": 0}, 
      {"x": 20, "y": 0}, 
      {"x": 24, "y": 0}, 
      {"x": 25, "y": 0}, 
      {"x": 26, "y": 0} 
    ] 
  },
  "antenna": [ 
    { 
      "type": 0, 
      "x": 0, "y": 0, 
      "power": 20, 
      "gain": 0, "loss": 0, 
      "frequency": 900, 
      "coef": 1 
    }, 
    { 
      "type": 1, 
      "x": 30, "y": 0, 
      "power": 10, 
      "gain": 0, "loss": 0, 
      "frequency": 900, 
      "coef": 1 
    }, 
    {
      "type": 0, 
      "x": 20, "y": 5, 
      "power": 12, 
      "gain": 0, "loss": 0, 
      "frequency": 900, 
      "coef": 1 
    }
  ]
}

It’s funny to compare this with the one-line-way to parse json in Node.Js:

var jsonObject = require('jsonFileName');
var classPower =jsonObject.mobile.classPower

[POC] Puppet master-agent avec Docker

Petit Proof of Concept réalisé la semaine dernière autour des technologies Puppet et Docker. L’idée consiste à utiliser Docker pour pouvoir facilement déployer un environnement master-slave Puppet et avoir ainsi la possibilité de tester ses scripts de déploiement ou plus généralement, d’étudier et de comprendre le fonctionnement de Puppet avant de passer à une utilisation en production.

Le projet permet donc la création de deux containers Docker, l’un contenant le master et l’autre l’agent. Après création du container master, on peut créer l’agent et lier les deux containers à l’aide du paramètre -link de Docker. On permet ainsi aux deux containers de communiquer entre eux sans avoir à essayer de déterminer leur IP respective à la main. Par la suite, après signature du certificat de l’agent par le master, la configuration décrite dans le fichier site.pp sous le nœud agent pourra être mise en place sur celui-ci.

node  'agent' {
  class { 'apache': }
}

Par exemple, on installe ici apache dans le container de l’agent.

Mes différents tests m’ont également permis d’identifier certains limitations au niveau de Docker:

Impossible de modifier le fichier /etc/hosts au sein d’un container.
Impossible de modifier les paramètres ulimit dans un container.

Le code est bien sûr disponible disponible sous licence libre sur Github: vvision/docker-puppet-master-agent.

C4ptch@

De temps à autre, il m’arrive de regarder un peu sous le capot des sites web que je visite, de plonger dans le code pour m’intéresser à l’un ou l’autre composant du site. Dernièrement, j’ai donc été attiré par la partie captcha de l’un d’eux.

Dès le premier coup d’œil, je pressens une faille. Quelques actualisations de page plus tard, ma première impression se confirme, le nom donné aux images représentant les différents chiffres du captcha ne changent pas. Il suffit donc d’établir la correspondance entre nom d’image et chiffre et nous devenons capable de déterminer le captcha automatiquement.

En regardant d’un peu plus près l’identifiant de chaque image, je m’aperçois également que celui-ci fait 32 caractères de long. Résumons: 32 caractères, lettres minuscules de a à z et chiffres de 0 à 9. Qui a dit md5? Un petit test pour s’en convaincre. L’image correspondant au 0 a pour identifiant cfcd208495d565ef66e7dff9f98764da, ce qui correspond bien au hash md5 de 0.

Cette constatation m’a donc fait réfléchir à la question suivante: si il est possible de casser un captcha en apprenant la règle spécifique à un programme, ce mécanisme de captcha est-il toujours valable, au sens où il a fallu une intervention humaine pour écrire la règle?

Revenons donc sur la définition d’un captcha par Wikipédia: « A CAPTCHA (an acronym for « Completely Automated Public Turing test to tell Computers and Humans Apart ») is a type of challenge-response test used in computing to determine whether or not the user is human. ». On y apprend qu’un captcha doit permettre de déterminer si un utilisateur est humain ou non. Donc, le mécanisme de captcha étudié n’est pas valable, puisqu’un programme relativement simple est capable de résoudre le défi. Bien entendu, il aura fallu qu’un humain écrive la façon de résoudre ce captcha en particulier (,mais après tout, il y a un humain derrière chaque ligne de code). De plus, on peut très bien écrire un programme capable de reconnaître lorsqu’un site utilise ce type de captcha et ainsi s’affranchir d’une intervention humaine pour chaque site utilisant ce mécanisme de captcha.

Pour terminer, j’ai continué mes recherches et avec les bons mot-clés, j’ai donc constaté que ce type de captcha utilisant un hash md5 comme identifiant d’image se retrouve sur quelques sites mais ne semble pas être trop répandu. On peut néanmoins déplorer que la page sur laquelle j’ai découvert ce captcha soit celle de contact d’une commune française de taille moyenne.