source: trunk/CrypPlugins/PeerToPeer/KeySearcherResult.cs @ 1433

Last change on this file since 1433 was 1433, checked in by Paul Lelgemann, 12 years ago

o Extracted common classes from PeerToPeerBase plugin into new PeerToPeer plugin as a preparation for the new P2P proxy
o Modified directory properties to ignore the CrypBuild directory

File size: 4.8 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using KeySearcher;
6
7namespace Cryptool.Plugins.PeerToPeer.Internal
8{
9    public class KeySearcherResult
10    {
11        private Encoding enc;
12
13        public KeySearcherResult()
14        {
15            this.enc = UTF8Encoding.UTF8;
16        }
17
18        public KeySearcherResult(Encoding encType)
19        {
20            this.enc = encType;
21        }
22
23        /* serialization information: 3 fields per data set in the following order:
24         *  -------------------------------------------------------------------------------------------------------------------------------
25         * | Dataset count | double-value (8 byte) | string len (1 byte) | string-data (n bytes) | byte len (1 byte) | byte-data (n bytes) |
26         *  ------------------------------------------------------------------------------------------------------------------------------- */
27        public byte[] SerializeResult(LinkedList<KeySearcher.KeySearcher.ValueKey> resultList)
28        {
29            ByteQueue queueResult = new ByteQueue();
30            //amount of list entries
31            queueResult.Push((byte)resultList.Count);
32
33            foreach (KeySearcher.KeySearcher.ValueKey valKey in resultList)
34            {
35                queueResult.Push(BitConverter.GetBytes(valKey.value));
36                queueResult.Push((byte)valKey.key.Length);
37                queueResult.Push(enc.GetBytes(valKey.key));
38                // maybe this could run into an exception, when decryption byte is longer than 256 bytes!
39                if (valKey.decryption.Length > 255)
40                {
41                    queueResult.Push((byte)255);
42                    byte[] shortDecrypt = new byte[255];
43                    Buffer.BlockCopy(valKey.decryption, 0, shortDecrypt, 0, 255);
44                    queueResult.Push(shortDecrypt);
45                }
46                else
47                {
48                    queueResult.Push((byte)valKey.decryption.Length);
49                    queueResult.Push(valKey.decryption);
50                }
51            }
52            return queueResult.ToArray();
53        }
54
55        private const int VALUE_SIZE = 8;
56        public LinkedList<KeySearcher.KeySearcher.ValueKey> DeserializeResult(byte[] serializedResult)
57        {
58            ByteQueue resultQueue = new ByteQueue(serializedResult);
59            LinkedList<KeySearcher.KeySearcher.ValueKey> lstRet = new LinkedList<KeySearcher.KeySearcher.ValueKey>();
60
61            KeySearcher.KeySearcher.ValueKey valKey = new KeySearcher.KeySearcher.ValueKey();
62            int stringLen = 0;
63            int byteLen = 0;
64            int iDatasetCount = Convert.ToInt32(resultQueue.PopOneByte());
65            for (int i = 0; i < iDatasetCount; i++) //run through every data set (first byte = dataset count)
66            {
67                // 8 byte = double value
68                valKey.value = BitConverter.ToDouble(resultQueue.PopBytes(VALUE_SIZE), 0);
69                // variable string length
70                stringLen = Convert.ToInt32(resultQueue.PopOneByte());
71                valKey.key = enc.GetString(resultQueue.PopBytes(stringLen));
72                // variable byte length
73                byteLen = Convert.ToInt32(resultQueue.PopOneByte());
74                valKey.decryption = resultQueue.PopBytes(byteLen);
75
76                lstRet.AddLast(valKey);
77            }
78            return lstRet;
79        }
80
81        private class ByteQueue
82        {
83            private Queue<byte> myQueue;
84
85            public int CurrentStackSize { get { return myQueue.Count; } }
86
87            public ByteQueue()
88            {
89                myQueue = new Queue<byte>();
90            }
91
92            public ByteQueue(byte[] data)
93            {
94                myQueue = new Queue<byte>();
95                for (int i = 0; i < data.Length; i++)
96                {
97                    myQueue.Enqueue(data[i]);
98                }
99            }
100
101            public void Push(byte data)
102            {
103                myQueue.Enqueue(data);
104            }
105
106            public void Push(byte[] data)
107            {
108                for (int i = 0; i < data.Length; i++)
109                {
110                    myQueue.Enqueue(data[i]);
111                }
112            }
113
114            public byte PopOneByte()
115            {
116                byte ret = myQueue.Dequeue();
117                return ret;
118            }
119
120            public byte[] PopBytes(int num)
121            {
122                byte[] ret = new byte[num];
123                for (int i = 0; i < num; i++)
124                {
125                    ret[i] = myQueue.Dequeue();
126                }
127                return ret;
128            }
129
130            public byte[] ToArray()
131            {
132                return myQueue.ToArray();
133            }
134        }
135    }
136}
Note: See TracBrowser for help on using the repository browser.