Synnefo

#!/usr/bin/env python

#coding=utf8

# Copyright 2011-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import re

import hashlib

import random

from binascii import hexlify

from StringIO import StringIO

from pithos.backends.random_word import get_random_word

from pithos.api import settings as pithos_settings

def is_date(date):

    __D = r'(?P<day>\d{2})'

    __D2 = r'(?P<day>[ \d]\d)'

    __M = r'(?P<mon>\w{3})'

    __Y = r'(?P<year>\d{4})'

    __Y2 = r'(?P<year>\d{2})'

    __T = r'(?P<hour>\d{2}):(?P<min>\d{2}):(?P<sec>\d{2})'

    RFC1123_DATE = re.compile(r'^\w{3}, %s %s %s %s GMT$' % (

        __D, __M, __Y, __T))

    RFC850_DATE = re.compile(r'^\w{6,9}, %s-%s-%s %s GMT$' % (

        __D, __M, __Y2, __T))

    ASCTIME_DATE = re.compile(r'^\w{3} %s %s %s %s$' % (

        __M, __D2, __T, __Y))

    for regex in RFC1123_DATE, RFC850_DATE, ASCTIME_DATE:

        m = regex.match(date)

        if m is not None:

            return True

    return False

def strnextling(prefix):

    """Return the first unicode string

       greater than but not starting with given prefix.

       strnextling('hello') -> 'hellp'

    """

    if not prefix:

        ## all strings start with the null string,

        ## therefore we have to approximate strnextling('')

        ## with the last unicode character supported by python

        ## 0x10ffff for wide (32-bit unicode) python builds

        ## 0x00ffff for narrow (16-bit unicode) python builds

        ## We will not autodetect. 0xffff is safe enough.

        return unichr(0xffff)

    s = prefix[:-1]

    c = ord(prefix[-1])

    if c >= 0xffff:

        raise RuntimeError

    s += unichr(c + 1)

    return s

def get_random_data(length=None):

    length = length or random.randint(

        pithos_settings.BACKEND_BLOCK_SIZE,

        2 * pithos_settings.BACKEND_BLOCK_SIZE)

    return get_random_word(length)[:length]

def md5_hash(data):

    md5 = hashlib.md5()

    md5.update(data)

    return md5.hexdigest().lower()

def file_read_iterator(fp, size=1024):

    while True:

        data = fp.read(size)

        if not data:

            break

        yield data

class HashMap(list):

    def __init__(self, blocksize, blockhash):

        super(HashMap, self).__init__()

        self.blocksize = blocksize

        self.blockhash = blockhash

    def _hash_raw(self, v):

        h = hashlib.new(self.blockhash)

        h.update(v)

        return h.digest()

    def _hash_block(self, v):

        return self._hash_raw(v.rstrip('\x00'))

    def hash(self):

        if len(self) == 0:

            return self._hash_raw('')

        if len(self) == 1:

            return self.__getitem__(0)

        h = list(self)

        s = 2

        while s < len(h):

            s = s * 2

        h += [('\x00' * len(h[0]))] * (s - len(h))

        while len(h) > 1:

            h = [self._hash_raw(h[x] + h[x + 1]) for x in range(0, len(h), 2)]

        return h[0]

    def load(self, data):

        self.size = 0

        fp = StringIO(data)

        for block in file_read_iterator(fp, self.blocksize):

            self.append(self._hash_block(block))

            self.size += len(block)

def merkle(data, blocksize, blockhash):

    hashes = HashMap(blocksize, blockhash)

    hashes.load(data)

    return hexlify(hashes.hash())