Fonctionnement du Karotz (OS)

#!/usr/bin/python

import os
import sys
import shutil
import network
#import time
from encodings import hex_codec
import simplejson as json

# answears "iamkarotz" to "karotz_ping"
def ping(line):
    return {'response':'OK'}

def start_syslogd(cmd):
    open('/etc/conf/enable_syslogd','w').close()
    res = 0
    running = os.system('pidof syslogd > /dev/null')
    if running != 0:
        res = os.system("/sbin/syslogd 2>/dev/null")
    if res != 0:
        return {'response':'ERROR'}
    else:
        return {'response':'OK'}

def stop_syslogd(cmd):
    if os.path.exists('/etc/conf/enable_syslogd'):
        os.unlink('/etc/conf/enable_syslogd')
    os.system("/bin/killall syslogd 2>/dev/null")
    return {'response':'OK'}

def get_syslogd(cmd):
    logs=""
    numLine = 100
    if "lines" in cmd:
        numLine = cmd["lines"]
    if os.path.exists('/var/log/messages'):
        logCmd = os.popen("tail -n %d /var/log/messages" % (numLine))
        logs = logCmd.read()
        logCmd.close()
    return {'response':'OK', 'log': logs}

def set_pass(cmd):
    if 'pwd' not in cmd:
        return {'response':'ERROR', 'desc':'need password'}

    try:
        file = open('/etc/conf/voos.conf', 'w')
        file.write('[voos]\n')
        file.write('id=')
        file.write(__get_id())
        file.write('\npwd=')
        file.write(cmd['pwd'])
        file.write('\n')
        file.close()
    except:
        return {'response':'ERROR', 'desc':'cannot write config'}

    return {'response':'OK'}

def reboot(cmd):
    os.system("(sleep 3 ; /sbin/reboot) &")
    return {'response':'OK'}

def get_id(cmd):
    return {'response':'OK', 'id': __get_id()}

def get_sys_version(cmd):
    file = "/etc/conf/sys_version"
    if not os.path.exists(file):
        return {'response':'ERROR', 'desc':'cannot find file'}
    fs_version_file = open(file)
    fs_version = fs_version_file.read().strip()
    fs_version_file.close()
    return {'response':'OK', 'version': fs_version}

def get_rootfs_version(cmd):
    file = "/etc/conf/rootfs_version"
    if not os.path.exists(file):
        return {'response':'ERROR', 'desc':'cannot find file'}
    fs_version_file = open(file)
    fs_version = fs_version_file.read().strip()
    fs_version_file.close()
    return {'response':'OK', 'version': fs_version}

def __get_mac(interface="wlan0"):
    if interface != "eth0":
        interface = "wlan0"
    macCmd = os.popen("ifconfig | egrep '^" + interface + "'")
    macAddress = macCmd.readline().strip().split()[-1]
    macCmd.close()
    return macAddress;

def get_mac(cmd):
    interface="wlan0"
    if 'interface' in cmd:
        interface = cmd['interface']
    try:
        return {'response':'OK', 'mac': __get_mac(interface)}
    except:
        return {'response':'ERROR'}

def get_networks(cmd):
    return {'response':'OK', 'networks': network.get_networks()}

def set_wifi(cmd, save=True):
    if 'encryption' not in cmd:
        return {'response':'ERROR', 'desc':'need encryption'}
    if 'ssid' not in cmd:
        return {'response':'ERROR', 'desc':'need ssid'}
       
    result = -1
    if cmd['encryption'] == 'open':
        result = network.connect_open(cmd['ssid'])
    elif cmd['encryption'] == 'wep':
        if 'key' not in cmd:
            return {'response':'ERROR', 'desc':'need key'}
        result = network.connect_wep(cmd['ssid'], cmd['key'])
    elif cmd['encryption'] == 'wpa' or cmd['encryption'] == 'wpa2':
        if 'settings' not in cmd:
            return {'response':'ERROR', 'desc':'need settings'}
        result = network.set_wpa_supplicant(cmd["settings"])
    if result == 0:
        if save:
            wifiFile = open("/etc/conf/wifi.conf", "w")
            wifiFile.write(cmd["__orig__"])
            wifiFile.close()
        return {'response':'OK'}
    else:
        return {'response':'ERROR'}
       
def load_wifi():
    wifiFile = open("/etc/conf/wifi.conf", "r")
    set_wifi(json.loads(wifiFile.read()), False);
    wifiFile.close()
       
def get_ip(cmd):
    interface = "wlan0"
    if 'interface' in cmd and cmd['interface']=="eth0":
        interface = "eth0"
    return {'response':'OK', 'ip' : network.get_ip(interface)};     
       
def set_ip(cmd, save=True):
    interface = "wlan0"
    if 'interface' in cmd and cmd['interface']=="eth0":
        interface = "eth0"
    if 'dhcp' in cmd and cmd['dhcp'] == True:
        network.set_dynamic_ip(interface)

    else:
        if 'ip' not in cmd:
            return {'response':'ERROR', 'desc':'need ip'}
        if 'netmask' not in cmd:
            return {'response':'ERROR', 'desc':'need netmask'}
        if 'gateway' not in cmd:
            return {'response':'ERROR', 'desc':'need gateway'}
        if 'nameserver' not in cmd:
            return {'response':'ERROR', 'desc':'need nameserver'}
       
        network.set_static_ip(cmd['ip'], cmd['netmask'], cmd['gateway'], cmd['nameserver'],interface)

    if save :
        ipFile = open("/etc/conf/ip_%s.conf" % (interface), "w")
        ipFile.write(cmd["__orig__"])
        ipFile.close()
    return {'response':'OK'}

def load_ip(interface):
    if interface != "eth0":
        interface = "wlan0"
    ipFile = open("/etc/conf/ip_%s.conf" % (interface), "r")
    set_ip(json.loads(ipFile.read()), False);
    ipFile.close()

def get_wifi_status(cmd):
    return {'response':'OK', 'status': network.get_wifi_status()}
   
def is_connected(cmd):
    if network.is_connected() == 0:
        return {'response':'OK'}
    else:
        return {'response':'ERROR'}

def __get_id():
    global uniqueId
    if uniqueId == None:
        macCmd = os.popen("echo "+ __get_mac() +" 'AC353EFA-2B04-45BA-9BDA-FEEFA43BB640' | md5sum | cut -d' ' -f1")
        uniqueId = macCmd.readline().strip()
        macCmd.close()
    return uniqueId

def set_country(cmd):
    if 'code' not in cmd:
        return {'response':'ERROR', 'desc':'need code'}
    result = network.set_wifi_country(cmd["code"])
    if result == 0:
        return {'response':'OK'}
    else:
        return {'response':'ERROR'}
    return

def get_iwlist(cmd):
    result = network.get_iwlist()
    return {'response':'OK', 'data': result}

def get_version(cmd):
    return {'response':'OK', 'version': 1.0}
   
uniqueId=None

cmdTab = {
    'ping':ping,
    'start_syslogd':start_syslogd,
    'stop_syslogd':stop_syslogd,
    'get_syslogd':get_syslogd,
    'set_pass':set_pass,
    'reboot':reboot,
    'get_id':get_id,
    'get_sys_version':get_sys_version,
    'get_rootfs_version':get_rootfs_version,
    'get_mac':get_mac,
    'get_networks':get_networks,
    'set_wifi':set_wifi,
    'set_ip':set_ip,
    'get_ip':get_ip,
    'is_connected':is_connected,
    'set_country':set_country,
    'get_iwlist':get_iwlist,
    'get_version':get_version,
    'get_wifi_status':get_wifi_status
}

def onReceivedLine(line):
    try:
        if len(line) > 0:
            cmdJson = json.loads(line)
            cmdJson["__orig__"]=line
            cmd = cmdJson["cmd"]
            if cmd in cmdTab:
                resultPython = cmdTab[cmd](cmdJson)
                resultJson = json.dumps(resultPython, sort_keys=True, indent=4)
                lines = resultJson.count('\n')
                serialFileW.write(str(lines+1)+'\n')
                serialFileW.write(resultJson+'\n')
            else:
                serialFileW.write('1\n')
                serialFileW.write(json.dumps({'response':'ERROR', 'desc':"command '%s' doesn't exists" % (cmd) })+'\n')
            return True;
        else:
            return False;
    except Exception, e:
        serialFileW.write('1\n')
        serialFileW.write(json.dumps({'response':'ERROR'})+'\n')
        raise e

def main():
    global serialFileW
    global serialFileR
    ttyDevice = "/dev/ttyGS0";
   

   
    cmd_line = raw_input().strip()
   
    if sys.argv.count('--cmd') > 0:
        serialFileR=sys.stdin
        serialFileW=sys.stdout
       
        onReceivedLine(cmd_line)
        sys.exit(0)
       
    serialFileW = open(ttyDevice, "w")
    serialFileR = open(ttyDevice, "r")
    # read command and obey
    while onReceivedLine(cmd_line):
        cmd_line = serialFileR.readline().strip()

if __name__ == "__main__":
    main()

#!/usr/bin/python
#
# iwlistparse.py
# Hugo Chargois - 17 jan. 2010 - v.0.1
# https://bbs.archlinux.org/viewtopic.php?pid=761899
# Parses the output of iwlist scan into a table

import sys

def get_name(cell):
    return matching_line(cell,"ESSID:")[1:-1]

def get_quality(cell):
    quality = matching_line(cell,"Quality=").split()[0].split('/')
    return int(round(float(quality[0]) / float(quality[1]) * 100))

def get_channel(cell):
    return int(matching_line(cell,"Channel:"))

def get_encryption(cell):
    enc=""
    if matching_line(cell,"Encryption key:") == "off":
        enc="Open"
    else:
        for line in cell:
            matching = match(line,"IE:")
            if matching!=None:
                if detect(matching, "WPA Version"):
                    enc="WPA"
                if detect(matching, "IEEE 802.11i/WPA2 Version"):
                    enc="WPA2"
        if enc=="":
            enc="WEP"
    return enc

def get_encryption_detail(cell):
    enc=""
    for line in cell:
        matching = match(line,"Group Cipher : ")
        if matching!=None:
            enc=matching
        matching = match(line,"Authentication Suites (1) : ")
        if matching!=None:
            if matching == "802.1x":
                enc=enc+"/"+"EAP"
            else:
                enc=enc+"/"+matching
    return enc

def get_address(cell):
    return matching_line(cell,"Address: ")

# Here's a dictionary of rules that will be applied to the description of each
# cell. The key will be the name of the column in the table. The value is a
# function defined above.

rules={"Name":get_name,
      "Quality":get_quality,
      "Channel":get_channel,
      "Encryption":get_encryption,
      "Address":get_address,
      "Detail":get_encryption_detail,
      }

# Here you can choose the way of sorting the table. sortby should be a key of
# the dictionary rules.

def sort_cells(cells):
    sortby = "Quality"
    reverse = True
    cells.sort(None, lambda el:el[sortby], reverse)

# You can choose which columns to display here, and most importantly in what order. Of
# course, they must exist as keys in the dict rules.

columns=["Name","Address","Quality","Channel","Encryption", "Detail"]

# Below here goes the boring stuff. You shouldn't have to edit anything below
# this point

def matching_line(lines, keyword):
    """Returns the first matching line in a list of lines. See match()"""
    for line in lines:
        matching=match(line,keyword)
        if matching!=None:
            return matching
    return None

def match(line,keyword):
    """If the first part of line (modulo blanks) matches keyword,
    returns the end of that line. Otherwise returns None"""
    line=line.lstrip()
    length=len(keyword)
    if line[:length] == keyword:
        return line[length:]
    else:
        return None

def detect(line, keyword):
    line=line.lstrip()
    length=len(keyword)
    if line[:length] == keyword:
        return 1
    else:
        return 0


def parse_cell(cell):
    """Applies the rules to the bunch of text describing a cell and returns the
    corresponding dictionary"""
    parsed_cell={}
    for key in rules:
        rule=rules[key]
        parsed_cell.update({key:rule(cell)})
    return parsed_cell

def print_table(table):
    # widths=map(max,map(lambda l:map(len,l),zip(*table))) #functional magic

    justified_table = []
    for line in table:
        justified_line=[]
        for i,el in enumerate(line):
            justified_line.append(str(el).ljust(30))
            # justified_line.append(el.ljust(widths[i]+2))
        justified_table.append(justified_line)
   
    for line in justified_table:
        for el in line:
            print el,
        print

def get_networks(list):
    cells=[[]]
    parsed_cells=[]

    for line in list:
        cell_line = match(line,"Cell ")
        if cell_line != None:
            cells.append([])
            line = cell_line[-27:]
        cells[-1].append(line.rstrip())

    cells=cells[1:]

    for cell in cells:
        parsed_cells.append(parse_cell(cell))

    sort_cells(parsed_cells)

    return parsed_cells

#!/usr/bin/python

import os
import iwlist
import time
import re

# Network interfaces

def lo_up():
    return os.system("ifconfig lo up")

def wlan0_up():
    return os.system("ifconfig wlan0 up")

def wlan0_down():
    return  os.system("ifconfig wlan0 down")

def eth0_up():
    return os.system("ifconfig eth0 up")

def eth0_down():
    return  os.system("ifconfig eth0 down")


def reset_networks():
    os.system("killall -9 wpa_supplicant")
    # os.system("killall -9 udhcpc")
    os.system("echo nameserver 8.8.8.8 > /etc/resolv.conf")

def get_networks():
    wlan0_up()
    list = os.popen("iwlist wlan0 scan")
    tab = list.readlines()
    list.close()
    return iwlist.get_networks(tab)

def get_iwlist():
    wlan0_up()
    command = os.popen("iwlist wlan0 scan")
    result = command.read()
    command.close()
    return result

def set_wifi_country(alpha2):
    if not re.match("[A-Z]{2}", alpha2):
        return 1
    f = open("/etc/conf/wifi_country.conf", "w")
    f.write(alpha2)
    f.close()
    return 0

def connect_open(ssid):
    wlan0_down()
    wlan0_up()
    return os.spawnl(os.P_WAIT, '/sbin/iwconfig', '/sbin/iwconfig', 'wlan0', 'essid', ssid, 'channel', 'auto', 'key', 'off')

def connect_wep(ssid, key):
    wlan0_down()
    wlan0_up()
    return os.spawnl(os.P_WAIT, '/sbin/iwconfig', '/sbin/iwconfig', 'wlan0', 'essid', ssid, 'key', key)

def set_wpa_supplicant(dict):
    reset_networks()
    wlan0_down()
    wlan0_up()
    f = open("/etc/conf/wpa.conf", "w")
    f.write("network={\n")
   
    for k, v in dict.iteritems():
        f.write("%s=%s\n" % (k,v))   

    f.write("}\n")
    f.close()
    return os.system("wpa_supplicant -iwlan0 -Dwext -B -c /etc/conf/wpa.conf")

def get_wifi_status():
    result = "Not-Associated"
    command = os.popen("iwconfig wlan0 | grep 'Access Point'")
    try:
        result = re.search("Access Point: ([^ ]*)", command.read()).group(1)
    except:
        pass
    command.close()
    return result

def kill_dhcp(interface="wlan0"):
    if interface != "eth0":
        interface="wlan0"

    p_cmd = os.popen("ps | egrep 'udhcpc.*%s' | grep -v egrep" % (interface))
    p_str=p_cmd.read()
    p_cmd.close()
   
    if p_str != "":
        pid = p_str.strip().split()[0]
        os.system("kill -9 "+pid)


def set_dynamic_ip(interface="wlan0"):
    kill_dhcp(interface)
    if interface == "wlan0":
        os.system("udhcpc -A5 -i wlan0 -s /karotz/scripts/udhcpc_script.sh &")
    if interface == "eth0":
        if eth0_up() == 0:
            os.system("udhcpc -A5 -i eth0 -s /karotz/scripts/udhcpc_script.sh &")

def set_static_ip(ip, netmask, gateway, nameserver, interface="wlan0"):
    if ip == "" or netmask == "" or gateway == "" or nameserver == "" or interface == "":
        return 1

    kill_dhcp(interface)
   
    if interface == "wlan0":
        if os.spawnl(os.P_WAIT, '/sbin/ifconfig', '/sbin/ifconfig', 'wlan0', ip, 'netmask', netmask) !=0: return 1
    elif interface == "eth0":
        if eth0_up() == 0:
            if os.spawnl(os.P_WAIT, '/sbin/ifconfig', '/sbin/ifconfig', 'eth0', ip, 'netmask', netmask) !=0: return 1
    else:
        return 1

    if os.spawnl(os.P_WAIT, '/sbin/route', '/sbin/route', 'add', 'default', 'gw', gateway) !=0: return 1

    try:
        f = open("/etc/resolv.conf", "w")
        f.write("nameserver "+nameserver+"\n")
        f.close()
    except:
        return 1
   
    return 0

def is_connected():
    return os.system("ping -q -c1 platform.karotz.com")

def get_ip(interface="wlan0"):
    if interface != "eth0":
        interface = "wlan0"
    if interface == "wlan0":
        ifCmd = os.popen("ifconfig wlan0 | grep 'inet addr'")
    else:
        ifCmd = os.popen("ifconfig eth0 | grep 'inet addr'")

    try:
        result = re.search("inet addr:([^ ]*)", ifCmd.read()).group(1)
    except:
        result=""
   
    ifCmd.close()
    return result;

# Connection functions
def wait_wifi_status(timeout):
    start=time.time()
    while time.time() - start < timeout:
        res = get_wifi_status()
        if res != "Not-Associated": return True
        time.sleep(1)
    return False

def wait_ip(timeout):
    start=time.time()
    while time.time() - start < timeout:
        if is_connected() == 0: return True
        time.sleep(1)
    return False 

#!/bin/bash

ZIMAGE_MD5=b771be3ab18de244cb6556082de80b64
ZIMAGE_SIZE=2314316
ROOTFS_MD5=2b432f72035f6aa6c1e56362ff600bf7
ROOTFS_SIZE=3064162
YAFFS_MD5=160bda9334ce7d5a1b012fdfd9000cc9
YAFFS_SIZE=2178568

LED=/karotz/bin/led

function led_orange_pulse {
    killall led
    $LED -l ff6600 -p 000000 -d 700 &
}

function led_red {
    killall led
    $LED -l ff0000
}

function led_green {
    killall led
    $LED -l 00ff00
}

function error_fail {
 $LED -l ff0000
while /bin/true ; do
  $LED -l 000000
  sleep 1
  $LED -l ff0000
  sleep 1
done
exit 1
}

#parmam $1 : zimage  $2 : partition , $3 : taille de l image $4 md5
function write_partition {
   echo write /tmp/$1 dans /dev/$2 de taille $3 sz md5 $4
   cp /mnt/usbkey/$1 /tmp/$1
    ACTUAL_MD5=$(/bin/md5sum /tmp/$1 | cut -d' ' -f1)
    if [ ! "$4"    == "$ACTUAL_MD5" ] ; then
      led_red
      echo "bad $2 md5"
      error_fail
      exit 1
    fi   
    /sbin/flash_eraseall /dev/$2
    /sbin/nandwrite -pm /dev/$2 /tmp/$1
    nanddump -o -b -f  /tmp/${1}_dump  /dev/$2 # copie le contenu de la nand en ignorant les badbloc et octet de control interne de la flash
    head -c $3 /tmp/${1}_dump > /tmp/${1}_dumphead #le zimage se trouve en debut de partition
    diff /tmp/$1 /tmp/${1}_dumphead
    if [ $? -eq 0 ] ; then
        echo  write $1 ok
    else
        led_red
        echo error write $1
        error_fail
        exit 1
    fi
    rm /tmp/${1}*
}


cd $(dirname $0)

ps | grep "hotplug.sh" | grep -v grep
if [ $? -eq 0 ] ; then
    echo "hotplug found"
    exit 1
fi

led_orange_pulse

## verify md5sums
for FILE in zImage rootfs.img.gz yaffs_factory.tar.gz.encoded ; do
    [ -f "/mnt/usbkey/$FILE" ] || { echo "no file /mnt/usbkey/$FILE" ; error_fail ; exit 1 ;}
done

#ACTUAL_ZIMAGE_MD5=$(/bin/md5sum /mnt/usbkey/zImage | cut -d' ' -f1)
#ACTUAL_ROOTFS_DEV_MD5=$(/bin/md5sum /mnt/usbkey/rootfs-dev.img.gz | cut -d' ' -f1)
#ACTUAL_ROOTFS_PROD_MD5=$(/bin/md5sum /mnt/usbkey/rootfs-prod.img.gz | cut -d' ' -f1)
#ACTUAL_YAFFS_DEV_MD5=$(/bin/md5sum /mnt/usbkey/yaffs-dev.tar.gz | cut -d' ' -f1)
#ACTUAL_YAFFS_PROD_MD5=$(/bin/md5sum /mnt/usbkey/yaffs-prod.tar.gz | cut -d' ' -f1)

## okay everything is clear, let's rock

# flash zImage
echo "## zImage rescue"
write_partition zImage mtd3 $ZIMAGE_SIZE $ZIMAGE_MD5

echo "## rootfs.img.gz rescue"
write_partition rootfs.img.gz mtd4 $ROOTFS_SIZE $ROOTFS_MD5

echo "## yaffs_factory.tar.gz.encoded rescue"
write_partition yaffs_factory.tar.gz.encoded mtd5 $YAFFS_SIZE $YAFFS_MD5

echo "## zImage "
write_partition zImage mtd1 $ZIMAGE_SIZE $ZIMAGE_MD5

echo "## rootfs.img.gz "
write_partition rootfs.img.gz mtd2 $ROOTFS_SIZE $ROOTFS_MD5

# erase yaffs
echo "## erasing yaffs"
/bin/umount /usr
/sbin/flash_eraseall /dev/mtd6

# get yaffs_rescue
/bin/mount -t yaffs /dev/mtdblock6 /usr
/sbin/nanddump -nbo -f /tmp/yaffs_rescue /dev/mtd5
/sbin/yaffs_rescue_decode /tmp/yaffs_rescue - | gzip -d -c | tar x -C /usr/
rm /tmp/yaffs_rescue
sleep 1
/bin/umount /usr
led_green

echo "## All done. Remove USB and reboot."

while /bin/true ; do
  $LED -l 000000
  sleep 1
  $LED -l 00ff00
  sleep 1
done

root: [UPDATE] updating yaffs.
root: [UPDATE] sys version: 10.10.10.10.
root: [UPDATE] rootfs version: 11.03.12.00.
root: Stopping yaffs
killall: immortaldog: no process killed
killall: led: no process killed
root: [UPDATE] checking integrity.
root: Stopping yaffs
killall: immortaldog: no process killed
killall: led: no process killed
root: [UPDATE] cleanup_yaffs.
0: [UPDATE] extract.
   0: [UPDATE] pre_install.
0: [UPDATE] extracting rootfs system from the yaffs package.
0: [UPDATE] installing EABI rootfs.
0: [ROOTFS INSTALL] flash erasing /dev/mtd1
Erasing 128 Kibyte @ 2e0000 -- 95 % complete.
0: [ROOTFS INSTALL] writing new zImage
Writing data to block 0
(…)
Writing data to block 220000
0: [ROOTFS INSTALL] flash erasing /dev/mtd2
Erasing 128 Kibyte @ 4e0000 -- 97 % complete.
0: [ROOTFS INSTALL] writing new rootfs
Writing data to block 0
Writing data to block 20000
(…)
Writing data to block 300000
0: [UPDATE] extract_sys.
0: [UPDATE] post_install.
0: [UPDATE] cleanup.
0: [UPDATE] Reboot !
save exit: isCheckpointed 1
killall: led: no process killed
save exit: isCheckpointed 1
umount: can't remount /dev/mtdblock6 read-only
umount: none busy - remounted read-only
The system is going down NOW!
Sent SIGTERM to all processes
Sent SIGKILL to all processes
save exit: isCheckpointed 1
Requesting system reboot

root: [START] checking updates.
root: [UPDATE] updating rootfs.
root: [UPDATE] rootfs version: 11.04.01.00
root: [UPDATE] downloading new rootfs.
root: Stopping yaffs
killall: immortaldog: no process killed
killall: led: no process killed
killall: led: no process killed
root: [UPDATE] Checking integrity.
root: [UPDATE] installing new rootfs.
root: [ROOTFS INSTALL] flash erasing /dev/mtd1
Erasing 128 Kibyte @ 2e0000 -- 95 % complete.
root: [ROOTFS INSTALL] writing new zImage
Writing data to block 0 at offset 0x0
Writing data to block 1 at offset 0x20000
(…)
Writing data to block 17 at offset 0x220000
root: [ROOTFS INSTALL] flash erasing /dev/mtd2
Erasing 128 Kibyte @ 4e0000 -- 97 % complete.
root: [ROOTFS INSTALL] writing new rootfs
Writing data to block 0 at offset 0x0
Writing data to block 1 at offset 0x20000
(…)
Writing data to block 24 at offset 0x300000
root: [UPDATE] Reboot !
save exit: isCheckpointed 1
umount: /dev/mtdblock6 busy - remounted read-only
umount: none busy - remounted read-only
umount: ramfs busy - remounted read-only
The system is going down NOW!
Sent SIGTERM to all processes
Sent SIGKILL to all processes
Requesting system reboot

root: [START] checking updates.
root: [UPDATE] updating rootfs.
root: [UPDATE] rootfs version: 11.07.07.00
root: [UPDATE] up to date.
root: [UPDATE] updating yaffs.
root: [UPDATE] sys version: 11.04.01.01.
root: [UPDATE] rootfs version: 11.07.07.00.

POST /tts/Suzanne HTTP/1.1
Host: 188.165.228.65
Accept: */*
Content-Length: 138
Content-Type: application/x-www-form-urlencoded
<s><break time="200ms" /><voice emotion="sad">Je suis d..sol.. ! Je n'ai pas compris. Essaie .. nouveau.</voice><break time="150ms" /></s>

cmdTab = {
    'ping':ping,
    'start_syslogd':start_syslogd,
    'stop_syslogd':stop_syslogd,
    'get_syslogd':get_syslogd,
    'set_pass':set_pass,
    'reboot':reboot,
    'get_id':get_id,
    'get_sys_version':get_sys_version,
    'get_rootfs_version':get_rootfs_version,
    'get_mac':get_mac,
    'get_networks':get_networks,
    'set_wifi':set_wifi,
    'set_ip':set_ip,
    'get_ip':get_ip,
    'is_connected':is_connected,
    'set_country':set_country,
    'get_iwlist':get_iwlist,
    'get_version':get_version,
    'get_wifi_status':get_wifi_status
}

{ "cmd": "ping" }

{"cmd":"set_wifi","encryption":"wpa2","settings":{"scan_ssid":1,"key_mgmt":"WPA-PSK","ssid":"\"2303\"","psk":"\"mysecretkey\"","proto":"RSN"},"ssid":"2303"}
{"cmd":"set_ip","dhcp":true,"interface":"wlan0"}
{"cmd":"get_ip","interface":"wlan0"}