Updated Copyright claims

- updated reference dates;
- removed reference to Community Edition;
- normalized logging using Clipperz.log[Warn|Error|Debug]

1 files changed, 16 insertions, 55 deletions

diff --git a/frontend/gamma/js/Clipperz/ByteArray.js b/frontend/gamma/js/Clipperz/ByteArray.js
index ae586e7..22c7c6e 100644
--- a/frontend/gamma/js/Clipperz/ByteArray.js
+++ b/frontend/gamma/js/Clipperz/ByteArray.js
@@ -1,46 +1,44 @@
 /*
 
-Copyright 2008-2011 Clipperz Srl
+Copyright 2008-2013 Clipperz Srl
 
-This file is part of Clipperz Community Edition.
-Clipperz Community Edition is an online password manager.
+This file is part of Clipperz, the online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
-* Clipperz Community Edition is free software: you can redistribute
-  it and/or modify it under the terms of the GNU Affero General Public
-  License as published by the Free Software Foundation, either version
-  3 of the License, or (at your option) any later version.
+* Clipperz is free software: you can redistribute it and/or modify it
+  under the terms of the GNU Affero General Public License as published
+  by the Free Software Foundation, either version 3 of the License, or 
+  (at your option) any later version.
 
-* Clipperz Community Edition is distributed in the hope that it will
-  be useful, but WITHOUT ANY WARRANTY; without even the implied
-  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* Clipperz is distributed in the hope that it will be useful, but 
+  WITHOUT ANY WARRANTY; without even the implied warranty of 
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
-  License along with Clipperz Community Edition.  If not, see
-  <http://www.gnu.org/licenses/>.
+  License along with Clipperz. If not, see http://www.gnu.org/licenses/.
 
 */
 
 if (typeof(Clipperz) == 'undefined') { Clipperz = {}; }
 
 //=============================================================================
 
 Clipperz.ByteArray_abstract = function(args) {
         return this;
 }
 
 Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
 
         //-------------------------------------------------------------------------
 
         'toString': function() {
                 return "Clipperz.ByteArray_abstract";
         },
         
         //-------------------------------------------------------------------------
 
         'equals': function(aValue) {
                 return (this.compare(aValue) == 0);
         },
@@ -68,53 +66,50 @@ Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
 
         //-------------------------------------------------------------------------
 
         'newInstance': function() {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
         
         //-------------------------------------------------------------------------
 
         'reset': function() {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
         
         //-------------------------------------------------------------------------
         
         'length': function() {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
         
         //-------------------------------------------------------------------------
 
         'checkByteValue': function(aValue) {
-//Clipperz.log("aValue", aValue.toString(16));
-//Clipperz.log("(aValue & 0xff)", (aValue & 0xff).toString(16));
-
                 if ((aValue & 0xff) != aValue) {
-                        MochiKit.Logging.logError("Clipperz.ByteArray.appendByte: the provided value (0x" + aValue.toString(16) + ") is not a byte value.");
+                        Clipperz.logError("Clipperz.ByteArray.appendByte: the provided value (0x" + aValue.toString(16) + ") is not a byte value.");
                         throw Clipperz.ByteArray.exception.InvalidValue;
                 }
         },
         
         //-------------------------------------------------------------------------
 
         'xorMergeWithBlock': function(aBlock, anAllignment, paddingMode) {
                 var result;
                 var a, b;
                 var aLength;
                         var bLength;            
                 var i, c;
                 
                 if (this.length() > aBlock.length()) {
                         a = this;
                         b = aBlock;
                 } else {
                         a = aBlock;
                         b = this;
                 }
 
                 aLength = a.length();
                 bLength = b.length();
 
@@ -123,70 +118,58 @@ Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
                                 if (anAllignment == 'left') {
                                         a = a.split(0, bLength);
                                 } else {
                                         a = a.split(aLength - bLength);
                                 }
                         } else {
                                 var ii, cc;
                                 var padding;
                                 
         //                      padding = new Clipperz.ByteArray();
                                 padding = this.newInstance();
                                 cc = aLength - bLength;
                                 for (ii=0; ii<cc; ii++) {
                                         padding.appendByte(0);
                                 }
                                 
                                 if (anAllignment == 'left') {
                                         b = b.appendBlock(padding);
                                 } else {
                                         b = padding.appendBlock(b);
                                 }
                         }
                 }
 
-
-        //      result = new Clipperz.ByteArray();
                 result = this.newInstance();
                 c = a.length();
                 for (i=0; i<c; i++) {
                         result.appendByte(a.byteAtIndex(i) ^ b.byteAtIndex(i));
                 }
 
                 return result;
         },
 
         //-------------------------------------------------------------------------
-/*
-        'shiftLeft': function(aNumberOfBitsToShift) {
-                var result;
-
-                        result = this.clone();  //???????????
-                
-                return result;
-        },
-        */
-        //-------------------------------------------------------------------------
 
         'appendBlock': function(aBlock) {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
 
         //-------------------------------------------------------------------------
 
         'appendByte': function(aValue) {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
 
         'appendBytes': function(args) {
                         varvalues;
                         vari,c;
 
                 if (args.constructor == Array) {
                         values = args;
                 } else {
                         values = arguments;
                 }
 
                 c = values.length;
                 for (i=0; i<c; i++) {
                         this.appendByte(values[i]);
@@ -271,180 +254,158 @@ Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
         
         'setByteAtIndex': function(aValue, anIndex) {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
 
         //-------------------------------------------------------------------------
 
         'bitAtIndex': function(aBitPosition) {
                 var result;
                         varbytePosition;
                 var bitPositionInSelectedByte;
                 var selectedByte;
                 var selectedByteMask;
                 
                 bytePosition = this.length() - Math.ceil((aBitPosition + 1)/ 8);
                 bitPositionInSelectedByte = aBitPosition % 8;
                 selectedByte = this.byteAtIndex(bytePosition);
 
                 if (bitPositionInSelectedByte > 0) {
                         selectedByteMask = (1 << bitPositionInSelectedByte);
                 } else {
                         selectedByteMask = 1;
                 }
                 result = selectedByte & selectedByteMask ? 1 : 0;
-//console.log("aBitPosition: " + aBitPosition + ", length: " + this.length() + ", bytePosition: " + bytePosition + ", bitPositionInSelectedByte: " + bitPositionInSelectedByte + ", selectedByteMask: " + selectedByteMask);
                 
                 return result;
         },
 
         //-------------------------------------------------------------------------
 
         'bitBlockAtIndexWithSize': function(aBitPosition, aSize) {
                 var result;
                 var bitValue;
                 var i,c;
                 
                 result = 0;
                 c = aSize;
                 for (i=0; i<c; i++) {
                         bitValue = this.bitAtIndex(aBitPosition + i);
                         result = result | bitValue << i;
                 }
                 
                 return result;
         },
         
         //-------------------------------------------------------------------------
 
         'asString': function() {
                         varresult;
                         varlength;
                         vari;
 
-//var startTime = new Date();
-
-        //#     result = "";
                 result = [];
                 
                 i = 0;
                 length = this.length();
                 
                 while (i < length) {
                                 varcurrentCharacter;
                                 varcurrentByte;
                                 varunicode;
                         
                         currentByte = this.byteAtIndex(i);
                         
                                 if ((currentByte & 0x80) == 0x00 ) {            //0xxxxxxx
                                 unicode = currentByte;
                                 currentCharacter = String.fromCharCode(unicode);
                                 } else if ((currentByte & 0xe0) == 0xc0 ) {     //110xxxxx 10xxxxxx
                                 unicode = (currentByte & 0x1f) << 6;
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | (currentByte & 0x3f);
 
                                 currentCharacter = String.fromCharCode(unicode);
                                 } else if ((currentByte & 0xf0) == 0xe0 ) {     //1110xxxx 10xxxxxx 10xxxxxx
                                 unicode = (currentByte & 0x0f) << (6+6);
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | ((currentByte & 0x3f) << 6);
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | (currentByte & 0x3f);
                                 
                                 currentCharacter = String.fromCharCode(unicode);
                                 } else {                                                                        //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                                 unicode = (currentByte & 0x07) << (6+6+6);
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | ((currentByte & 0x3f) << (6+6));
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | ((currentByte & 0x3f) << 6);
                                 i++; currentByte = this.byteAtIndex(i);
                                 unicode = unicode | (currentByte & 0x3f);
                                 
                                 currentCharacter = String.fromCharCode(unicode);
                         }
                         
-        //              result += currentCharacter;
                         result.push(currentCharacter);
                         i++;
                 }
 
-//MochiKit.Logging.logDebug("[" + (new Date() - startTime) + "] ByteArray.asString");
-
-        //      return result;
                 return result.join("");
         },
 
         //-------------------------------------------------------------------------
 
         'toHexString': function() {
                 throw Clipperz.Base.exception.AbstractMethod;
         },
         
         //-------------------------------------------------------------------------
         
         'base64map': "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
         'base64mapIndex': "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(''),
-        //'base64mapInvertedIndex': {
-        //      'A':  0, 'B':  1, 'C':  2, 'D':  3, 'E':  4, 'F':  5, 'G':  6, 'H':  7, 'I':  8, 'J':  9,
-        //      'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15, 'Q': 16, 'R': 17, 'S': 18, 'T': 19,
-        //      'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24, 'Z': 25, 'a': 26, 'b': 27, 'c': 28, 'd': 29,
-        //      'e': 30, 'f': 31, 'g': 32, 'h': 33, 'i': 34, 'j': 35, 'k': 36, 'l': 37, 'm': 38, 'n': 39,
-        //      'o': 40, 'p': 41, 'q': 42, 'r': 43, 's': 44, 't': 45, 'u': 46, 'v': 47, 'w': 48, 'x': 49,
-        //      'y': 50, 'z': 51, '0': 52, '1': 53, '2': 54, '3': 55, '4': 56, '5': 57, '6': 58, '7': 59,
-        //      '8': 60, '9': 61, '+': 62, '/': 63,
-        //      "=": -1},
 
         //-------------------------------------------------------------------------
         
         'appendBase64String': function(aValue) {
                 var i;
                 var length;
 
                 length = aValue.length;
                 
                 if ((length % 4) != 0) {
-                        MochiKit.Logging.logError("the value passed to the 'ByteArray.setBase64Value' is not correct");
+                        Clipperz.logError("the value passed to the 'ByteArray.setBase64Value' is not correct");
                         throw Clipperz.ByteArray.exception.InvalidValue;
                 }
 
                 i = 0;
                 while (i<length) {
                         var value1, value2, value3, value4;
                         var byte1, byte2, byte3;
                         
                         value1 = this.base64map.indexOf(aValue.charAt(i));
                         value2 = this.base64map.indexOf(aValue.charAt(i+1));
                         value3 = this.base64map.indexOf(aValue.charAt(i+2));
                         value4 = this.base64map.indexOf(aValue.charAt(i+3));
 
-        //              value1 = this.base64mapInvertedIndex[aValue.charAt(i)];
-        //              value2 = this.base64mapInvertedIndex[aValue.charAt(i+1)];
-        //              value3 = this.base64mapInvertedIndex[aValue.charAt(i+2)];
-        //              value4 = this.base64mapInvertedIndex[aValue.charAt(i+3)];
-
                         byte1 = (value1 << 2) | ((value2 & 0x30) >> 4);
                         if (value3 != -1) {
                                 byte2 = ((value2 & 0x0f) << 4) | ((value3 & 0x3c) >> 2);
 
                                 if (value4 != -1) {
                                         byte3 = ((value3 & 0x03) << 6) | (value4);
                                 } else {
                                         byte3 = null;
                                 }
                         } else {
                                 byte2 = null;
                                 byte3 = null;
                         }
 
                         this.appendByte(byte1);
                         this.appendByte(byte2);
                         this.appendByte(byte3);
 
                         i += 4;
                 }
                 
                 return this;
         },
 
@@ -499,49 +460,49 @@ Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
         },
 
         //-------------------------------------------------------------------------
 
         'base32map': "0123456789abcdefghjkmnpqrstvwxyz",
         'base32mapIndex': "0123456789abcdefghjkmnpqrstvwxyz".split(''),
 
         //-------------------------------------------------------------------------
         
         'appendBase32String': function(aValue) {
                 var value;
                 var i;
                 var length;
                 var value1, value2, value3, value4, value5, value6, value7, value8;
                 var byte1, byte2, byte3, byte4, byte5;
 
                 value = aValue.toLowerCase();
                 value = value.replace(/[\s\-]/g, '');
                 value = value.replace(/[0o]/g, '0');
                 value = value.replace(/[1il]/g, '1');
 
                 length = value.length;
                 
                 if ((length % 8) != 0) {
-                        MochiKit.Logging.logError("the value passed to the 'ByteArray.setBase32Value' is not correct");
+                        Clipperz.logError("the value passed to the 'ByteArray.setBase32Value' is not correct");
                         throw Clipperz.ByteArray.exception.InvalidValue;
                 }
 
                 i = 0;
                 while (i<length) {
                         value1 = this.base32map.indexOf(value.charAt(i));
                         value2 = this.base32map.indexOf(value.charAt(i+1));
                         value3 = this.base32map.indexOf(value.charAt(i+2));
                         value4 = this.base32map.indexOf(value.charAt(i+3));
                         value5 = this.base32map.indexOf(value.charAt(i+4));
                         value6 = this.base32map.indexOf(value.charAt(i+5));
                         value7 = this.base32map.indexOf(value.charAt(i+6));
                         value8 = this.base32map.indexOf(value.charAt(i+7));
 
                         byte1 = byte2 = byte3 = byte4 = byte5 = null;
                         
                         byte1 = (value1 << 3) | ((value2 & 0x1c) >> 2);
                         if (value3 != -1) {
                                 byte2 = ((value2 & 0x03) << 6) | (value3 << 1) | ((value4 & 0x10) >> 4);
                                 if (value5 != -1) {
                                         byte3 = ((value4 & 0x0f) << 4) | ((value5 & 0x1e) >> 1);
                                         if (value6 != -1) {
                                                 byte4 = ((value5 & 0x01) << 7) | (value6 << 2) | ((value7 & 0x18) >> 3);
                                                 if (value8 != -1) {
@@ -707,49 +668,49 @@ Clipperz.ByteArray_abstract.prototype = MochiKit.Base.update(null, {
 //=============================================================================
 //
         //Clipperz.ByteArray_hex
 //
 //=============================================================================
 /*
 Clipperz.ByteArray_hex = function (args) {
         this._value = "";
 
         if (typeof(args) != 'undefined') {
                 if (args.constructor == Array) {
                         this.appendBytes(args);
                 } else if (args.constructor == String) {
                         if (args.indexOf("0x") == 0) {
                                         varvalue;
                         
                                 value = args.substring(2).toLowerCase();
                                         if (/[0123456789abcdef]* /.test(value)) { the space in the regexp shoud be removed if the code is activate
                                         if ((value.length % 2) == 0) {
                                                 this._value = value;
                                         } else {
                                                 this._value = "0" + value;
                                         }
                                 } else {
-MochiKit.Logging.logError("Clipperz.ByteArray should be inizialized with an hex string.");
+Clipperz.logError("Clipperz.ByteArray should be inizialized with an hex string.");
                                         throw Clipperz.ByteArray.exception.InvalidValue;
                                 }
                         } else {
                                         varvalue;
                                         vari,c;
 
                                 c = args.length;
                                 value = new Array(c);
                                 for (i=0; i<c; i++) {
                                         value.push(Clipperz.ByteArray.unicodeToUtf8HexString(args.charCodeAt(i)));
                                 }
 
                                 this._value = value.join("");
                         }
                 } else {
                         this.appendBytes(MochiKit.Base.extend(null, arguments));
                 }
         }
         return this;
 }
 
 Clipperz.ByteArray_hex.prototype = MochiKit.Base.update(new Clipperz.ByteArray_abstract(), {
 
         //-------------------------------------------------------------------------
@@ -893,49 +854,49 @@ Clipperz.ByteArray_hex.prototype = MochiKit.Base.update(new Clipperz.ByteArray_a
 
 //=============================================================================
 //
         //Clipperz.ByteArray_array
 //
 //=============================================================================
 
 Clipperz.ByteArray_array = function (args) {
         if (typeof(args) != 'undefined') {
                 if (args.constructor == Array) {
                         this._value = args.slice(0);
                 } else if (args.constructor == String) {
                         var result;
                                 varvalue;
                         var i, c;
                         
                         if (args.indexOf("0x") == 0) {
                         
                                 value = args.substring(2).toLowerCase();
                                 if (/[0123456789abcdef]*/.test(value)) {
                                         if ((value.length % 2) != 0) {
                                                 value = "0" + value;
                                         }
                                 } else {
-MochiKit.Logging.logError("Clipperz.ByteArray should be inizialized with an hex string.");
+                                        Clipperz.logError("Clipperz.ByteArray should be inizialized with an hex string.");
                                         throw Clipperz.ByteArray.exception.InvalidValue;
                                 }
 
                                 c = value.length / 2
                                 result = new Array(c);
                                 for (i=0; i<c; i++) {
                                         result[i] = parseInt(value.substr(i*2, 2), 16);
                                 }
 
                         } else {
                                 var unicode;
                                 result = [];
                                 c = args.length;
                                 for (i=0; i<c; i++) {
         //                              Clipperz.ByteArray.pushUtf8BytesOfUnicodeChar(result, args.charCodeAt(i));
 
                                         unicode = args.charCodeAt(i);
                                                 if (unicode <= 0x7f) {                                                                          //0x00000000 - 0x0000007f -> 0xxxxxxx
                                                 result.push(unicode);
                                         //      } else if ((unicode >= 0x80) && (unicode <= 0x7ff)) {           //0x00000080 - 0x000007ff -> 110xxxxx 10xxxxxx
                                                 } else if (unicode <= 0x7ff) {          //0x00000080 - 0x000007ff -> 110xxxxx 10xxxxxx
                                                 result.push((unicode >> 6) | 0xc0);
                                                 result.push((unicode & 0x3F) | 0x80);
                                         //      } else if ((unicode >= 0x0800) && (unicode <= 0xffff)) {        //0x00000800 - 0x0000ffff -> 1110xxxx 10xxxxxx 10xxxxxx
@@ -1094,49 +1055,49 @@ Clipperz.ByteArray_array.prototype = MochiKit.Base.update(new Clipperz.ByteArray
 //
         //Clipperz.ByteArray_string
 //
 //=============================================================================
 /*
 Clipperz.ByteArray_string = function (args) {
         this._value = "";
 
         if (typeof(args) != 'undefined') {
                 if (args.constructor == Array) {
                         this.appendBytes(args);
                 } else if (args.constructor == String) {
                         var result;
                                 varvalue;
                         var i, c;
                         
                         if (args.indexOf("0x") == 0) {
                         
                                 value = args.substring(2).toLowerCase();
                                 if (/[0123456789abcdef]* /.test(value)) { the space in the regexp shoud be removed if the code is activated
                                         if ((value.length % 2) != 0) {
                                                 value = "0" + value;
                                         }
                                 } else {
-MochiKit.Logging.logError("Clipperz.ByteArray should be inizialized with an hex string.");
+Clipperz.logError("Clipperz.ByteArray should be inizialized with an hex string.");
                                         throw Clipperz.ByteArray.exception.InvalidValue;
                                 }
                         } else {
                                 value = "";
                                 c = args.length;
                                 for (i=0; i<c; i++) {
                                         value += Clipperz.ByteArray.unicodeToUtf8HexString(args.charCodeAt(i));
                                 }
                         }
                         
                         c = value.length / 2
                         for (i=0; i<c; i++) {
                                 this.appendByte(parseInt(value.substr(i*2, 2), 16));
                         }
                 } else {
                         this.appendBytes(MochiKit.Base.extend(null, arguments));
                 }
         }
         
         return this;
 }
 
 Clipperz.ByteArray_string.prototype = MochiKit.Base.update(new Clipperz.ByteArray_abstract(), {