Grapsus.net

Nagios plugin to check SSL certificates

Alexis Bezverkhyy — Tue, 27 Sep 2011 11:15:00 +0200

Here a Nagios plugin I wrote for checking SSL certificates for expiry. You can set it up for emitting a WARNING or a CRITICAL state N days before expiry.

/root/bin/nagios-check-crt.sh :

#!/bin/bash
 
# Written by Alexis Bezverkhyy <alexis@grapsus.net> in september 2011
# This is free and unencumbered software released into the public domain.
# For more information, please refer to <http://unlicense.org/>
 
function PRINT_USAGE(){
  echo "This Nagios plugin checks SSL certificates for expiration :
  -c HOST:PORT host and port to connect
  -d DAYS  minimum days before expiry, otherwise a WARNING is issued
  -D DAYS  minimum days before expiry, otherwise a CRITICAL is issued
  -h    prints out this help"
  exit 0
}
 
CONNECT='';WDAYS=0;CDAYS=0;
declare -i CDAYS 
declare -i WDAYS
while true ; do
  getopts 'c:d:D:h' OPT 
  if [ "$OPT" = '?' ] ; then break; fi; 
  case "$OPT" in
    "c") CONNECT="$OPTARG";;
    "d") WDAYS="$OPTARG";;
    "D") CDAYS="$OPTARG";;
    "h") PRINT_USAGE;;
  esac
done
 
if [ -z "$CONNECT" -o '(' "$WDAYS" = '0' -a "$CDAYS" = '0' ')' ] ; then
  PRINT_USAGE
fi
 
function get_crt_expiry
{
        # connect to host with OpenSSL client, filter CRT, parse CRT,
        # get expiry time, convert to traditionnal y-m-d h:s
        echo -n '' | openssl s_client -connect "$1" 2>/dev/null \
                | awk 'BEGIN { p = 0 }
                                         /BEGIN CERT/ { p = 1 }
                                         { if (p) print $0 }
                                         /END CERT/ { p = 0 }' \
                | openssl asn1parse 2>/dev/null \
                | grep 'UTCTIME' \
                | awk '{ print $7 }' \
                | tr -d 'Z:' \
                | tail -n 1 \
                | sed -r 's/^(..)(..)(..)(..)(..).*$/\1-\2-\3 \4:\5/'
}
 
EXPIRY=$(get_crt_expiry "$CONNECT")
if [ -z "$EXPIRY" ] ; then
        echo "WARNING - cannot get expiry date for $CONNECT"
        exit 1
fi
EPOCH_EXPIRY=$(date -d "$EXPIRY" +%s)
EPOCH_NOW=$(date +%s)
let "REM_DAYS = (EPOCH_EXPIRY - EPOCH_NOW)/(24*3600)"
 
if [ "$CDAYS" -gt 0 -a "$REM_DAYS" -lt "$CDAYS" ] ; then
  echo "CRITICAL - $CONNECT crt expries on $EXPIRY ($REM_DAYS days left)" 
        exit 2
fi
 
if [ "$WDAYS" -gt 0 -a "$REM_DAYS" -lt "$WDAYS" ] ; then
  echo "WARNING - $CONNECT crt expries on $EXPIRY ($REM_DAYS days left)" 
        exit 1
fi
  
echo "OK - $CONNECT crt expries on $EXPIRY ($REM_DAYS days left)"

Here's the configuration to check a simple HTTPS service.

commands.cfg :

define command {
  command_name check_crt
  command_line /root/bin/nagios-check-crt.sh -c $ARG1$ -d $ARG2$ -D $ARG3$
}

myhost.cfg :

define service {
        use             generic-service
        host_name  myhost
        service_description HTTPS-CRT
        check_command check_crt!myhost.com:443!60!30
}

Low-level Python debugging with GDB

Alexis Bezverkhyy — Thu, 11 Aug 2011 22:08:00 +0200

Introduction

Your Python program is crashing or unresponsive and you can't figure it out with traditional tools (printing, PDB) ? Then this tutorial might help you !

GDB is a very powerful debugging tool, but it's hardly intuitive to use and moreover it doesn't understand Python data structures. With no hacking it will only be able to print the system stack and addresses of some variables whereas what you need is the Python stack and Python local variables in a human readable form.

To start, install GDB and a debug build of your Python interpreter (python2.x-dbg on Debian-like systems).

This last file contains a few macros for GDB that will enable it to print Python locals and stack.

Test program

Let's pretend we don't know why this simple program doesn't stop and why it's unresponsive :

import time
 
def next(i):
    time.sleep(10)
    i = 1 - i
 
i = 1
while True:
    next(i)

Easy case

If your problem is easily reproducible, then you're in luck. Restart your script with the debug build of the Python interpreter and attach to it with GDB :

1
2
3

python2.7-dbg test.py &
[1] 7877
gdb -p 7877

At this point the Python interpreter has been interrupted and the script is paused so we can inspect it. First, we can see the Python stack of our script :

(gdb) py-bt
#5 Frame 0x242ae50, for file test.py, line 4, in next (i=1)
    time.sleep(10)
#8 Frame 0x2427e00, for file test.py, line 9, in <module> ()
    next(i)

To avoid all confusion : the most recent call comes first in this trace unlike when the backtrace is printed from Python. In GDB, the most recent call is called active or selected. We can print Python code and local variables in the selected frame :

(gdb) py-list 
   1    import time
   2    
   3    def next(i):
  >4        time.sleep(10)
   5        i = 1 - i
   6    
   7    i = 1
   8    while True:
   9        next(i)
(gdb) py-locals 
i = 1

With py-up and py-down macros we can change the selected Python frame. You must be aware that the process is still frozen and those commands don't actually do anything to the process.

(gdb) py-up
#8 Frame 0x2427e00, for file test.py, line 9, in <module> ()
    next(i)
(gdb) py-list 
   4        time.sleep(10)
   5        i = 1 - i
   6    
   7    i = 1
   8    while True:
  >9        next(i)

At this point GDB has the same behavior as PDB, it is good but not so helpful. If you were unable to figure it out with PDB, then you're probably dealing with some low-level problem in some Python internal, external lib or system call. To understand what happens you will need to explore the system stack :

(gdb) backtrace
#0  0x00007f48671cddf3 in select () from /lib/x86_64-linux-gnu/libc.so.6
#1  0x000000000058b22c in floatsleep (secs=10) at ../Modules/timemodule.c:943
#2  0x000000000058a05f in time_sleep (self=0x0, args=(10,)) at ../Modules/timemodule.c:206
#3  0x000000000048867e in PyCFunction_Call (func=<built-in function sleep>, arg=(10,), kw=0x0)
    at ../Objects/methodobject.c:81
#4  0x0000000000525efe in call_function (pp_stack=0x7fff3ac2ca40, oparg=1) at ../Python/ceval.c:4013
#5  0x0000000000520f59 in PyEval_EvalFrameEx (f=Frame 0xe59e50, for file test.py, line 4, in next (i=1), throwflag=0)
    at ../Python/ceval.c:2666
#6  0x00000000005263c5 in fast_function (func=<function at remote 0xe074f8>, pp_stack=0x7fff3ac2cdc0, n=1, na=1, nk=0)
    at ../Python/ceval.c:4099
#7  0x00000000005260d5 in call_function (pp_stack=0x7fff3ac2cdc0, oparg=1) at ../Python/ceval.c:4034
#8  0x0000000000520f59 in PyEval_EvalFrameEx (f=Frame 0xe56e00, for file test.py, line 9, in <module> (), throwflag=0)
    at ../Python/ceval.c:2666
#9  0x0000000000523744 in PyEval_EvalCodeEx (co=0xdb90f0, globals=
    {'__builtins__': <module at remote 0x7f4868754470>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0xe0e678>, '__name__': '__main__', 'next': <function at remote 0xe074f8>, '__doc__': None}, locals=
    {'__builtins__': <module at remote 0x7f4868754470>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0xe0e678>, '__name__': '__main__', 'next': <function at remote 0xe074f8>, '__doc__': None}, args=0x0, 
    argcount=0, kws=0x0, kwcount=0, defs=0x0, defcount=0, closure=0x0) at ../Python/ceval.c:3253
#10 0x0000000000519b86 in PyEval_EvalCode (co=0xdb90f0, globals=
    {'__builtins__': <module at remote 0x7f4868754470>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0xe0e678>, '__name__': '__main__', 'next': <function at remote 0xe074f8>, '__doc__': None}, locals=
[...]

We can now see that our program is stuck in a call to select(), in the libc (you might not actually see exactly where the last call was made unless you have a debug version of that external library). Now you should probably use GDB commands finish and return to see if the execution thread comes back into the Python interpreter. If not, it's probably a bug with an external library which should be reproducible outside of Python.

Hard case

You might not be able to trigger systematically the bug which may be happening like once a day on one of your production servers. In this case we absolutely need to perform the analysis right on the production server where you found the unresponsive process. As this process is running on an optimized and stripped version of the Python interpreter, the stack trace will give you very few info :

(gdb) bt
#0  0x00007f1b7f02cdf3 in select () from /lib/x86_64-linux-gnu/libc.so.6
#1  0x00000000005048c2 in ?? ()
#2  0x00000000004b90a9 in PyEval_EvalFrameEx ()
#3  0x00000000004b9673 in PyEval_EvalFrameEx ()
#4  0x00000000004bf600 in PyEval_EvalCodeEx ()
#5  0x00000000004c0082 in PyEval_EvalCode ()
#6  0x00000000004df2d2 in ?? ()
#7  0x00000000004dfe64 in PyRun_FileExFlags ()
#8  0x00000000004e096e in PyRun_SimpleFileExFlags ()
#9  0x00000000004f09dd in Py_Main ()
#10 0x00007f1b7ef7cead in __libc_start_main () from /lib/x86_64-linux-gnu/libc.so.6
#11 0x000000000041f0a1 in _start ()

Only public symbols of libpython are visible, we absolutely don't know where we are in the Python script and we have no idea of the Python stack. Let's install the debug version of Python, it will at least install GDB symbols for the Python interpreter :

(gdb) bt
#0  0x00007f0b1773bdf3 in select () from /lib/x86_64-linux-gnu/libc.so.6
#1  0x00000000005048c2 in floatsleep (self=<value optimized out>, args=<value optimized out>)
    at ../Modules/timemodule.c:943
#2  time_sleep (self=<value optimized out>, args=<value optimized out>) at ../Modules/timemodule.c:206
#3  0x00000000004b90a9 in call_function (f=<value optimized out>, throwflag=<value optimized out>)
    at ../Python/ceval.c:4013
#4  PyEval_EvalFrameEx (f=<value optimized out>, throwflag=<value optimized out>) at ../Python/ceval.c:2666
#5  0x00000000004b9673 in fast_function (f=<value optimized out>, throwflag=<value optimized out>)
    at ../Python/ceval.c:4099
#6  call_function (f=<value optimized out>, throwflag=<value optimized out>) at ../Python/ceval.c:4034
#7  PyEval_EvalFrameEx (f=<value optimized out>, throwflag=<value optimized out>) at ../Python/ceval.c:2666
#8  0x00000000004bf600 in PyEval_EvalCodeEx (co=0x7f0b18c0f8b0, globals=<value optimized out>, 
    locals=<value optimized out>, args=<value optimized out>, argcount=<value optimized out>, 
    kws=<value optimized out>, kwcount=0, defs=0x0, defcount=0, closure=0x0) at ../Python/ceval.c:3253
#9  0x00000000004c0082 in PyEval_EvalCode (co=<value optimized out>, globals=<value optimized out>, 
    locals=<value optimized out>) at ../Python/ceval.c:667
#10 0x00000000004df2d2 in run_mod (mod=<value optimized out>, filename=<value optimized out>, globals=
    {'__builtins__': <module at remote 0x7f0b18c8cad0>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0x7f0b18bc7210>, '__name__': '__main__', 'next': <function at remote 0x7f0b18bc2578>, '__doc__': None}, locals=
    {'__builtins__': <module at remote 0x7f0b18c8cad0>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0x7f0b18bc7210>, '__name__': '__main__', 'next': <function at remote 0x7f0b18bc2578>, '__doc__': None}, flags=
<value optimized out>, arena=<value optimized out>) at ../Python/pythonrun.c:1346
#11 0x00000000004dfe64 in PyRun_FileExFlags (fp=0x2693690, filename=0x7ffffc54e67b "test.py", 
    start=<value optimized out>, globals=
    {'__builtins__': <module at remote 0x7f0b18c8cad0>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0x7f0b18bc7210>, '__name__': '__main__', 'next': <function at remote 0x7f0b18bc2578>, '__doc__': None}, locals=
    {'__builtins__': <module at remote 0x7f0b18c8cad0>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0x7f0b18bc7210>, '__name__': '__main__', 'next': <function at remote 0x7f0b18bc2578>, '__doc__': None}, closeit=1,
flags=0x7ffffc54ce30) at ../Python/pythonrun.c:1332
#12 0x00000000004e096e in PyRun_SimpleFileExFlags (fp=0x2693690, filename=<value optimized out>, closeit=1, flags=
    0x7ffffc54ce30) at ../Python/pythonrun.c:936
#13 0x00000000004f09dd in Py_Main (argc=<value optimized out>, argv=<value optimized out>) at ../Modules/main.c:599
#14 0x00007f0b1768bead in __libc_start_main () from /lib/x86_64-linux-gnu/libc.so.6
#15 0x000000000041f0a1 in _start ()

It is better, we now know the module and the file, but nothing about local variables or Python stack. Do not try to use py-* macros, they will not work as almost all Python internals are "optimized out", they will probably trigger a segmentation fault by trying to print Python objects with _PyObject_Dump.

The only chance you have to find exactly where the code is failing is by carefully inspecting all the internal Python variables, some of them are still usable and can be used to find out what's going on. For example :

(gdb) select-frame 2
(gdb) info locals
secs = 10
(gdb) select-frame 3
(gdb) info locals
callargs = (10,)
flags = <value optimized out>
tstate = <value optimized out>
func = <built-in function sleep>
w = <value optimized out>
na = <value optimized out>
nk = <value optimized out>
n = <value optimized out>
pfunc = 0x26aace0
x = <value optimized out>

Frame 2 was a call in timemodule.c and showed us that the argument of the function call was 10 secs.

Frame 3 is in PyEval_EvalFrameEx() (main Python bytecode interpretation routine) it brings us back into the interpreter. Almost all local variables were optimized, func tells us that the function call was for the function sleep. Finally :

(gdb) select-frame 4
(gdb) info locals 
sp = 0x26aace8
stack_pointer = <value optimized out>
next_instr = 0x7f0b18bc0760 "\001d\002"
opcode = <value optimized out>
oparg = <value optimized out>
why = WHY_NOT
err = 0
x = <value optimized out>
v = <value optimized out>
w = <value optimized out>
u = <value optimized out>
t = <value optimized out>
stream = 0x0
fastlocals = <value optimized out>
freevars = 0x26aace0
retval = <value optimized out>
tstate = 0x25d20a0
co = 0x7f0b18c0fa30
instr_ub = -1
instr_lb = 0
instr_prev = -1
first_instr = 0x7f0b18bc0754 "t"
names = ('time', 'sleep')
consts = (None, 10, 1)
(gdb) p tstate->frame->f_globals 
$5 = 
    {'__builtins__': <module at remote 0x7f0b18c8cad0>, '__file__': 'test.py', '__package__': None, 'i': 1, 'time': <module at remote 0x7f0b18bc7210>, '__name__': '__main__', 'next': 
<function at remote 0x7f0b18bc2578>, '__doc__': None}
(gdb) p tstate->frame->f_lineno 
$6 = 3

Here we go test.py line 3, i = 1, function call to time.sleep(10) !

Insanely hard case

If this those steps are still insufficient, you might try to set breakpoints on call_function() and let the script run a little bit with continue or step.

The final and ultimate solution is to run PyEval_EvalFrameEx() step by step. Grab the source of CPython and go to the Python directory before launching GDB (it must be the source of that exact same version of the Python interpreter that runs your script) :

(gdb) finish
Run till exit from #0  0x00007fc13a60adf3 in select () from /lib/x86_64-linux-gnu/libc.so.6
0x00000000004dc17b in floatsleep (self=<value optimized out>, args=<value optimized out>)
    at ../Modules/timemodule.c:914
914     ../Modules/timemodule.c: No such file or directory.
        in ../Modules/timemodule.c
(gdb) next
time_sleep (self=<value optimized out>, args=<value optimized out>) at ../Modules/timemodule.c:206
206     in ../Modules/timemodule.c
(gdb) cd python2.7-2.7.2/Python/
Working directory /home/grapsus/ludia/python2.7-2.7.2/Python.
(gdb) next
208         Py_INCREF(Py_None);
(gdb) next
209         return Py_None;
(gdb) next
210     }

Notice that it doesn't work until you cd to the Python directory of CPython source tree. Same thing if you want to debug step by step some Python module, like gevent, you will need the source code of the very same version that's running the script.

It is very time-consuming and you'll probably need a Python bytecode reference to follow what's going on but you'll eventually find the issue.

Conclusion

Even with a strongly optimized and stripped Python interpreter it is possible to debug or at least analyze a buggy Python script.

References

http://docs.python.org/devguide/gdb... Debugging Python with GDB and the new Python GDB API
http://tromey.com/blog/?p=548 About GDB 7+ Python API
http://hg.python.org/cpython/file/e... Old GDB macros for Python (before GDB 7 and Python API)
http://marcioandreyoliveira.blogspo... Article about debugging stripped programs
CPython source code in general

Sleep sort performance test

Alexis Bezverkhyy — Mon, 25 Jul 2011 01:38:00 +0200

Introduction

Sleep sort is a very curious and original algorithm. It brings several interesting questions. Such as, how to measure its complexity or in what cases does it perform the best.

Principle

In a nutshell: for each element to sort, start a thread or a process which sleeps a time proportional to the element and then pushes it back to the main thread.

Trivial Bash implementation:

#!/bin/bash
 
function f {
        sleep $1
        echo $1
}
 
while [ -n "$1" ] ; do 
        f $1 &
        shift
done
wait

Test suite

In order to study it and measure its performance we (me and Hartok) decided to implement the Sleep Sort in Python and gevent.

Our program generates a set of random numbers and sorts it with Sleep sort then with the Python built-in Quick sort and records timings. It works with three parameters:

set size
maximum value in the set
the ratio between sleep time and values in the set (for example with 10 the thread for 42 sleeps for 42/10 seconds)

This last parameter is pretty tricky: the higher it is, the faster the Sleep sort works. But if it is too high, the time to start a new thread (or greenlet) will be more important than the sleep time for low values and the result will be incorrect. It seems to be strongly hardware dependent and a little tied to the other parameters.

#!/usr/bin/python
 
import sys
import random
import time
import copy
import gevent
 
divisor = 900000
 
def sort(numbers):
        """ Sorts a list with Sleep Sort algorithm and measures time
        """
        begin = time.time()
 
        def f(n, result):
                gevent.sleep(float(n)/divisor)
                result.append(n)
        
        result = []
        greenlets = []
        # spawn a sleep greenlet for each value
        for n in numbers:
                greenlets.append(gevent.Greenlet.spawn(f, n, result))
 
        # wait for all greenlets to end
        gevent.joinall(greenlets)
        return (time.time()-begin, result)
 
def systemsort(numbers):
        """ Sorts a list with system sort function and measures time
        """
        begin = time.time()
        result = copy.copy(numbers)
        result.sort()
        return (time.time()-begin, result)
 
def generate(n, m): 
        """ Generates a list of n random numbers, each being less than m
        """
        numbers = []
        for i in range(n):
                numbers.append(random.randint(1, m))
        return numbers
 
if __name__ == '__main__':
        # read params
        try:
                n = int(sys.argv[1])
                m = int(sys.argv[2])
        except BaseException:
                print "usage: %s n m [d]" % sys.argv[0]
                print " - n number of random numbers"
                print " - m maximum random value"
                print " - d time divisor (optionnal), default is %d" % divisor
                sys.exit(1)
 
        try:
                divisor = int(sys.argv[3])
        except:
                pass
 
        # generate random values
        numbers = generate(n, m)
        # sleep sort them
        (sleep_time, sleep_result) = sort(numbers)
        # system sort them
        (system_time, system_result) = systemsort(numbers)
 
        if system_result == sleep_result:
                print "sleep sort succeed"
                print "sleep: %f" % sleep_time
                print "system: %f" % system_time
        else:
                print "sleep sort failed (time divisor too ambitious ?)"
                print "sleep: (%d elements)" % len(sleep_result)
                #print sleep_result.__str__()
                print "system: (%d elements)" % len(system_result)
                #print system_result.__str__()
                errors = 0
                for n in range(n):
                        if system_result[n] != sleep_result[n]:
                                errors = errors + 1
                print "%d errors" % errors

Test results

The overall performance of the Sleep sort is awful, but it has interesting performance when it comes to sets with few different values.

Blog migré !

Alexis Bezverkhyy — Fri, 22 Jul 2011 11:20:00 +0200

Plusieurs internautes reconnus ont retwitté mon dernier billet. Merci Stéphane Bortzmeyer et Korben ! Mon blog était devenu affreusement lent à consulter, la ligne ADSL ne tenant plus la charge avec son petit mégabit d'upload. Plus de 50 personnes se sont rabattues sur une copie que j'ai envoyée sur pastebin.

J'ai décidé de migrer mon blog immédiatement vers un serveur OVH. Merci à Ekinox pour ce gros domU ! Tout est de nouveau opérationnel et rapide si les DNS se sont bien propagés chez vous. Je migrerai le reste de mes services demain, Mercurial, SVN, etc. L'ancien serveur est toujours accessible sur

home.grapsus.net

Bouygues Télécom modifie en douce ses CGS peu après mon premier billet

Alexis Bezverkhyy — Fri, 22 Jul 2011 07:20:00 +0200

Avant-propos

Tout d'abord je voudrais remercier tous ceux qui ont promu mon billet précédent sur Twitter ou dans leurs blogs : en deux jours, je suis passé de 50 à 1000 visiteurs journaliers, avec une pointe à 3500 hier. Ça me donne vraiment envie d'écrire plus souvent.

Mon blog a d'ailleurs eu une petite coupure causée par cette affluence soudaine. Il est actuellement hébergé à la maison avec une machine à la retraite et une connexion ADSL. Je fais ça plus par conviction que par manque de moyens. Ce système marchait parfaitement pour 50 visiteurs journaliers mais il est évident que ça ne peut plus marcher avec 1000 et au-delà. Je vais donc le déplacer sur un serveur dédié plus traditionnel dans les jours qui viennent et il n'y aura plus de problèmes de ce côté.

Des personnes ont mentionné le tethering employé pour faire mes tests comme un non respect des conditions d'utilisation. Oui c'est vrai, mais techniquement, la provenance d'un paquet n'a aucune espèce d'importance et je me suis servi d'un PC pour une raison purement pratique, pour avoir accès à des outils comme tcpdump, wireshark, wget, nmap ou netcat. On pourrait refaire les mêmes tests depuis le terminal du téléphone et l'on trouvera rigoureusement la même chose. D'ailleurs la raison qui m'a poussé à faire ces tests est que je n'arrivais regarder presqu'aucune vidéo proposée par un site web depuis mon téléphone. D'autres personnes se plaignent de ne pas pouvoir consulter des documents tels que des journaux ou des BD depuis leur téléphone. Ceci démontre bien que ce n'est pas un problème de tethering, mais une véritable limitation pour ceux qui utilisent légitiment le service.

N'hésitez pas à me contacter si vous avez des questions techniques concernant le test de votre connexion. Je pourrai même vous aider si vous me donnez un accès SSH.

Introduction

De nombreuses personnes (et trolls) ont commenté mon billet précédent dans lequel je dénonçais la coupure des sessions TCP dépassant 10 Mo et l'interdiction, par un proxy transparent, de l'accès aux fichiers dépassant 10 Mo. Plusieurs personnes ont dit que ces limites étaient annoncées dans les conditions générales de service de l'opérateur. À ma grande surprise c'est vrai ! Mais pourtant, je me rappelle, en janvier 2011, avoir épluché ces conditions, avant de souscrire à mon forfait Internet et il n'y avait rien qui parlait de ce genre de limites.

Pratiques douteuses avec les CGS

Je ne suis pas du tout juriste, mais je sais que lorsqu'on souscrit à un service, surtout avec de l'engagement de durée, on signe un très long contrat décrivant très scrupuleusement le service souscrit et les conditions de son utilisation. Lorsque l'opérateur ne respecte pas ces conditions, ou lorsqu'il décide de changer de manière unilatérale ces conditions, le client n'est plus tenu à respecter son engagement. C'est exactement ce qui était arrivée avec l'augmentation de la TVA sur les services multimédias en février 2011.

Chez Bouygues Télécom on a une vision très particulière du contrat avec le client. Après des heures de recherche, la seule page qui contient des informations à valeur légale (et non pas des brochures ou des informations indicatives) est la suivante : http://www.laboutique.bouyguestelec...

La première chose qui m'a frappée, c'est que ces documents ne sont pas versionnés : il sont régulièrement mis à jour et toute trace des versions précédentes est effacée. Or c'est les conditions de service à la date où l'on a souscrit au service qui doivent être appliquées à un client. Le moindre changement doit être explicitement accepté par le client. C'est quelque chose que l'on voit régulièrement chez Free, sur la page d'accueil de l'espace client on nous propose d'accepter ou non des modifications apportées au contrat (souvent pour profiter de nouveaux tarifs ou services). Chez Bouygues, il est donc quasi impossible d'obtenir le texte des conditions de services à la date où l'on s'est abonné au service.

Deuxième point noir : "Conditions Générales de Service" est tout sauf un document légal, c'est encore une brochure de 4 pages qui prend la forme d'une FAQ et où on vous dit en gros deux choses :

Les seules raisons valables pour résilier avant la fin de l'engagement c'est le décès ou l'emprisonnement à longue durée du client.
Tous les tarifs et les services sont définis dans le "Guide des tarifs".

Alors là c'est très fort : pour la description et les tarifs des services souscrits on vous renvoie à une brochure !

Changement des CGS en douce

Je tombe alors sur le fameux "Guide des tarifs" version "mai/août 2011" qui prend la forme d'une brochure explicative des prix et des services avec, à la page 74, "les informations contractuelles". Cette dernière partie se contente de reprendre le texte des "Conditions Générales de Service" sous forme de FAQ.

Dans la partie non contractuelle on trouve effectivement la phrase suivante :

INTERNET
Correspond à la navigation sur tous les sites Internet ou wap. Cette navigation s'effectue soit :
sur votre mobile ou sur votre ordinateur/tablette grâce à l'option modem 24/24. Chaque télé-
chargement ou accès en streaming est de 10Mo maximum.

Première remarque : on est en train de nous dire que Internet c'est naviguer sur des sites Internet ou WAP. On m'a appris à l'école, que Internet est un réseau qui interconnecte des millions de réseaux et leur permet d'échanger des données au moyen du protocole IP. Chez Bouygues Internet c'est la consultation d'un seul service, le web, au moyen du protocole HTTP. Soit.

Deuxième remarque : toutes les limites d'utilisation du service Internet sont répertoriées dans la partie contractuelle de la brochure, mais pas celle-là ! Ça sent l'ajout à la va-vite, sans avoir consulté le juriste pour inclure cette condition dans les véritables CGS...

J'avais vraiment le sentiment que cette phrase ne figurait pas dans le "Guide des tarifs" en janvier 2011. Heureusement que le web conserve et archive des documents : j'ai pu retrouver les PDF des versions précédentes du "Guide des tarifs", effacées du site officiel :

guide des tarifs bouygues "Offres mobile" filetype:pdf

Résultats :

12729PHR novembre/janvier 2010 : pas de paragraphe "INTERNET", mais un modeste paragraphe "SURF" qui donne des exemples d'utilisation
12755PHR mars/mai 2010 : +"L’Internet depuis un mobile correspond à l’échange de données (dont les e-mails) sur les sites Internet ou WAP."
12783PHR août/novembre 2010 : "Correspond à la navigation sur tous les sites Internet ou wap. Cette navigation s’effectue exclusivement sur votre mobile non relié à un ordinateur ou avec une clé 3G+ relié à un seul ordinateur."
12820PHR janvier/mars 2011 : pas de changement
12830PHR mars/mai 2011 : pas de changement
12846PHR mai/août 2011 (version actuelle) : bingo ! +"Chaque télé-chargement ou accès en streaming est de 10Mo maximum."

Je ne veux pas soutenir une quelconque théorie du complot, ou me donner de l'importance : mais mon billet précédent a été publié le 19 avril 2011 et à l'époque je l'avais twitté à @bouyguestelecom et il avait fait déjà un peu de bruit.

Conclusion

Les Conditions Générales de Service de Bouygues ont été modifiées en douce en mai 2011 pour rendre contractuelles des limitations techniques intolérables. Les versions précédentes des documents contractuels sont effacées pour faire comme si tous les clients acceptaient tacitement n'importe quel changement.

Le contrat que j'ai signé en janvier 2011 ne mentionne pas ces limitations, pourtant je les subis et je n'ai jamais accepté les nouvelles conditions. Dans la mesure où ce changement est une régression du service proposé, ceci constitue une modification unilatérale de mon contrat. Je suis actuellement en stage à l'étranger et ma ligne est temporairement suspendue. À mon retour je compte envoyer une lettre de résiliation.

Je voudrais vraiment entendre des vrais avis juridiques sur la question. L'idéal serait de faire étudier la problématique à quelqu'un comme Maître Éolas... Il y a peut-être aussi du matériel pour une action de l'UFC Que choisir ?

Edit

J'ai retrouvé plusieurs autres PDF 12***PHR, surtout le "mars/mai 2011" qui était la pièce manquante pour avoir la preuve que le changement a été introduit en mai 2011. J'ai aussi ajouté une évolution plus détaillé du paragraphe problématique : on s'aperçoit qu'il a été remanié plus d'une fois !

Remarquez le passage de "SURF" à "INTERNET" après janvier 2010. Bizarrement ce changement n'a pas entraîné l'ouverture d'autres services que le web ou l'attribution d'adresses IP Internet aux clients...

Bouygues Télécom filtre malhonnêtement son réseau 3G et inspecte vos données

Alexis Bezverkhyy — Tue, 19 Apr 2011 11:10:00 +0200

Une jolie leçon en matière de neutralité de réseau de la part de Bouygues Télécom. Voici "l'accès Internet illimité 2Go" que obtenez pour 45 euros par mois.

Introduction

Mon PC sous Debian SID est connecté au réseau 3G de Bouygues Télécom à travers la fonctionnalité "point d'accès Wifi" du téléphone HTC Desire Z (Android Froyo).

Filtrage de contenus vidéo

Tous les lecteurs de vidéos flash que vous rencontrez sur internet affichent mystérieusement une erreur. Avec Firebug on voit aisément que c'est le flux FLV en lui même qui ne passe pas : ERREUR 403 : Forbidden avec un message d'erreur en français, quelque soit le site. On a donc affaire à un proxy transparent. Pourquoi on trouverait ça choquant ou inadmissible de la part d'un FAI ADSL alors que c'est monnaie courante chez les revendeurs de minitels mobiles ? Essayons d'en savoir plus...

Voici un faux contenu FLV :

1 2	<?php header("Content-Type: video/x-flv"); ?> lol

Bizarrement tout va bien :

 grapsus@escher:~$ wget grapsus.net/test.php
 ...
 2011-04-18 12:28:36 (417 KB/s) - «test.php» sauvegardé 6/6

Mais alors pourquoi une vraie vidéo bloque ? Essayons d'enregistrer un vrai fichier FLV de 20 Mo :

 wget http://grapsus.net/test.flv
 ...
 requête HTTP transmise, en attente de la réponse...403 Forbidden
 2011-04-18 22:09:56 ERREUR 403: Forbidden.

Et les logs du serveur :

 62.201.XXX.XXX - - 18/Apr/2011:22:07:24 +0200 "GET /test.flv HTTP/1.0" 200 22466703 "-" "Wget/1.12 (linux-gnu)"

Toujours pas convaincus du proxy transparent ?

Essayons de tronquer le fichier pour voir si la taille joue un rôle :

 $ dd if=test.flv of=test2.flv bs=1 count=8000000
 8000000+0 enregistrements lus
 8000000+0 enregistrements écrits
 8000000 bytes (8,0 MB) copied, 26,4951 s, 302 kB/s

Et miracle, ça passe !!

Avec une recherche dichotomique, on comprend très vite que la taille limite est précisément de 10 Mo (10*2^20 octets), au délà, un contenu de type video/x-flv est remplacé par la réponse 403 Forbidden.

Coupure de sessions TCP trop gourmandes

Un proxy ça reste gentil me direz-vous, mais voici quelque chose d'encore plus fort. Bouygues coupe pour vous toutes les sessions TCP qui dépassent 10 Mo en termes de volume reçu !!!

Prenons l'exemple d'une connexion SSH qui atteint lesdits 10 Mo :

 root@XXX:~# Write failed: Broken pipe

Et le magnifique dump 'Wireshark' sur la carte réseau du client :

 11158	214.451936	192.168.1.108	XXX			SSHv2	Encrypted request packet len=48
 11159	214.461449	XXX		192.168.1.108	SSHv2	Encrypted response packet len=1408
 11160	214.461604	XXX		192.168.1.108	TCP	ssh > 48450 RST, PSH, ACK Seq=9593089 Ack=88369 Win=92628 Len=128
 11161	214.531079	XXX		192.168.1.108	TCP	ssh > 48450 RST, ACK Seq=9591681 Ack=88417 Win=0 Len=0
 11162	214.553142	XXX		192.168.1.108	TCP	ssh > 48450 RST, ACK Seq=9591681 Ack=88465 Win=0 Len=0

Au segment 11159 on dépasse le quota des 10 Mo, notez bien le segment suivant qui arrive avec un flag RST (la présence de PSH suggère qu'il a juste été violemment ajouté par les équipements du réseau Bouygues). Et comme ce n'est pas assez, les segments restants (11161 et 11162) se prennent aussi des flags RST pour être bien sûr d'achever la connexion, du grand art !

Conclusion

Il est tout simplement scandaleux que ce service soit appelé "accès à Internet" ! Le réseau de Bouygues vous ment en essayent de se substituer aux réponses données par les vrais destinataires de vos connexions dans l'irrespect le plus total des protocoles réseau. On peut comprendre (mais sûrement pas accepter !) que les opérateurs essayent de défendre une économie vouée à mourir dans laquelle on vend séparément à prix d'or des services inclus dans une vraie connexion Internet : mail, vidéos ou même la téléphonie !

Ce genre de pratiques fait honte au domaine des télécoms et me rend très songeur quant à la perspective d'y travailler à la fin de mes études...

Notes

Mon article n'est en aucun cas une diffamation ou une accusation infondée, dans ma mesure où toutes les manipulations sont décrites avec précision et reproductibles avec un résultat sans équivoque.

La question générale de la neutralité d'Internet étant très intéressante, mais hors de la portée de cet article (plutôt technique), je vous invite fortement à voir les conférences de Benjamin Bayart : http://www.fdn.fr/minitel.avi

Si vous êtes chez d'autres opérateurs, je vous suggère d'étudier en détail votre connexion et à poster les détails ici, afin de comparer les différents réseaux.

Hexadecimal dump in C

Alexis Bezverkhyy — Thu, 13 Jan 2011 01:38:00 +0100

It can be very handy, in your C programs, to be able to print raw data in a UNIX xxd fashion. Here is a short function to do that :

hexdump.c :

#include <stdio.h>
#include <ctype.h>
 
#ifndef HEXDUMP_COLS
#define HEXDUMP_COLS 8
#endif
 
void hexdump(void *mem, unsigned int len)
{
        unsigned int i, j;
        
        for(i = 0; i < len + ((len % HEXDUMP_COLS) ? (HEXDUMP_COLS - len % HEXDUMP_COLS) : 0); i++)
        {
                /* print offset */
                if(i % HEXDUMP_COLS == 0)
                {
                        printf("0x%06x: ", i);
                }
 
                /* print hex data */
                if(i < len)
                {
                        printf("%02x ", 0xFF & ((char*)mem)[i]);
                }
                else /* end of block, just aligning for ASCII dump */
                {
                        printf("   ");
                }
                
                /* print ASCII dump */
                if(i % HEXDUMP_COLS == (HEXDUMP_COLS - 1))
                {
                        for(j = i - (HEXDUMP_COLS - 1); j <= i; j++)
                        {
                                if(j >= len) /* end of block, not really printing */
                                {
                                        putchar(' ');
                                }
                                else if(isprint(((char*)mem)[j])) /* printable char */
                                {
                                        putchar(0xFF & ((char*)mem)[j]);        
                                }
                                else /* other char */
                                {
                                        putchar('.');
                                }
                        }
                        putchar('\n');
                }
        }
}
 
#ifdef HEXDUMP_TEST
int main(int argc, char *argv[])
{
        hexdump(argv[0], 20);
 
        return 0;
}
#endif

hexdump.h

#ifndef _HEXDUMP_H
#define _HEXDUMP_H
 
void hexdump(void *mem, unsigned int len);
 
#endif

It can be tested as a standalone program (which dumps 20 bytes of memory strating at *argv) :

cc --ansi -DHEXDUMP_TEST -o hexdump hexdump.c
./hexdump
0x000000: 2e 2f 68 65 78 64 75 6d ./hexdum
0x000008: 70 00 53 53 48 5f 41 47 p.SSH_AG
0x000010: 45 4e 54 5f             ENT_

A script for splitting videos using ffmpeg

Alexis Bezverkhyy — Sat, 01 Jan 2011 22:07:00 +0100

Here is a small bash script for automatically cutting a video file into smaller chunks of fixed length. ffmpeg cannot output multiple files, but it has start offset and duration parameters which my script uses to actually split the file.

For example, if we have a video called 'video.mpeg' which is 3000 seconds long and we run

ffsplit.sh video.mpeg 1200

we will obtain three files : video-001.mpeg (1200 seconds), video-002.mpeg (1200 seconds) and video-003.mpeg (600 seconds).

#!/bin/bash
 
# Written by Alexis Bezverkhyy <alexis@grapsus.net> in 2011
# This is free and unencumbered software released into the public domain.
# For more information, please refer to <http://unlicense.org/>
 
function usage {
        echo "Usage : ffsplit.sh input.file chunk-duration [output-filename-format]"
        echo -e "\t - input file may be any kind of file reconginzed by ffmpeg"
        echo -e "\t - chunk duration must be in seconds"
        echo -e "\t - output filename format must be printf-like, for example myvideo-part-%04d.avi"
        echo -e "\t - if no output filename format is given, it will be computed\
 automatically from input filename"
}
 
IN_FILE="$1"
OUT_FILE_FORMAT="$3"
typeset -i CHUNK_LEN
CHUNK_LEN="$2"
 
DURATION_HMS=$(ffmpeg -i "$IN_FILE" 2>&1 | grep Duration | cut -f 4 -d ' ')
DURATION_H=$(echo "$DURATION_HMS" | cut -d ':' -f 1)
DURATION_M=$(echo "$DURATION_HMS" | cut -d ':' -f 2)
DURATION_S=$(echo "$DURATION_HMS" | cut -d ':' -f 3 | cut -d '.' -f 1)
let "DURATION = ( DURATION_H * 60 + DURATION_M ) * 60 + DURATION_S"
 
if [ "$DURATION" = '0' ] ; then
        echo "Invalid input video"
        usage
        exit 1
fi
 
if [ "$CHUNK_LEN" = "0" ] ; then
        echo "Invalid chunk size"
        usage
        exit 2
fi
 
if [ -z "$OUT_FILE_FORMAT" ] ; then
        FILE_EXT=$(echo "$IN_FILE" | sed 's/^.*\.\([a-zA-Z0-9]\+\)$/\1/')
        FILE_NAME=$(echo "$IN_FILE" | sed 's/^\(.*\)\.[a-zA-Z0-9]\+$/\1/')
        OUT_FILE_FORMAT="${FILE_NAME}-%03d.${FILE_EXT}"
        echo "Using default output file format : $OUT_FILE_FORMAT"
fi
 
N='1'
OFFSET='0'
let 'N_FILES = DURATION / CHUNK_LEN + 1'
 
while [ "$OFFSET" -lt "$DURATION" ] ; do
        OUT_FILE=$(printf "$OUT_FILE_FORMAT" "$N")
        echo "writing $OUT_FILE ($N/$N_FILES)..."
        ffmpeg -i "$IN_FILE" -vcodec copy -acodec copy -ss "$OFFSET" -t "$CHUNK_LEN" "$OUT_FILE"
        let "N = N + 1"
        let "OFFSET = OFFSET + CHUNK_LEN"
done

Lightweight HTTP server in BASH with PHP support

Alexis Bezverkhyy — Wed, 15 Sep 2010 00:06:00 +0200

No kidding, I wrote this HTTP server in Bourne Shell. It supports most of HTTP 1.0 headers, Keep-alive requests, directory listing and PHP scripts. By its nature, this piece of software is not secure (it is fun though) and isn't intended for production purposes : <insert the usual NO WARRANTY boilerplate bullshit here>.

I tested it with PHPMyAdmin which I consider to be heavy PHP software and it works pretty well. It is not well commented, really I just wrote it for fun, learning BASH and HTTP protocol.

#!/bin/bash
 
# Written by Alexis Bezverkhyy <alexis@grapsus.net> in 2008
# This is free and unencumbered software released into the public domain.
# For more information, please refer to <http://unlicense.org/>
 
# This script should be run via inetd, first parameter is WWW root path
 
# Uncomment for debugging
#exec 2>/tmp/log ; set -x
 
NUM="$RANDOM"
DOCUMENT_ROOT="$1"
KEEP_ALIVE="keep-alive"
 
while [ "$KEEP_ALIVE" == "keep-alive" ] ; do
KEEP_ALIVE="close"
 
for i in seq 1 5; do
  read -t 5 line
  if [ -n "$line" ] ; then break; fi
done
 
if grep -sqv 'HTTP' <<< "$line" ; then exit ; fi
#echo `date`" BEGIN $line" >> /tmp/"$NUM"-log
 
REQUEST_METHOD=`cut -d ' ' -f 1 <<< "$line"`
REQUEST_URI=`cut -d ' ' -f 2 <<< "$line" | sed 's/%20/ /'`
SCRIPT_NAME=`cut -d '?' -f 1 <<< "$REQUEST_URI"`
SCRIPT_FILENAME=`sed -e 's#//#/#' -e 's#/$##' <<< "$DOCUMENT_ROOT$SCRIPT_NAME"`
QUERY_STRING=''
if grep -sq '?' <<< "$REQUEST_URI" ; then
  QUERY_STRING=`cut -d '?' -f 2 <<< "$REQUEST_URI"`
fi
 
while read -t 1 line ; do
  line=`strings <<< "$line"`
  if grep -sqi '^Content-length' <<< "$line" ; then
    CONTENT_LENGTH=`cut -d ' ' -f 2 <<< "$line"`
  elif grep -sqi '^Content-type' <<< "$line" ; then
    CONTENT_TYPE=`cut -d ' ' -f 2 <<< "$line"`
  elif grep -sqi '^Connection' <<< "$line" ; then
    KEEP_ALIVE=`cut -d ' ' -f 2 <<< "$line"`
  elif grep -sqi '^Cookie' <<< "$line" ; then
    HTTP_COOKIE=`sed 's/Cookie:[ ]*//i' <<< "$line"`
  fi
  if [ -z "$line" -a "$REQUEST_METHOD" == "POST" -a -n "$CONTENT_LENGTH" ] ; then
    read -n "$CONTENT_LENGTH" line
    echo "$line" > /tmp/"$NUM"-post
    break
  elif [ -z "$line" ] ; then
    break
  fi
done
 
# some security
if grep -sq '\.\.' <<< "$SCRIPT_FILENAME" || ( namei "$SCRIPT_FILENAME" | grep -sq '\->') ; 
then
  SCRIPT_FILENAME='./'  
fi
 
if [ -d "$SCRIPT_FILENAME" ] ; then
  echo -en 'HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n'
  dir=`sed 's#'"$DOCUMENT_ROOT"'##' <<< "$SCRIPT_FILENAME"`
  if [ -z "$dir" ] ; then
    dir='/' ; parent='/'
  else
    parent=`sed 's#/[^/]\+$##' <<< "$dir"`
    if [ -z "$parent" ] ; then parent='/' ; fi
  fi
  echo "<html><head><title>Index of $dir</title></head>
  <body><h3>Index of $dir</h3>
  <table>
    <tr>
      <td><b>Name</b></td>
      <td><b>Last modified</b></td>
      <td><b>Size</b></td>
    </tr>
    <tr><td colspan=\"3\">[D] <a href=\"$parent\">..</a></td></tr>"
  for item in "$SCRIPT_FILENAME"/* ; do
    if [ "$item" == "$SCRIPT_FILENAME"'/*' ] ; then break ; fi
    name=`basename "$item"`
    link=`sed 's#'"$DOCUMENT_ROOT"'##' <<< "$item"`
    stat=`ls -lhd --time-style='+%d-%m-%y#%H:%m' "$item"`
    mtime=`cut -d ' ' -f 6 <<< "$stat" | sed 's/#/ /'`
    size=`cut -d ' ' -f 5 <<< "$stat"`
    echo "<tr><td>"
    if [ -L "$item" ] ; then
      echo "[S] $name<br/>"
    elif [ -d "$item" ] ; then
      echo '[D] <a href="'"$link"'">'"$name"'</a><br/>'
    else
      echo '[F] <a href="'"$link"'">'"$name"'</a><br/>'
    fi
    echo "</td><td>$mtime</td><td>$size</td></tr>"
  done
  echo "</table></body></html>"
elif [ -f "$SCRIPT_FILENAME" ] ; then
  mime='text/html'
  if grep -Esqv '\.(php|htm|html)$' <<< "$SCRIPT_FILENAME" ; then
    mime=`file -b --mime-type $SCRIPT_FILENAME`
  fi
  if grep -sq '\.php$' <<< "$SCRIPT_FILENAME" ; then
    for var in `env | cut -d '=' -f 1` ; do
      if [ "$var" != "PATH" -a "$var" != "PWD" -a "$var" != "LANG" -a "$var" != "SHLVL" ] ; then
        export -n "$var"
      fi
    done
    export REQUEST_URI REQUEST_METHOD QUERY_STRING DOCUMENT_ROOT SCRIPT_FILENAME \
    SCRIPT_NAME CONTENT_LENGTH CONTENT_TYPE GATEWAY_INTERFACE='CGI/1.1' \
    HTTP_HOST=`hostname -i` HTTP_COOKIE REDIRECT_STATUS=1
    if [ "$REQUEST_METHOD" == "GET" ] ; then
      php-cgi $SCRIPT_FILENAME \
      `tr '&' ' ' <<< "$QUERY_STRING"` > /tmp/"$NUM"-php
    else
      php-cgi $SCRIPT_FILENAME \
      `tr '&' ' ' <<< "$QUERY_STRING"` > /tmp/"$NUM"-php < /tmp/"$NUM"-post
    fi
    HTTP_STATUS=`grep -i '^Status: .*$' /tmp/"$NUM"-php | cut -d ' ' -f 2`
    if [ -z "$HTTP_STATUS" ] ; then
      HTTP_STATUS='200'
    fi
    OUT="head"
    cat /tmp/"$NUM"-php | while read ; do
      if [ "$OUT" = 'head' ] ; then
        REPLY=$(strings <<< "$REPLY")
        if [ -z "$REPLY" ] ; then
          OUT='body'
          continue
        fi
      fi
      echo "$REPLY" >> /tmp/"$NUM"-php-"$OUT"
    done
    echo -en "HTTP/1.0 $HTTP_STATUS OK\r\nContent-type: $mime\r\nContent-length:"\
    `ls -l /tmp/"$NUM"-php-body | cut -d ' ' -f 5`"\r\nConnection: $KEEP_ALIVE\r\n"
    cat /tmp/"$NUM"-php-head
    echo -en "\r\n"
    cat /tmp/"$NUM"-php-body
  else
    echo -en "HTTP/1.0 200 OK\r\nContent-type: $mime\r\nContent-length: "\
    `ls -l "$SCRIPT_FILENAME" | cut -d ' ' -f 5`"\r\nConnection: $KEEP_ALIVE\r\n\r\n"
    cat "$SCRIPT_FILENAME"
  fi
  rm -f /tmp/"$NUM"-php /tmp/"$NUM"-php-body /tmp/"$NUM"-php-head /tmp/"$NUM"-post 
  # /tmp/"$NUM"-log
else
  echo -en 'HTTP/1.0 404 NOT FOUND\n\rContent-type: text/plain\r\n\r\n404 File not found'
fi
#echo `date`" END" >> /tmp/"$NUM"-log
done

Here's the inetd configuration I use to run it :

8080	stream	tcp	nowait	grapsus	/usr/sbin/tcpd /home/grapsus/bin/http.sh /home/grapsus/www

I know BASH supports sockets, but this support is disabled in most Unix distributions (especially on Debian).

Let me know what you think about it or the improvements you made.

PHP tricks : generate an MS Excel file

Alexis Bezverkhyy — Sun, 12 Sep 2010 10:31:00 +0200

Here's the shortest and the fastest way I found to convert a CSV file to MS Excel format. It supports string and numeric fields. I hope this function can avoid you using huge Excel PHP classes which are too complicated and slow (and require reading a lot of documentation) for such a basic task.

/* Written by Alexis Bezverkhyy <alexis@grapsus.net> in September 2010
 * This is free and unencumbered software released into the public domain.
 * For more information, please refer to <http://unlicense.org/> */
 
/** Convert a CSV file to MS Excel format
 * 
 * @param string $in input file
 * @param string $out output
 * @param string $glue CSV glue
 * @param string $enclosure CSV enclosure character
 */
function csv2xls($in, $out, $glue=";", $enclosure='"')
{
        $fp_in = fopen($in, "r");
        $fp_out = fopen($out, "w");
        
        /* write Excel BOF */
        fputs($fp_out, pack("ssssss", 0x809, 0x8, 0x0, 0x10, 0x0, 0x0));
        
        /* Read CSV fields */
        for($row = 0; $fields = fgetcsv($fp_in, 0, $glue, $enclosure); $row++)
        {
                foreach($fields as $col=>$value)
                {
                        $value = trim($value);
                        $value = utf8_decode($value);
                        
                        /* string cell */
                        if(!is_numeric($value))
                        {
                                $l = strlen($value);
                                fputs($fp_out,
                                        pack("ssssss", 0x204, 8 + $l, $row, $col, 0x0, $l).$value);
                        }
                        /* numeric cell */
                        else 
                        {
                                fputs($fp_out,
                                        pack("sssss", 0x203, 14, $row, $col, 0x0).pack("d", $value));
                        }
                }
        }
        
        /* write Excel EOF */
        fputs($fp_out, pack("ss", 0x0A, 0x00));
        
        fclose($fp_out);
        fclose($fp_in);
}