~ubuntu-branches/ubuntu/trusty/jsch/trusty-proposed

« back to all changes in this revision

Viewing changes to src/com/jcraft/jsch/Util.java

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-01-06 10:50:04 UTC
  • mfrom: (4.2.1 experimental) (6.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140106105004-9al5p968hmaaj78t
Tags: 0.1.50-1ubuntu1
* Resync with Debian unstable.
* Drop dependency on libjzlib-java for continued main inclusion. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
2
 
/*
3
 
Copyright (c) 2002-2009 ymnk, JCraft,Inc. All rights reserved.
4
 
 
5
 
Redistribution and use in source and binary forms, with or without
6
 
modification, are permitted provided that the following conditions are met:
7
 
 
8
 
  1. Redistributions of source code must retain the above copyright notice,
9
 
     this list of conditions and the following disclaimer.
10
 
 
11
 
  2. Redistributions in binary form must reproduce the above copyright 
12
 
     notice, this list of conditions and the following disclaimer in 
13
 
     the documentation and/or other materials provided with the distribution.
14
 
 
15
 
  3. The names of the authors may not be used to endorse or promote products
16
 
     derived from this software without specific prior written permission.
17
 
 
18
 
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
19
 
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20
 
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
21
 
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23
 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
24
 
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25
 
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26
 
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
27
 
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 
*/
29
 
 
30
 
package com.jcraft.jsch;
31
 
import java.net.Socket;
32
 
 
33
 
class Util{
34
 
 
35
 
  private static final byte[] b64 ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".getBytes();
36
 
  private static byte val(byte foo){
37
 
    if(foo == '=') return 0;
38
 
    for(int j=0; j<b64.length; j++){
39
 
      if(foo==b64[j]) return (byte)j;
40
 
    }
41
 
    return 0;
42
 
  }
43
 
  static byte[] fromBase64(byte[] buf, int start, int length){
44
 
    byte[] foo=new byte[length];
45
 
    int j=0;
46
 
    for (int i=start;i<start+length;i+=4){
47
 
      foo[j]=(byte)((val(buf[i])<<2)|((val(buf[i+1])&0x30)>>>4));
48
 
      if(buf[i+2]==(byte)'='){ j++; break;}
49
 
      foo[j+1]=(byte)(((val(buf[i+1])&0x0f)<<4)|((val(buf[i+2])&0x3c)>>>2));
50
 
      if(buf[i+3]==(byte)'='){ j+=2; break;}
51
 
      foo[j+2]=(byte)(((val(buf[i+2])&0x03)<<6)|(val(buf[i+3])&0x3f));
52
 
      j+=3;
53
 
    }
54
 
    byte[] bar=new byte[j];
55
 
    System.arraycopy(foo, 0, bar, 0, j);
56
 
    return bar;
57
 
  }
58
 
  static byte[] toBase64(byte[] buf, int start, int length){
59
 
 
60
 
    byte[] tmp=new byte[length*2];
61
 
    int i,j,k;
62
 
    
63
 
    int foo=(length/3)*3+start;
64
 
    i=0;
65
 
    for(j=start; j<foo; j+=3){
66
 
      k=(buf[j]>>>2)&0x3f;
67
 
      tmp[i++]=b64[k];
68
 
      k=(buf[j]&0x03)<<4|(buf[j+1]>>>4)&0x0f;
69
 
      tmp[i++]=b64[k];
70
 
      k=(buf[j+1]&0x0f)<<2|(buf[j+2]>>>6)&0x03;
71
 
      tmp[i++]=b64[k];
72
 
      k=buf[j+2]&0x3f;
73
 
      tmp[i++]=b64[k];
74
 
    }
75
 
 
76
 
    foo=(start+length)-foo;
77
 
    if(foo==1){
78
 
      k=(buf[j]>>>2)&0x3f;
79
 
      tmp[i++]=b64[k];
80
 
      k=((buf[j]&0x03)<<4)&0x3f;
81
 
      tmp[i++]=b64[k];
82
 
      tmp[i++]=(byte)'=';
83
 
      tmp[i++]=(byte)'=';
84
 
    }
85
 
    else if(foo==2){
86
 
      k=(buf[j]>>>2)&0x3f;
87
 
      tmp[i++]=b64[k];
88
 
      k=(buf[j]&0x03)<<4|(buf[j+1]>>>4)&0x0f;
89
 
      tmp[i++]=b64[k];
90
 
      k=((buf[j+1]&0x0f)<<2)&0x3f;
91
 
      tmp[i++]=b64[k];
92
 
      tmp[i++]=(byte)'=';
93
 
    }
94
 
    byte[] bar=new byte[i];
95
 
    System.arraycopy(tmp, 0, bar, 0, i);
96
 
    return bar;
97
 
 
98
 
//    return sun.misc.BASE64Encoder().encode(buf);
99
 
  }
100
 
 
101
 
  static String[] split(String foo, String split){
102
 
    if(foo==null)
103
 
      return null;
104
 
    byte[] buf=foo.getBytes();
105
 
    java.util.Vector bar=new java.util.Vector();
106
 
    int start=0;
107
 
    int index;
108
 
    while(true){
109
 
      index=foo.indexOf(split, start);
110
 
      if(index>=0){
111
 
        bar.addElement(new String(buf, start, index-start));
112
 
        start=index+1;
113
 
        continue;
114
 
      }
115
 
      bar.addElement(new String(buf, start, buf.length-start));
116
 
      break;
117
 
    }
118
 
    String[] result=new String[bar.size()];
119
 
    for(int i=0; i<result.length; i++){
120
 
      result[i]=(String)(bar.elementAt(i));
121
 
    }
122
 
    return result;
123
 
  }
124
 
  static boolean glob(byte[] pattern, byte[] name){
125
 
    return glob0(pattern, 0, name, 0);
126
 
  }
127
 
  static private boolean glob0(byte[] pattern, int pattern_index,
128
 
                              byte[] name, int name_index){
129
 
    if(name.length>0 && name[0]=='.'){
130
 
      if(pattern.length>0 && pattern[0]=='.'){
131
 
        if(pattern.length==2 && pattern[1]=='*') return true;
132
 
        return glob(pattern, pattern_index+1, name, name_index+1);
133
 
      }
134
 
      return false;
135
 
    }
136
 
    return glob(pattern, pattern_index, name, name_index);
137
 
  }
138
 
  static private boolean glob(byte[] pattern, int pattern_index,
139
 
                              byte[] name, int name_index){
140
 
    //System.err.println("glob: "+new String(pattern)+", "+pattern_index+" "+new String(name)+", "+name_index);
141
 
 
142
 
    int patternlen=pattern.length;
143
 
    if(patternlen==0)
144
 
      return false;
145
 
 
146
 
    int namelen=name.length;
147
 
    int i=pattern_index;
148
 
    int j=name_index;
149
 
 
150
 
    while(i<patternlen && j<namelen){
151
 
      if(pattern[i]=='\\'){
152
 
        if(i+1==patternlen)
153
 
          return false;
154
 
        i++;
155
 
        if(pattern[i]!=name[j]) 
156
 
          return false;
157
 
        i+=skipUTF8Char(pattern[i]);
158
 
        j+=skipUTF8Char(name[j]);
159
 
        continue;
160
 
      }
161
 
 
162
 
      if(pattern[i]=='*'){
163
 
        while(i<patternlen){
164
 
          if(pattern[i]=='*'){
165
 
            i++;
166
 
            continue;
167
 
          }
168
 
          break;
169
 
        }
170
 
        if(patternlen==i)
171
 
          return true;
172
 
 
173
 
        byte foo=pattern[i];
174
 
        if(foo=='?'){
175
 
          while(j<namelen){
176
 
            if(glob(pattern, i, name, j)){
177
 
              return true;
178
 
            }
179
 
            j+=skipUTF8Char(name[j]);
180
 
          }
181
 
          return false;
182
 
        }
183
 
        else if(foo=='\\'){
184
 
          if(i+1==patternlen)
185
 
            return false;
186
 
          i++;
187
 
          foo=pattern[i];
188
 
          while(j<namelen){
189
 
            if(foo==name[j]){
190
 
              if(glob(pattern, i+skipUTF8Char(foo),
191
 
                      name, j+skipUTF8Char(name[j]))){
192
 
                return true;
193
 
              }
194
 
            }
195
 
            j+=skipUTF8Char(name[j]);
196
 
          }
197
 
          return false;
198
 
        }
199
 
 
200
 
        while(j<namelen){
201
 
          if(foo==name[j]){
202
 
            if(glob(pattern, i, name, j)){
203
 
              return true;
204
 
            }
205
 
          }
206
 
          j+=skipUTF8Char(name[j]);
207
 
        }
208
 
        return false;
209
 
      }
210
 
 
211
 
      if(pattern[i]=='?'){
212
 
        i++;
213
 
        j+=skipUTF8Char(name[j]);
214
 
        continue;
215
 
      }
216
 
 
217
 
      if(pattern[i]!=name[j])
218
 
        return false;
219
 
 
220
 
      i+=skipUTF8Char(pattern[i]);
221
 
      j+=skipUTF8Char(name[j]);
222
 
 
223
 
      if(!(j<namelen)){         // name is end
224
 
        if(!(i<patternlen)){    // pattern is end
225
 
          return true;
226
 
        }
227
 
        if(pattern[i]=='*'){    
228
 
          break;
229
 
        }
230
 
      }
231
 
      continue;
232
 
    }
233
 
 
234
 
    if(i==patternlen && j==namelen) 
235
 
      return true;
236
 
 
237
 
    if(!(j<namelen) &&  // name is end
238
 
       pattern[i]=='*'){
239
 
      boolean ok=true;
240
 
      while(i<patternlen){
241
 
        if(pattern[i++]!='*'){
242
 
          ok=false;
243
 
          break;
244
 
        }
245
 
      }
246
 
      return ok;
247
 
    }
248
 
 
249
 
    return false;
250
 
  }
251
 
 
252
 
  static String quote(String path){
253
 
    byte[] _path=str2byte(path);
254
 
    int count=0;
255
 
    for(int i=0;i<_path.length; i++){
256
 
      byte b=_path[i];
257
 
      if(b=='\\' || b=='?' || b=='*')
258
 
        count++;
259
 
    }
260
 
    if(count==0)
261
 
      return path;
262
 
    byte[] _path2=new byte[_path.length+count];
263
 
    for(int i=0, j=0; i<_path.length; i++){
264
 
      byte b=_path[i];
265
 
      if(b=='\\' || b=='?' || b=='*'){
266
 
        _path2[j++]='\\';
267
 
      }
268
 
      _path2[j++]=b;
269
 
    }
270
 
    return byte2str(_path2);
271
 
  }
272
 
 
273
 
  static String unquote(String path){
274
 
    byte[] foo=str2byte(path);
275
 
    byte[] bar=unquote(foo);
276
 
    if(foo.length==bar.length)
277
 
      return path;
278
 
    return byte2str(bar);
279
 
  }
280
 
  static byte[] unquote(byte[] path){
281
 
    int pathlen=path.length;
282
 
    int i=0;
283
 
    while(i<pathlen){
284
 
      if(path[i]=='\\'){
285
 
        if(i+1==pathlen)
286
 
          break;
287
 
        System.arraycopy(path, i+1, path, i, path.length-(i+1));
288
 
        pathlen--;
289
 
        i++;
290
 
        continue;
291
 
      }
292
 
      i++;
293
 
    }
294
 
    if(pathlen==path.length)
295
 
      return path;
296
 
    byte[] foo=new byte[pathlen];
297
 
    System.arraycopy(path, 0, foo, 0, pathlen);
298
 
    return foo;
299
 
  }
300
 
 
301
 
  private static String[] chars={
302
 
    "0","1","2","3","4","5","6","7","8","9", "a","b","c","d","e","f"
303
 
  };
304
 
  static String getFingerPrint(HASH hash, byte[] data){
305
 
    try{
306
 
      hash.init();
307
 
      hash.update(data, 0, data.length);
308
 
      byte[] foo=hash.digest();
309
 
      StringBuffer sb=new StringBuffer();
310
 
      int bar;
311
 
      for(int i=0; i<foo.length;i++){
312
 
        bar=foo[i]&0xff;
313
 
        sb.append(chars[(bar>>>4)&0xf]);
314
 
        sb.append(chars[(bar)&0xf]);
315
 
        if(i+1<foo.length)
316
 
          sb.append(":");
317
 
      }
318
 
      return sb.toString();
319
 
    }
320
 
    catch(Exception e){
321
 
      return "???";
322
 
    }
323
 
  }
324
 
  static boolean array_equals(byte[] foo, byte bar[]){
325
 
    int i=foo.length;
326
 
    if(i!=bar.length) return false;
327
 
    for(int j=0; j<i; j++){ if(foo[j]!=bar[j]) return false; }
328
 
    //try{while(true){i--; if(foo[i]!=bar[i])return false;}}catch(Exception e){}
329
 
    return true;
330
 
  }
331
 
  static Socket createSocket(String host, int port, int timeout) throws JSchException{
332
 
    Socket socket=null;
333
 
    if(timeout==0){
334
 
      try{
335
 
        socket=new Socket(host, port);
336
 
        return socket;
337
 
      }
338
 
      catch(Exception e){
339
 
        String message=e.toString();
340
 
        if(e instanceof Throwable)
341
 
          throw new JSchException(message, (Throwable)e);
342
 
        throw new JSchException(message);
343
 
      }
344
 
    }
345
 
    final String _host=host;
346
 
    final int _port=port;
347
 
    final Socket[] sockp=new Socket[1];
348
 
    final Exception[] ee=new Exception[1];
349
 
    String message="";
350
 
    Thread tmp=new Thread(new Runnable(){
351
 
        public void run(){
352
 
          sockp[0]=null;
353
 
          try{
354
 
            sockp[0]=new Socket(_host, _port);
355
 
          }
356
 
          catch(Exception e){
357
 
            ee[0]=e;
358
 
            if(sockp[0]!=null && sockp[0].isConnected()){
359
 
              try{
360
 
                sockp[0].close();
361
 
              }
362
 
              catch(Exception eee){}
363
 
            }
364
 
            sockp[0]=null;
365
 
          }
366
 
        }
367
 
      });
368
 
    tmp.setName("Opening Socket "+host);
369
 
    tmp.start();
370
 
    try{ 
371
 
      tmp.join(timeout);
372
 
      message="timeout: ";
373
 
    }
374
 
    catch(java.lang.InterruptedException eee){
375
 
    }
376
 
    if(sockp[0]!=null && sockp[0].isConnected()){
377
 
      socket=sockp[0];
378
 
    }
379
 
    else{
380
 
      message+="socket is not established";
381
 
      if(ee[0]!=null){
382
 
        message=ee[0].toString();
383
 
      }
384
 
      tmp.interrupt();
385
 
      tmp=null;
386
 
      throw new JSchException(message);
387
 
    }
388
 
    return socket;
389
 
  } 
390
 
 
391
 
  static byte[] str2byte(String str, String encoding){
392
 
    if(str==null) 
393
 
      return null;
394
 
    try{ return str.getBytes(encoding); }
395
 
    catch(java.io.UnsupportedEncodingException e){
396
 
      return str.getBytes();
397
 
    }
398
 
  }
399
 
 
400
 
  static byte[] str2byte(String str){
401
 
    return str2byte(str, "UTF-8");
402
 
  }
403
 
 
404
 
  static String byte2str(byte[] str, String encoding){
405
 
    try{ return new String(str, encoding); }
406
 
    catch(java.io.UnsupportedEncodingException e){
407
 
      return new String(str);
408
 
    }
409
 
  }
410
 
 
411
 
  static String byte2str(byte[] str){
412
 
    return byte2str(str, "UTF-8");
413
 
  }
414
 
 
415
 
  /*
416
 
  static byte[] char2byte(char[] foo){
417
 
    int len=0;
418
 
    for(int i=0; i<foo.length; i++){
419
 
      if((foo[i]&0xff00)==0) len++;
420
 
      else len+=2;
421
 
    }
422
 
    byte[] bar=new byte[len];
423
 
    for(int i=0, j=0; i<foo.length; i++){
424
 
      if((foo[i]&0xff00)==0){
425
 
        bar[j++]=(byte)foo[i];
426
 
      }
427
 
      else{
428
 
        bar[j++]=(byte)(foo[i]>>>8);
429
 
        bar[j++]=(byte)foo[i];
430
 
      }
431
 
    }
432
 
    return bar;
433
 
  }
434
 
  */
435
 
  static void bzero(byte[] foo){
436
 
    if(foo==null)
437
 
      return;
438
 
    for(int i=0; i<foo.length; i++)
439
 
      foo[i]=0;
440
 
  }
441
 
 
442
 
  static String diffString(String str, String[] not_available){
443
 
    String[] stra=Util.split(str, ",");
444
 
    String result=null;
445
 
    loop:
446
 
    for(int i=0; i<stra.length; i++){
447
 
      for(int j=0; j<not_available.length; j++){
448
 
        if(stra[i].equals(not_available[j])){
449
 
          continue loop;
450
 
        }
451
 
      }
452
 
      if(result==null){ result=stra[i]; }
453
 
      else{ result=result+","+stra[i]; }
454
 
    }
455
 
    return result;
456
 
  }
457
 
 
458
 
  private static int skipUTF8Char(byte b){
459
 
    if((byte)(b&0x80)==0) return 1;
460
 
    if((byte)(b&0xe0)==(byte)0xc0) return 2;
461
 
    if((byte)(b&0xf0)==(byte)0xe0) return 3;
462
 
    return 1;
463
 
  }
464
 
}