source: trunk/CrypPlugins/KeySearcher/KeyPattern.cs @ 1137

Last change on this file since 1137 was 1137, checked in by arnold, 12 years ago

Completely redesigned Manager-JobAdmin-Worker-infrastructure to distribute Jobs with a Peer-to-Peer infrastructure to remote CT2-Workspaces.

To test this infrastructure, open 2 instances of CT and load P2P_Manager_NEW_DES.cte and in the other instance P2P_Worker_NEW.cte.
HINT: Working with remote peers isn't possible every time, because the so called "SuperNode", which is necessary for relaying, sometimes goes down. But testing this infrastructure on different computers in the same network should work every time.

File size: 17.9 KB
Line 
1/*                             
2   Copyright 2009 Team CrypTool (Sven Rech,Dennis Nolte,Raoul Falk,Nils Kopal), Uni Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Collections.Generic;
19using System.Linq;
20using System.Text;
21using Cryptool.PluginBase.Miscellaneous;
22using System.Collections;
23using Cryptool.Plugins.PeerToPeer.Jobs;
24
25namespace KeySearcher
26{
27    public class KeyPattern
28    {       
29        private string pattern;
30        internal ArrayList wildcardList;
31
32        /// <summary>
33        /// Property for the WildCardKey. Could return null, if the KeyPattern isn't initialized correctly.
34        /// </summary>
35        public string WildcardKey
36        {
37            get
38            {
39                return getWildcardKey();
40            }
41            set
42            {
43                if (!testWildcardKey(value))
44                    throw new Exception("Invalid wildcard key!");
45                setWildcardKey(value);
46            }
47        }
48
49        public KeyPattern(string pattern)
50        {
51            if (!testPattern(pattern))
52                throw new Exception("Invalid pattern!");
53            this.pattern = pattern;
54        }       
55
56        public KeyPattern[] split()
57        {
58            KeyPattern[] patterns = new KeyPattern[2];
59            for (int i = 0; i < 2; i++)
60            {
61                patterns[i] = new KeyPattern(pattern);               
62                patterns[i].wildcardList = new ArrayList();
63            }
64            bool s = false;
65            for (int i = 0; i < wildcardList.Count; i++)
66            {
67                Wildcard wc = ((Wildcard)wildcardList[i]);
68                if (!s && (wc.size() - wc.count()) > 1)
69                {
70                    Wildcard[] wcs = wc.split();
71                    patterns[0].wildcardList.Add(wcs[0]);
72                    patterns[1].wildcardList.Add(wcs[1]);                   
73                    s = true;
74                }
75                else
76                {
77                    patterns[0].wildcardList.Add(new Wildcard(wc));
78                    Wildcard copy = new Wildcard(wc);
79                    if (s)
80                        copy.resetCounter();
81                    patterns[1].wildcardList.Add(copy);
82                }
83            }
84            if (!s)
85                return null;
86            return patterns;
87        }
88
89        public string giveInputPattern()
90        {
91            string res = "";
92            int i = 0;
93            while (i < pattern.Length)
94            {
95                if (pattern[i] != '[')
96                    res += pattern[i];
97                else
98                {
99                    res += '*';
100                    while (pattern[i] != ']')
101                        i++;
102                }
103                i++;
104            }
105            return res;
106        }
107
108        /**
109         * tests, if 'pattern' is a valid pattern.
110         **/
111        public static bool testPattern(string pattern)
112        {
113            int i = 0;
114            while (i < pattern.Length)
115            {
116                if (pattern[i] == '[')
117                {
118                    i++;
119                    while (pattern[i] != ']')
120                    {
121                        if (specialChar(pattern[i]))
122                            return false;
123                        if (pattern[i + 1] == '-')
124                        {
125                            if (specialChar(pattern[i]) || specialChar(pattern[i + 2]))
126                                return false;
127                            i += 2;
128                        }
129                        i++;
130                    }
131                }
132                i++;
133            }
134            return true;
135        }
136
137        private static bool specialChar(char p)
138        {
139            if (p == '-' || p == '[' || p == ']' || p == '*')
140                return true;
141            return false;
142        }
143
144        /**
145         * tests, if 'wildcardKey' matches 'pattern'.
146         **/
147        public static bool testWildcardKey(string wildcardKey, string pattern)
148        {
149            try
150            {
151                int kcount = 0;
152                int pcount = 0;
153                while (kcount < wildcardKey.Length && pcount < pattern.Length)
154                {
155                    if (pattern[pcount] != '[')
156                    {
157                        if (pattern[pcount] != wildcardKey[kcount])
158                            return false;
159                        kcount++;
160                        pcount++;
161                    }
162                    else
163                    {
164                        Wildcard wc1 = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
165                        while (pattern[pcount++] != ']') ;
166                        Wildcard wc2 = null;
167                        if (wildcardKey[kcount] == '[')
168                        {
169                            wc2 = new Wildcard(wildcardKey.Substring(kcount, wildcardKey.IndexOf(']', kcount) + 1 - kcount));
170                            while (wildcardKey[++kcount] != ']') ;
171                        }
172                        else if (wildcardKey[kcount] != '*')
173                            wc2 = new Wildcard("" + wildcardKey[kcount]);
174
175                        if (!wc1.contains(wc2) && !(wildcardKey[kcount] == '*'))
176                            return false;
177                        kcount++;
178                    }
179                }
180                if (pcount != pattern.Length || kcount != wildcardKey.Length)
181                    return false;
182                return true;
183            }
184            catch (Exception)
185            {
186                return false;
187            }
188        }
189
190        public bool testWildcardKey(string wildcardKey)
191        {
192            return testWildcardKey(wildcardKey, pattern);
193        }
194
195        private void setWildcardKey(string wildcardKey)
196        {         
197            int pcount = 0;
198            wildcardList = new ArrayList();
199            int i = 0;
200            while (i < wildcardKey.Length)           
201            {
202                if (pattern[pcount] == '[')
203                {
204                    if (wildcardKey[i] == '*')
205                    {
206                        Wildcard wc = new Wildcard(pattern.Substring(pcount, pattern.IndexOf(']', pcount) + 1 - pcount));
207                        wildcardList.Add(wc);
208                      }
209                    else if (wildcardKey[i] == '[')
210                    {
211                        Wildcard wc = new Wildcard(wildcardKey.Substring(i, wildcardKey.IndexOf(']', i) + 1 - i));
212                        wildcardList.Add(wc);
213                        while (wildcardKey[++i] != ']') ;
214                    }
215                    else
216                    {
217                        Wildcard wc = new Wildcard("" + wildcardKey[i]);
218                        wildcardList.Add(wc);
219                    }
220                    while (pattern[++pcount] != ']') ;
221                }
222                pcount++;
223                i++;
224            }
225        }
226
227        private string getWildcardKey()
228        {
229            string res = "";
230            int pcount = 0;
231            int wccount = 0;
232
233            // error handling
234            if (wildcardList != null)
235            {
236                while (pcount < pattern.Length)
237                {
238                    if (pattern[pcount] != '[')
239                        res += pattern[pcount];
240                    else
241                    {
242                        res += ((Wildcard)wildcardList[wccount++]).getRepresentationString();
243                        while (pattern[++pcount] != ']') ;
244                    }
245                    pcount++;
246                }
247                return res;
248            }
249            else
250                return null;
251        }
252
253        public BigInteger size()
254        {
255            if (wildcardList == null)
256                return 0;
257            BigInteger counter = 1;
258            foreach (Wildcard wc in wildcardList)
259                counter *= wc.size();
260            return counter;
261        }
262
263        /** used to jump to the next Key.         
264         * if nextWildcard == -1, we return false
265         * if nextWildcard == -2, we return true
266         * if nextWildcard == -3, we increase the rightmost wildcard
267         * if nextWildcard >= 0, we increase the wildcard on the position 'nextWildcard'
268         * returns false if there is no key left.
269         */
270        public bool nextKey(int nextWildcard)
271        {
272            if (nextWildcard == -2)
273                return true;
274            if (nextWildcard == -1)
275                return false;
276
277            int wildcardCount;
278            if (nextWildcard == -3)
279                wildcardCount = wildcardList.Count - 1;
280            else
281                wildcardCount = nextWildcard;
282            bool overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();           
283            while (overflow && (wildcardCount >= 0))
284                overflow = ((Wildcard)wildcardList[wildcardCount--]).succ();
285            return !overflow;
286        }
287
288        public string getKey()
289        {
290            string res = "";
291            int wildcardCount = 0;
292            int i = 0;
293            while (i < pattern.Length)           
294            {
295                if (pattern[i] != '[')
296                    res += pattern[i++];
297                else
298                {
299                    Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
300                    res += wc.getChar();
301                    while (pattern[i++] != ']') ;
302                }               
303            }
304            return res;
305        }
306
307        public string getKey(int add)
308        {
309            string res = "";
310            int div = 1;
311            int wildcardCount = wildcardList.Count - 1;
312            int i = pattern.Length - 1;
313            while (i >= 0)           
314            {
315                if (pattern[i] != ']')
316                    res += pattern[i--];
317                else
318                {
319                    Wildcard wc = (Wildcard)wildcardList[wildcardCount--];
320                    if (add < div)
321                        res += wc.getChar();
322                    else
323                    {
324                        res += wc.getChar((add / div) % wc.size());
325                        div *= wc.size();
326                    }
327                    while (pattern[i--] != '[') ;
328                }
329            }
330            char[] r = res.ToCharArray();
331            Array.Reverse(r);
332            return new string(r);
333        }
334
335        public string getKeyBlock(ref int blocksize, ref int nextWildcard)
336        {
337            const int MAXSIZE = 65536;
338            //find out how many wildcards we can group together:
339            blocksize = 1;
340            int pointer;
341            for (pointer = wildcardList.Count - 1; pointer >= 0; pointer--)
342            {
343                Wildcard wc = (Wildcard)wildcardList[pointer];
344                if (wc.isSplit || wc.count() != 0 || blocksize * wc.size() > MAXSIZE)
345                    break;
346                else
347                    blocksize *= wc.size();
348            }
349
350            if (pointer >= wildcardList.Count)
351                return null;
352
353            nextWildcard = pointer;
354
355            //generate key:
356            string res = "";
357            int wildcardCount = 0;
358            int i = 0;
359            while (i < pattern.Length)
360            {
361                if (pattern[i] != '[')
362                    res += pattern[i++];
363                else
364                {
365                    if (pointer < wildcardCount)
366                        res += "*";
367                    else
368                    {
369                        Wildcard wc = (Wildcard)wildcardList[wildcardCount++];
370                        res += wc.getChar();
371                    }
372                    while (pattern[i++] != ']') ;
373                }
374            }
375            return res;
376        }       
377
378         /*
379         * ARNIES SANDKASTEN - ALLE FOLGENDEN METHODEN SIND FÜR DIE VERTEILTE VERWENDUNG
380         * DES KEYPATTERNS NOTWENDIG ODER ABER EINFACH UM DAS KEYPATTERN SCHÖN ALS
381         * GUILOGMESSAGE AUSGEBEN ZU KÖNNEN ;-)
382         */
383
384        // Added by Arnold - 2010.02.04
385        public KeyPattern(byte[] serializedPattern)
386        {
387            KeyPattern deserializedPattern = Deserialize(serializedPattern);
388            // set deserialized Pattern to actual pattern
389            this.pattern = deserializedPattern.pattern;
390            this.WildcardKey = deserializedPattern.WildcardKey;
391            //this.wildcardList = deserializedPattern.wildcardList;
392            if (deserializedPattern == null)
393                throw new Exception("Invalid byte[] representation of KeyPattern!");
394        }
395
396        //added by Christian Arnold - 2009.12.02
397        /// <summary>
398        /// returns type, key and pattern. If you want to get only the pattern for processing use GetPattern-method!
399        /// </summary>
400        /// <returns></returns>
401        public override string ToString()
402        {
403            if(this.WildcardKey != null)
404                return "Type: KeySearcher.KeyPattern. WildcardKey: '" + this.WildcardKey + "', Pattern: '" + this.pattern + "'";
405            else
406                return "Type: KeySearcher.KeyPattern. KeyPattern isn't initialized correctly, Pattern: '" + this.pattern + "'";
407        }
408
409        //added by Christian Arnold - 2009.12.03
410        /// <summary>
411        /// returns ONLY the pattern as a string!
412        /// </summary>
413        /// <returns></returns>
414        public string GetPattern()
415        {
416            return this.pattern;
417        }
418
419        #region Serialization methods and auxiliary variables
420
421        /* Serialization information:
422         * 1st byte: Byte-Length of the WildCardKey
423         * 2nd - wildcardLen: WildCardKey Byte representation
424         * wildcardLen + 1: Byte-Length of the Pattern
425         * wildcardLen + 2 - wildcardLen+2+patternLen: Pattern Byte representation
426         *  -------------------------------------------------------------
427         * | wildcardkey length | wildcardkey | pattern length | pattern |
428         *  -------------------------------------------------------------  */
429        private Encoding encoder = UTF8Encoding.UTF8;
430
431        /// <summary>
432        /// Serialize all needful information to rebuild the existing pattern elsewhere
433        /// </summary>
434        /// <returns>byte representation of all the needful information of the actual KeyPattern</returns>
435        public byte[] Serialize()
436        {
437            byte[] retByte;
438            string wildcardKey = this.WildcardKey;
439            if (wildcardKey != null && this.pattern != null)
440            {
441                if (testWildcardKey(wildcardKey))
442                {
443                    byte[] byteWildCard = encoder.GetBytes(wildcardKey);
444                    byte[] bytePattern = encoder.GetBytes(pattern);
445                    retByte = new byte[byteWildCard.Length + bytePattern.Length + 2];
446                    retByte[0] = (byte)byteWildCard.Length;
447                    Buffer.BlockCopy(byteWildCard, 0, retByte, 1, byteWildCard.Length);
448                    retByte[byteWildCard.Length + 1] = (byte)bytePattern.Length;
449                    Buffer.BlockCopy(bytePattern, 0, retByte, byteWildCard.Length + 2, bytePattern.Length);
450                }
451                else
452                {
453                    throw (new Exception("Serializing KeyPattern canceled, because WildcardKey and/or Pattern aren't valid. "
454                        + "WildcardKey: '" + wildcardKey + "', Pattern: '" + pattern + "'.\n"));
455                }
456            }
457            else
458            {
459                throw (new Exception("Serializing KeyPattern canceled, because Key and/or Pattern are NULL. WildcardKey: '" + wildcardKey + "'. Pattern: '" + pattern + "'."));
460            }
461            return retByte;
462        }
463
464        /// <summary>
465        /// Deserialize a byte-representation of an KeyPattern object. Returns a full-initialized KeyPattern object.
466        /// </summary>
467        /// <param name="serializedPattern">byte-representation of an keypattern object</param>
468        /// <returns>a full-initialized KeyPattern object</returns>
469        public KeyPattern Deserialize(byte[] serializedPattern)
470        {
471            KeyPattern keyPatternToReturn;
472            string wildcardKey_temp;
473            string pattern_temp;
474
475            int iWildCardLen = serializedPattern[0];
476            wildcardKey_temp = encoder.GetString(serializedPattern, 1, iWildCardLen);
477            int iPatternLen = serializedPattern[iWildCardLen + 1];
478            pattern_temp = encoder.GetString(serializedPattern, iWildCardLen + 2, iPatternLen);
479
480            keyPatternToReturn = new KeyPattern(pattern_temp);
481            // test extracted pattern and wildcardKey!
482            if (keyPatternToReturn.testWildcardKey(wildcardKey_temp))
483            {
484                keyPatternToReturn.WildcardKey = wildcardKey_temp;
485                return keyPatternToReturn;
486            }
487            else
488            {
489                throw (new Exception("Deserializing KeyPattern canceled, because WildcardKey or Pattern aren't valid. "
490                    + "WildcardKey: '" + wildcardKey_temp + "', Pattern: '" + pattern_temp + "'.\n"));
491            }
492        }
493
494        #endregion
495
496    }
497}
Note: See TracBrowser for help on using the repository browser.