Changeset 841feae


Ignore:
Timestamp:
Dec 30, 2008 7:52:04 AM (12 years ago)
Author:
sponge <sponge@…>
Branches:
master
Children:
161379f
Parents:
ba8de6c
Message:

Bugfix for getting Properties to actually work.

Location:
apps/BOB
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • apps/BOB/nbproject/project.properties

    rba8de6c r841feae  
    11application.title=BOB
    22application.vendor=root
     3auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.expand-tabs=false
     4auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.indent-shift-width=8
     5auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.spaces-per-tab=8
     6auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.tab-size=8
     7auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.text-limit-width=80
     8auxiliary.org-netbeans-modules-editor-indent.CodeStyle.usedProfile=project
    39build.classes.dir=${build.dir}/classes
    410build.classes.excludes=**/*.java,**/*.form
     
    7783javadoc.version=false
    7884javadoc.windowtitle=
     85jnlp.codebase.type=local
     86jnlp.codebase.url=file:/root/NetBeansProjects/i2p.i2p/apps/BOB/dist/
     87jnlp.descriptor=application
     88jnlp.enabled=false
     89jnlp.offline-allowed=false
     90jnlp.signed=false
    7991main.class=net.i2p.BOB.Main
    8092manifest.file=manifest.mf
  • apps/BOB/src/net/i2p/BOB/BOB.java

    rba8de6c r841feae  
    115115        private static int maxConnections = 0;
    116116        private static NamedDB database;
     117        private static Properties props = new Properties();
     118
    117119
    118120        /**
     
    158160                // Re-reading the config file in each thread is pretty damn stupid.
    159161                // I2PClient client = I2PClientFactory.createClient();
    160                 Properties props = new Properties();
    161162                String configLocation = System.getProperty(PROP_CONFIG_LOCATION, "bob.config");
    162163
     
    218219
    219220                try {
     221                        info(props.toString());
    220222                        info("BOB is now running.");
    221223                        ServerSocket listener = new ServerSocket(Integer.parseInt(props.getProperty(PROP_BOB_PORT)), 10, InetAddress.getByName(props.getProperty(PROP_BOB_HOST)));
  • apps/BOB/src/net/i2p/BOB/DoCMDS.java

    rba8de6c r841feae  
    9090        private static final String C_setnick = "setnick";
    9191        private static final String C_show = "show";
     92        private static final String C_show_props = "showprops";
    9293        private static final String C_start = "start";
    9394        private static final String C_status = "status";
     
    114115                {C_setnick, C_setnick + " nickname * Create a new nickname."},
    115116                {C_show, C_show + " * Display the status of the current nickname."},
     117                {C_show_props, C_show_props + " * Display the properties of the current nickname."},
    116118                {C_start, C_start + " * Start the current nickname tunnel."},
    117119                {C_status, C_status + " nickname * Display status of a nicknamed tunnel."},
     
    119121                {C_verify, C_verify + " BASE64_key * Verifies BASE64 destination."},
    120122                {"", "COMMANDS: " + // this is ugly, but...
    121                  C_help + " " +
    122                  C_clear + " " +
    123                  C_getdest + " " +
    124                  C_getkeys + " " +
    125                  C_getnick + " " +
    126                  C_inhost + " " +
    127                  C_inport + " " +
    128                  C_list + " " +
    129                  C_newkeys + " " +
    130                  C_option + " " +
    131                  C_outhost + " " +
    132                  C_outport + " " +
    133                  C_quiet + " " +
    134                  C_quit + " " +
    135                  C_setkeys + " " +
    136                  C_setnick + " " +
    137                  C_show + " " +
    138                  C_start + " " +
    139                  C_status + " " +
    140                  C_stop + " " +
    141                  C_verify
     123                        C_help + " " +
     124                        C_clear + " " +
     125                        C_getdest + " " +
     126                        C_getkeys + " " +
     127                        C_getnick + " " +
     128                        C_inhost + " " +
     129                        C_inport + " " +
     130                        C_list + " " +
     131                        C_newkeys + " " +
     132                        C_option + " " +
     133                        C_outhost + " " +
     134                        C_outport + " " +
     135                        C_quiet + " " +
     136                        C_quit + " " +
     137                        C_setkeys + " " +
     138                        C_setnick + " " +
     139                        C_show + " " +
     140                        C_show_props + " " +
     141                        C_start + " " +
     142                        C_status + " " +
     143                        C_stop + " " +
     144                        C_verify
    142145                },
    143146                {" ", " "} // end of list
     
    153156        DoCMDS(Socket server, Properties props, NamedDB database, Log _log) {
    154157                this.server = server;
    155                 this.props = new Properties(props);
     158                this.props = new Properties();
    156159                this.database = database;
    157160                this._log = _log;
     161                Lifted.copyProperties(props, this.props);
    158162        }
    159163
     
    205209                try {
    206210                        rlock(info);
    207                 } catch(Exception e) {
     211                } catch (Exception e) {
    208212                        throw new Exception(e);
    209213                }
    210214                try {
    211215                        out.print(" " + key + ": ");
    212                         if(info.exists(key)) {
     216                        if (info.exists(key)) {
    213217                                out.print(info.get(key));
    214218                        } else {
    215219                                out.print("not_set");
    216220                        }
    217                 } catch(Exception e) {
     221                } catch (Exception e) {
    218222                        runlock(info);
    219223                        throw new Exception(e);
     
    233237                try {
    234238                        rlock(info);
    235                 } catch(Exception e) {
     239                } catch (Exception e) {
    236240                        throw new Exception(e);
    237241                }
     
    239243                        out.print(" " + key + ": ");
    240244                        out.print(info.exists(key));
    241                 } catch(Exception e) {
     245                } catch (Exception e) {
    242246                        runlock(info);
    243247                        throw new Exception(e);
     
    265269                try {
    266270                        rlock(info);
    267                 } catch(Exception e) {
     271                } catch (Exception e) {
    268272                        throw new Exception(e);
    269273                }
     
    281285                        trypnt(out, info, P_OUTHOST);
    282286                        out.println();
    283                 } catch(Exception e) {
     287                } catch (Exception e) {
     288                        runlock(info);
     289                        throw new Exception(e);
     290                }
     291
     292                runlock(info);
     293        }
     294
     295        /**
     296         * Dump properties information from the database
     297         *
     298         * @param out
     299         * @param info
     300         * @throws Exception
     301         */
     302        private void propprint(PrintStream out, NamedDB info) throws Exception {
     303                try {
     304                        rlock(info);
     305                } catch (Exception e) {
     306                        throw new Exception(e);
     307                }
     308                try {
     309
     310                        trypnt(out, info, P_PROPERTIES);
     311                        out.println();
     312                } catch (Exception e) {
    284313                        runlock(info);
    285314                        throw new Exception(e);
     
    298327                try {
    299328                        database.getReadLock();
    300                 } catch(Exception e) {
     329                } catch (Exception e) {
    301330                        throw new Exception(e);
    302331                }
    303332
    304333                try {
    305                         if(database.exists(Arg)) {
     334                        if (database.exists(Arg)) {
    306335                                out.print("DATA");
    307                                 nickprint(out, (NamedDB)database.get(Arg));
     336                                nickprint(out, (NamedDB) database.get(Arg));
    308337                        }
    309                 } catch(Exception e) {
     338                } catch (Exception e) {
    310339                        database.releaseReadLock();
    311340                        throw new Exception(e);
     
    326355                try {
    327356                        rlock(Arg);
    328                 } catch(Exception e) {
     357                } catch (Exception e) {
    329358                        throw new Exception(e);
    330359                }
     
    334363                                Arg.get(P_STOPPING).equals(Boolean.TRUE) ||
    335364                                Arg.get(P_RUNNING).equals(Boolean.TRUE));
    336                 } catch(Exception e) {
     365                } catch (Exception e) {
    337366                        runlock();
    338367                        throw new Exception(e);
     
    353382                        Destination x = new Destination(data);
    354383                        return true;
    355                 } catch(Exception e) {
     384                } catch (Exception e) {
    356385                        return false;
    357386                }
     
    370399                        BufferedReader in = new BufferedReader(new InputStreamReader(server.getInputStream()));
    371400                        PrintStream out = new PrintStream(server.getOutputStream());
    372 quit:                   {
    373 die:                            {
     401                        quit:
     402                        {
     403                                die:
     404                                {
    374405                                        prikey = new ByteArrayOutputStream();
    375406                                        out.println("BOB " + BOBversion);
    376407                                        out.println("OK");
    377                                         while((line = in.readLine()) != null) {
     408                                        while ((line = in.readLine()) != null) {
    378409                                                StringTokenizer token = new StringTokenizer(line, " "); // use a space as a delimiter
    379410                                                String Command = "";
     
    381412                                                NamedDB info;
    382413
    383                                                 if(token.countTokens() != 0) {
     414                                                if (token.countTokens() != 0) {
    384415                                                        Command = token.nextToken();
    385416                                                        Command =
    386417                                                                Command.toLowerCase();
    387                                                         if(token.countTokens() != 0) {
     418                                                        if (token.countTokens() != 0) {
    388419                                                                Arg = token.nextToken();
    389420                                                        } else {
     
    392423                                                        // The rest of the tokens are considered junk,
    393424                                                        // and discarded without any warnings.
    394                                                         if(Command.equals(C_help)) {
    395                                                                 for(int i = 0; !C_ALL[i][0].equals(" "); i++) {
    396                                                                         if(C_ALL[i][0].equalsIgnoreCase(Arg)) {
     425                                                        if (Command.equals(C_help)) {
     426                                                                for (int i = 0; !C_ALL[i][0].equals(" "); i++) {
     427                                                                        if (C_ALL[i][0].equalsIgnoreCase(Arg)) {
    397428                                                                                out.println("OK " + C_ALL[i][1]);
    398429                                                                        }
    399430
    400431                                                                }
    401                                                         } else if(Command.equals(C_getdest)) {
    402                                                                 if(ns) {
    403                                                                         if(dk) {
     432                                                        } else if (Command.equals(C_getdest)) {
     433                                                                if (ns) {
     434                                                                        if (dk) {
    404435                                                                                try {
    405436                                                                                        rlock();
    406                                                                                 } catch(Exception ex) {
     437                                                                                } catch (Exception ex) {
    407438                                                                                        break die;
    408439                                                                                }
     
    410441                                                                                try {
    411442                                                                                        out.println("OK " + nickinfo.get(P_DEST));
    412                                                                                 } catch(Exception e) {
     443                                                                                } catch (Exception e) {
    413444                                                                                        try {
    414445                                                                                                runlock();
    415                                                                                         } catch(Exception ex) {
     446                                                                                        } catch (Exception ex) {
    416447                                                                                                break die;
    417448                                                                                        }
     
    421452                                                                                try {
    422453                                                                                        runlock();
    423                                                                                 } catch(Exception ex) {
     454                                                                                } catch (Exception ex) {
    424455                                                                                        break die;
    425456                                                                                }
     
    433464                                                                }
    434465
    435                                                         } else if(Command.equals(C_list)) {
     466                                                        } else if (Command.equals(C_list)) {
    436467                                                                // Produce a formatted list of all nicknames
    437468                                                                database.getReadLock();
    438                                                                 for(int i = 0; i <
     469                                                                for (int i = 0; i <
    439470                                                                        database.getcount(); i++) {
    440471                                                                        try {
    441                                                                                 info = (NamedDB)database.getnext(i);
     472                                                                                info = (NamedDB) database.getnext(i);
    442473                                                                                out.print("DATA");
    443                                                                         } catch(Exception e) {
     474                                                                        } catch (Exception e) {
    444475                                                                                database.releaseReadLock();
    445476                                                                                break die;
     
    448479                                                                        try {
    449480                                                                                info.getReadLock();
    450                                                                         } catch(Exception ex) {
     481                                                                        } catch (Exception ex) {
    451482                                                                                break die;
    452483                                                                        }
    453484                                                                        try {
    454485                                                                                nickprint(out, info);
    455                                                                         } catch(Exception e) {
     486                                                                        } catch (Exception e) {
    456487                                                                                try {
    457488                                                                                        info.releaseReadLock();
    458489                                                                                        database.releaseReadLock();
    459                                                                                 } catch(Exception ex) {
     490                                                                                } catch (Exception ex) {
    460491                                                                                        break die;
    461492                                                                                }
     
    465496                                                                        try {
    466497                                                                                info.releaseReadLock();
    467                                                                         } catch(Exception ex) {
     498                                                                        } catch (Exception ex) {
    468499                                                                                break die;
    469500                                                                        }
     
    472503                                                                try {
    473504                                                                        database.releaseReadLock();
    474                                                                 } catch(Exception ex) {
     505                                                                } catch (Exception ex) {
    475506                                                                        break die;
    476507                                                                }
    477508                                                                out.println("OK Listing done");
    478                                                         } else if(Command.equals(C_quit)) {
     509                                                        } else if (Command.equals(C_quit)) {
    479510                                                                // End the command session
    480511                                                                break quit;
    481                                                         } else if(Command.equals(C_newkeys)) {
    482                                                                 if(ns) {
    483                                                                         try {
    484                                                                                 if(tunnelactive(nickinfo)) {
     512                                                        } else if (Command.equals(C_newkeys)) {
     513                                                                if (ns) {
     514                                                                        try {
     515                                                                                if (tunnelactive(nickinfo)) {
    485516                                                                                        out.println("ERROR tunnel is active");
    486517                                                                                } else {
     
    491522                                                                                                try {
    492523                                                                                                        wlock();
    493                                                                                                 } catch(Exception e) {
     524                                                                                                } catch (Exception e) {
    494525                                                                                                        break die;
    495526                                                                                                }
     
    498529                                                                                                        nickinfo.add(P_KEYS, prikey.toByteArray());
    499530                                                                                                        nickinfo.add(P_DEST, d.toBase64());
    500                                                                                                 } catch(Exception e) {
     531                                                                                                } catch (Exception e) {
    501532                                                                                                        try {
    502533                                                                                                                wunlock();
    503                                                                                                         } catch(Exception ex) {
     534                                                                                                        } catch (Exception ex) {
    504535                                                                                                                break die;
    505536                                                                                                        }
     
    510541                                                                                                try {
    511542                                                                                                        wunlock();
    512                                                                                                 } catch(Exception ex) {
     543                                                                                                } catch (Exception ex) {
    513544                                                                                                        break die;
    514545                                                                                                }
     
    516547                                                                                                try {
    517548                                                                                                        rlock();
    518                                                                                                 } catch(Exception ex) {
     549                                                                                                } catch (Exception ex) {
    519550                                                                                                        break die;
    520551                                                                                                }
     
    522553                                                                                                try {
    523554                                                                                                        out.println("OK " + nickinfo.get(P_DEST));
    524                                                                                                 } catch(Exception e) {
     555                                                                                                } catch (Exception e) {
    525556                                                                                                        runlock();
    526557                                                                                                        break die;
     
    529560                                                                                                try {
    530561                                                                                                        runlock();
    531                                                                                                 } catch(Exception ex) {
    532                                                                                                         break die;
    533                                                                                                 }
    534                                                                                         } catch(I2PException ipe) {
     562                                                                                                } catch (Exception ex) {
     563                                                                                                        break die;
     564                                                                                                }
     565                                                                                        } catch (I2PException ipe) {
    535566                                                                                                BOB.error("Error generating keys" + ipe);
    536567                                                                                                out.println("ERROR generating keys");
     
    538569
    539570                                                                                }
    540                                                                         } catch(Exception e) {
     571                                                                        } catch (Exception e) {
    541572                                                                                break die;
    542573                                                                        }
     
    545576                                                                        try {
    546577                                                                                nns(out);
    547                                                                         } catch(Exception ex) {
    548                                                                                 break die;
    549                                                                         }
    550                                                                 }
    551 
    552                                                         } else if(Command.equals(C_getkeys)) {
     578                                                                        } catch (Exception ex) {
     579                                                                                break die;
     580                                                                        }
     581                                                                }
     582
     583                                                        } else if (Command.equals(C_getkeys)) {
    553584                                                                // Return public key
    554                                                                 if(dk) {
     585                                                                if (dk) {
    555586                                                                        prikey = new ByteArrayOutputStream();
    556587                                                                        try {
    557588                                                                                rlock();
    558                                                                         } catch(Exception e) {
    559                                                                                 break die;
    560                                                                         }
    561                                                                         try {
    562                                                                                 prikey.write(((byte[])nickinfo.get(P_KEYS)));
    563                                                                         } catch(Exception ex) {
     589                                                                        } catch (Exception e) {
     590                                                                                break die;
     591                                                                        }
     592                                                                        try {
     593                                                                                prikey.write(((byte[]) nickinfo.get(P_KEYS)));
     594                                                                        } catch (Exception ex) {
    564595                                                                                try {
    565596                                                                                        runlock();
    566                                                                                 } catch(Exception ee) {
     597                                                                                } catch (Exception ee) {
    567598                                                                                        break die;
    568599                                                                                }
     
    571602                                                                        try {
    572603                                                                                runlock();
    573                                                                         } catch(Exception e) {
     604                                                                        } catch (Exception e) {
    574605                                                                                break die;
    575606                                                                        }
     
    580611                                                                }
    581612
    582                                                         } else if(Command.equals(C_quiet)) {
    583                                                                 if(ns) {
    584                                                                         try {
    585                                                                                 if(tunnelactive(nickinfo)) {
     613                                                        } else if (Command.equals(C_quiet)) {
     614                                                                if (ns) {
     615                                                                        try {
     616                                                                                if (tunnelactive(nickinfo)) {
    586617                                                                                        out.println("ERROR tunnel is active");
    587618                                                                                } else {
    588619                                                                                        try {
    589620                                                                                                wlock();
    590                                                                                         } catch(Exception ex) {
     621                                                                                        } catch (Exception ex) {
    591622                                                                                                break die;
    592623                                                                                        }
    593624                                                                                        try {
    594625                                                                                                nickinfo.add(P_QUIET, new Boolean(Boolean.parseBoolean(Arg) == true));
    595                                                                                         } catch(Exception ex) {
     626                                                                                        } catch (Exception ex) {
    596627                                                                                                try {
    597628                                                                                                        wunlock();
    598                                                                                                 } catch(Exception ee) {
     629                                                                                                } catch (Exception ee) {
    599630                                                                                                        break die;
    600631                                                                                                }
     
    604635                                                                                        try {
    605636                                                                                                wunlock();
    606                                                                                         } catch(Exception ex) {
     637                                                                                        } catch (Exception ex) {
    607638                                                                                                break die;
    608639                                                                                        }
     
    611642                                                                                }
    612643
    613                                                                         } catch(Exception ex) {
     644                                                                        } catch (Exception ex) {
    614645                                                                                break die;
    615646                                                                        }
     
    618649                                                                        try {
    619650                                                                                nns(out);
    620                                                                         } catch(Exception ex) {
    621                                                                                 break die;
    622                                                                         }
    623                                                                 }
    624 
    625                                                         }else if(Command.equals(C_verify)) {
    626                                                                 if(is64ok(Arg)) {
     651                                                                        } catch (Exception ex) {
     652                                                                                break die;
     653                                                                        }
     654                                                                }
     655
     656                                                        } else if (Command.equals(C_verify)) {
     657                                                                if (is64ok(Arg)) {
    627658                                                                        out.println("OK");
    628659                                                                } else {
    629660                                                                        out.println("ERROR not in BASE64 format");
    630661                                                                }
    631                                                         } else if(Command.equals(C_setkeys)) {
     662                                                        } else if (Command.equals(C_setkeys)) {
    632663                                                                // Set the NamedDB to a privatekey in BASE64 format
    633                                                                 if(ns) {
    634                                                                         try {
    635                                                                                 if(tunnelactive(nickinfo)) {
     664                                                                if (ns) {
     665                                                                        try {
     666                                                                                if (tunnelactive(nickinfo)) {
    636667                                                                                        out.println("ERROR tunnel is active");
    637668                                                                                } else {
     
    640671                                                                                                prikey.write(net.i2p.data.Base64.decode(Arg));
    641672                                                                                                d.fromBase64(Arg);
    642                                                                                         } catch(Exception ex) {
     673                                                                                        } catch (Exception ex) {
    643674                                                                                                Arg = "";
    644675                                                                                        }
    645676
    646                                                                                         if((Arg.length() == 884) && is64ok(Arg)) {
     677                                                                                        if ((Arg.length() == 884) && is64ok(Arg)) {
    647678                                                                                                try {
    648679                                                                                                        wlock();
    649                                                                                                 } catch(Exception ex) {
     680                                                                                                } catch (Exception ex) {
    650681                                                                                                        break die;
    651682                                                                                                }
     
    653684                                                                                                        nickinfo.add(P_KEYS, prikey.toByteArray());
    654685                                                                                                        nickinfo.add(P_DEST, d.toBase64());
    655                                                                                                 } catch(Exception ex) {
     686                                                                                                } catch (Exception ex) {
    656687                                                                                                        try {
    657688                                                                                                                wunlock();
    658                                                                                                         } catch(Exception ee) {
     689                                                                                                        } catch (Exception ee) {
    659690                                                                                                                break die;
    660691                                                                                                        }
     
    664695                                                                                                try {
    665696                                                                                                        wunlock();
    666                                                                                                 } catch(Exception ex) {
     697                                                                                                } catch (Exception ex) {
    667698                                                                                                        break die;
    668699                                                                                                }
     
    670701                                                                                                try {
    671702                                                                                                        rlock();
    672                                                                                                 } catch(Exception ex) {
     703                                                                                                } catch (Exception ex) {
    673704                                                                                                        break die;
    674705                                                                                                }
     
    676707                                                                                                try {
    677708                                                                                                        out.println("OK " + nickinfo.get(P_DEST));
    678                                                                                                 } catch(Exception e) {
     709                                                                                                } catch (Exception e) {
    679710                                                                                                        try {
    680711                                                                                                                runlock();
    681                                                                                                         } catch(Exception ex) {
     712                                                                                                        } catch (Exception ex) {
    682713                                                                                                                break die;
    683714                                                                                                        }
     
    687718                                                                                                try {
    688719                                                                                                        runlock();
    689                                                                                                 } catch(Exception ex) {
     720                                                                                                } catch (Exception ex) {
    690721                                                                                                        break die;
    691722                                                                                                }
     
    695726
    696727                                                                                }
    697                                                                         } catch(Exception ex) {
     728                                                                        } catch (Exception ex) {
    698729                                                                                break die;
    699730                                                                        }
     
    702733                                                                        try {
    703734                                                                                nns(out);
    704                                                                         } catch(Exception ex) {
    705                                                                                 break die;
    706                                                                         }
    707                                                                 }
    708 
    709                                                         } else if(Command.equals(C_setnick)) {
     735                                                                        } catch (Exception ex) {
     736                                                                                break die;
     737                                                                        }
     738                                                                }
     739
     740                                                        } else if (Command.equals(C_setnick)) {
    710741                                                                ns = dk = ip = op = false;
    711742                                                                try {
    712743                                                                        database.getReadLock();
    713                                                                 } catch(Exception ex) {
     744                                                                } catch (Exception ex) {
    714745                                                                        break die;
    715746                                                                }
    716747                                                                try {
    717                                                                         nickinfo = (NamedDB)database.get(Arg);
    718                                                                         if(!tunnelactive(nickinfo)) {
     748                                                                        nickinfo = (NamedDB) database.get(Arg);
     749                                                                        if (!tunnelactive(nickinfo)) {
    719750                                                                                nickinfo = null;
    720751                                                                                ns =
     
    722753                                                                        }
    723754
    724                                                                 } catch(Exception b) {
     755                                                                } catch (Exception b) {
    725756                                                                        nickinfo = null;
    726757                                                                        ns =
     
    730761                                                                try {
    731762                                                                        database.releaseReadLock();
    732                                                                 } catch(Exception ex) {
     763                                                                } catch (Exception ex) {
    733764                                                                        break die;
    734765                                                                }
    735766                                                                // Clears and Sets the initial NamedDB structure to work with
    736                                                                 if(ns) {
     767                                                                if (ns) {
    737768                                                                        nickinfo = new NamedDB();
    738769                                                                        try {
    739770                                                                                wlock();
    740                                                                         } catch(Exception e) {
     771                                                                        } catch (Exception e) {
    741772                                                                                break die;
    742773                                                                        }
     
    751782                                                                                nickinfo.add(P_INHOST, "localhost");
    752783                                                                                nickinfo.add(P_OUTHOST, "localhost");
    753                                                                                 Properties Q = new Properties(props);
     784                                                                                Properties Q = new Properties();
     785                                                                                Lifted.copyProperties(this.props, Q);
    754786                                                                                Q.setProperty("inbound.nickname", Arg);
    755787                                                                                Q.setProperty("outbound.nickname", Arg);
    756788                                                                                nickinfo.add(P_PROPERTIES, Q);
    757                                                                         } catch(Exception e) {
     789                                                                        } catch (Exception e) {
    758790                                                                                try {
    759791                                                                                        wunlock();
    760792                                                                                        break die;
    761                                                                                 } catch(Exception ee) {
     793                                                                                } catch (Exception ee) {
    762794                                                                                        break die;
    763795                                                                                }
     
    766798                                                                        try {
    767799                                                                                wunlock();
    768                                                                         } catch(Exception e) {
     800                                                                        } catch (Exception e) {
    769801                                                                                break die;
    770802                                                                        }
     
    775807                                                                }
    776808
    777                                                         } else if(Command.equals(C_option)) {
    778                                                                 if(ns) {
    779                                                                         try {
    780                                                                                 if(tunnelactive(nickinfo)) {
     809                                                        } else if (Command.equals(C_option)) {
     810                                                                if (ns) {
     811                                                                        try {
     812                                                                                if (tunnelactive(nickinfo)) {
    781813                                                                                        out.println("ERROR tunnel is active");
    782814                                                                                } else {
    783815                                                                                        StringTokenizer otoken = new StringTokenizer(Arg, "="); // use an equal sign as a delimiter
    784                                                                                         if(otoken.countTokens() != 2) {
     816                                                                                        if (otoken.countTokens() != 2) {
    785817                                                                                                out.println("ERROR to many or no options.");
    786818                                                                                        } else {
     
    789821                                                                                                try {
    790822                                                                                                        rlock();
    791                                                                                                 } catch(Exception ex) {
    792                                                                                                         break die;
    793                                                                                                 }
    794 
    795                                                                                                 Properties Q = (Properties)nickinfo.get(P_PROPERTIES);
     823                                                                                                } catch (Exception ex) {
     824                                                                                                        break die;
     825                                                                                                }
     826
     827                                                                                                Properties Q = (Properties) nickinfo.get(P_PROPERTIES);
    796828                                                                                                try {
    797829                                                                                                        runlock();
    798                                                                                                 } catch(Exception ex) {
     830                                                                                                } catch (Exception ex) {
    799831                                                                                                        break die;
    800832                                                                                                }
     
    803835                                                                                                try {
    804836                                                                                                        wlock();
    805                                                                                                 } catch(Exception ex) {
     837                                                                                                } catch (Exception ex) {
    806838                                                                                                        break die;
    807839                                                                                                }
     
    809841                                                                                                try {
    810842                                                                                                        nickinfo.add(P_PROPERTIES, Q);
    811                                                                                                 } catch(Exception ex) {
     843                                                                                                } catch (Exception ex) {
    812844                                                                                                        try {
    813845                                                                                                                wunlock();
    814                                                                                                         } catch(Exception ee) {
     846                                                                                                        } catch (Exception ee) {
    815847                                                                                                                break die;
    816848                                                                                                        }
     
    819851                                                                                                try {
    820852                                                                                                        wunlock();
    821                                                                                                 } catch(Exception ex) {
     853                                                                                                } catch (Exception ex) {
    822854                                                                                                        break die;
    823855                                                                                                }
     
    827859
    828860                                                                                }
    829                                                                         } catch(Exception ex) {
     861                                                                        } catch (Exception ex) {
    830862                                                                                break die;
    831863                                                                        }
     
    835867                                                                }
    836868
    837                                                         } else if(Command.equals(C_getnick)) {
     869                                                        } else if (Command.equals(C_getnick)) {
    838870                                                                // Get the NamedDB to work with...
    839871                                                                try {
    840872                                                                        database.getReadLock();
    841                                                                 } catch(Exception ex) {
     873                                                                } catch (Exception ex) {
    842874                                                                        break die;
    843875                                                                }
    844876                                                                try {
    845                                                                         nickinfo = (NamedDB)database.get(Arg);
     877                                                                        nickinfo = (NamedDB) database.get(Arg);
    846878                                                                        ns = true;
    847                                                                 } catch(RuntimeException b) {
     879                                                                } catch (RuntimeException b) {
    848880                                                                        try {
    849881                                                                                nns(out);
    850                                                                         } catch(Exception ex) {
     882                                                                        } catch (Exception ex) {
    851883                                                                                try {
    852884                                                                                        database.releaseReadLock();
    853                                                                                 } catch(Exception ee) {
     885                                                                                } catch (Exception ee) {
    854886                                                                                        break die;
    855887                                                                                }
     
    859891
    860892                                                                database.releaseReadLock();
    861                                                                 if(ns) {
     893                                                                if (ns) {
    862894                                                                        try {
    863895                                                                                rlock();
    864                                                                         } catch(Exception e) {
     896                                                                        } catch (Exception e) {
    865897                                                                                break die;
    866898                                                                        }
     
    869901                                                                                ip = nickinfo.exists(P_INPORT);
    870902                                                                                op = nickinfo.exists(P_OUTPORT);
    871                                                                         } catch(Exception ex) {
     903                                                                        } catch (Exception ex) {
    872904                                                                                try {
    873905                                                                                        runlock();
    874                                                                                 } catch(Exception ee) {
     906                                                                                } catch (Exception ee) {
    875907                                                                                        break die;
    876908                                                                                }
     
    879911                                                                        try {
    880912                                                                                runlock();
    881                                                                         } catch(Exception e) {
     913                                                                        } catch (Exception e) {
    882914                                                                                break die;
    883915                                                                        }
     
    886918                                                                }
    887919
    888                                                         } else if(Command.equals(C_inport)) {
     920                                                        } else if (Command.equals(C_inport)) {
    889921                                                                // Set the NamedDB inbound TO the router port
    890922                                                                // app --> BOB
    891                                                                 if(ns) {
    892                                                                         try {
    893                                                                                 if(tunnelactive(nickinfo)) {
     923                                                                if (ns) {
     924                                                                        try {
     925                                                                                if (tunnelactive(nickinfo)) {
    894926                                                                                        out.println("ERROR tunnel is active");
    895927                                                                                } else {
     
    897929                                                                                        try {
    898930                                                                                                wlock();
    899                                                                                         } catch(Exception ex) {
     931                                                                                        } catch (Exception ex) {
    900932                                                                                                break die;
    901933                                                                                        }
     
    903935                                                                                        try {
    904936                                                                                                nickinfo.kill(P_INPORT);
    905                                                                                         } catch(Exception ex) {
     937                                                                                        } catch (Exception ex) {
    906938                                                                                                try {
    907939                                                                                                        wunlock();
    908                                                                                                 } catch(Exception ee) {
     940                                                                                                } catch (Exception ee) {
    909941                                                                                                        break die;
    910942                                                                                                }
     
    914946                                                                                        try {
    915947                                                                                                prt = Integer.parseInt(Arg);
    916                                                                                                 if(prt > 1 && prt < 65536) {
     948                                                                                                if (prt > 1 && prt < 65536) {
    917949                                                                                                        try {
    918950                                                                                                                nickinfo.add(P_INPORT, new Integer(prt));
    919                                                                                                         } catch(Exception ex) {
     951                                                                                                        } catch (Exception ex) {
    920952                                                                                                                try {
    921953                                                                                                                        wunlock();
    922                                                                                                                 } catch(Exception ee) {
     954                                                                                                                } catch (Exception ee) {
    923955                                                                                                                        break die;
    924956                                                                                                                }
     
    928960                                                                                                }
    929961
    930                                                                                         } catch(NumberFormatException nfe) {
     962                                                                                        } catch (NumberFormatException nfe) {
    931963                                                                                                out.println("ERROR not a number");
    932964                                                                                        }
     
    934966                                                                                        try {
    935967                                                                                                wunlock();
    936                                                                                         } catch(Exception ex) {
     968                                                                                        } catch (Exception ex) {
    937969                                                                                                break die;
    938970                                                                                        }
    939971                                                                                        try {
    940972                                                                                                rlock();
    941                                                                                         } catch(Exception ex) {
     973                                                                                        } catch (Exception ex) {
    942974                                                                                                break die;
    943975                                                                                        }
     
    945977                                                                                        try {
    946978                                                                                                ip = nickinfo.exists(P_INPORT);
    947                                                                                         } catch(Exception ex) {
     979                                                                                        } catch (Exception ex) {
    948980                                                                                                try {
    949981                                                                                                        runlock();
    950                                                                                                 } catch(Exception ee) {
     982                                                                                                } catch (Exception ee) {
    951983                                                                                                        break die;
    952984                                                                                                }
     
    955987                                                                                        try {
    956988                                                                                                runlock();
    957                                                                                         } catch(Exception ex) {
    958                                                                                                 break die;
    959                                                                                         }
    960 
    961                                                                                         if(ip) {
     989                                                                                        } catch (Exception ex) {
     990                                                                                                break die;
     991                                                                                        }
     992
     993                                                                                        if (ip) {
    962994                                                                                                out.println("OK inbound port set");
    963995                                                                                        } else {
     
    966998
    967999                                                                                }
    968                                                                         } catch(Exception ex) {
     1000                                                                        } catch (Exception ex) {
    9691001                                                                                break die;
    9701002                                                                        }
     
    9741006                                                                }
    9751007
    976                                                         } else if(Command.equals(C_outport)) {
     1008                                                        } else if (Command.equals(C_outport)) {
    9771009                                                                // Set the NamedDB outbound FROM the router port
    9781010                                                                // BOB --> app
    979                                                                 if(ns) {
    980                                                                         try {
    981                                                                                 if(tunnelactive(nickinfo)) {
     1011                                                                if (ns) {
     1012                                                                        try {
     1013                                                                                if (tunnelactive(nickinfo)) {
    9821014                                                                                        out.println("ERROR tunnel is active");
    9831015                                                                                } else {
     
    9851017                                                                                        try {
    9861018                                                                                                wlock();
    987                                                                                         } catch(Exception ex) {
     1019                                                                                        } catch (Exception ex) {
    9881020                                                                                                break die;
    9891021                                                                                        }
     
    9911023                                                                                        try {
    9921024                                                                                                nickinfo.kill(P_OUTPORT);
    993                                                                                         } catch(Exception ex) {
     1025                                                                                        } catch (Exception ex) {
    9941026                                                                                                try {
    9951027                                                                                                        wunlock();
    996                                                                                                 } catch(Exception ee) {
     1028                                                                                                } catch (Exception ee) {
    9971029                                                                                                        break die;
    9981030                                                                                                }
     
    10011033                                                                                        try {
    10021034                                                                                                prt = Integer.parseInt(Arg);
    1003                                                                                                 if(prt > 1 && prt < 65536) {
     1035                                                                                                if (prt > 1 && prt < 65536) {
    10041036                                                                                                        try {
    10051037                                                                                                                nickinfo.add(P_OUTPORT, new Integer(prt));
    1006                                                                                                         } catch(Exception ex) {
     1038                                                                                                        } catch (Exception ex) {
    10071039                                                                                                                try {
    10081040                                                                                                                        wunlock();
    1009                                                                                                                 } catch(Exception ee) {
     1041                                                                                                                } catch (Exception ee) {
    10101042                                                                                                                        break die;
    10111043                                                                                                                }
     
    10141046                                                                                                }
    10151047
    1016                                                                                         } catch(NumberFormatException nfe) {
     1048                                                                                        } catch (NumberFormatException nfe) {
    10171049                                                                                                out.println("ERROR not a number");
    10181050                                                                                        }
     
    10201052                                                                                        try {
    10211053                                                                                                wunlock();
    1022                                                                                         } catch(Exception ex) {
     1054                                                                                        } catch (Exception ex) {
    10231055                                                                                                break die;
    10241056                                                                                        }
    10251057                                                                                        try {
    10261058                                                                                                rlock();
    1027                                                                                         } catch(Exception ex) {
     1059                                                                                        } catch (Exception ex) {
    10281060                                                                                                break die;
    10291061                                                                                        }
     
    10311063                                                                                        try {
    10321064                                                                                                ip = nickinfo.exists(P_OUTPORT);
    1033                                                                                         } catch(Exception ex) {
     1065                                                                                        } catch (Exception ex) {
    10341066                                                                                                try {
    10351067                                                                                                        runlock();
    1036                                                                                                 } catch(Exception ee) {
     1068                                                                                                } catch (Exception ee) {
    10371069                                                                                                        break die;
    10381070                                                                                                }
     
    10411073                                                                                        try {
    10421074                                                                                                runlock();
    1043                                                                                         } catch(Exception ex) {
    1044                                                                                                 break die;
    1045                                                                                         }
    1046 
    1047                                                                                         if(ip) {
     1075                                                                                        } catch (Exception ex) {
     1076                                                                                                break die;
     1077                                                                                        }
     1078
     1079                                                                                        if (ip) {
    10481080                                                                                                out.println("OK outbound port set");
    10491081                                                                                        } else {
     
    10521084
    10531085                                                                                }
    1054                                                                         } catch(Exception ex) {
     1086                                                                        } catch (Exception ex) {
    10551087                                                                                break die;
    10561088                                                                        }
     
    10591091                                                                        try {
    10601092                                                                                nns(out);
    1061                                                                         } catch(Exception ex) {
    1062                                                                                 break die;
    1063                                                                         }
    1064                                                                 }
    1065 
    1066                                                         } else if(Command.equals(C_inhost)) {
    1067                                                                 if(ns) {
    1068                                                                         try {
    1069                                                                                 if(tunnelactive(nickinfo)) {
     1093                                                                        } catch (Exception ex) {
     1094                                                                                break die;
     1095                                                                        }
     1096                                                                }
     1097
     1098                                                        } else if (Command.equals(C_inhost)) {
     1099                                                                if (ns) {
     1100                                                                        try {
     1101                                                                                if (tunnelactive(nickinfo)) {
    10701102                                                                                        out.println("ERROR tunnel is active");
    10711103                                                                                } else {
    10721104                                                                                        try {
    10731105                                                                                                wlock();
    1074                                                                                         } catch(Exception ex) {
     1106                                                                                        } catch (Exception ex) {
    10751107                                                                                                break die;
    10761108                                                                                        }
    10771109                                                                                        try {
    10781110                                                                                                nickinfo.add(P_INHOST, Arg);
    1079                                                                                         } catch(Exception ex) {
     1111                                                                                        } catch (Exception ex) {
    10801112                                                                                                try {
    10811113                                                                                                        wunlock();
    1082                                                                                                 } catch(Exception ee) {
     1114                                                                                                } catch (Exception ee) {
    10831115                                                                                                        break die;
    10841116                                                                                                }
     
    10871119                                                                                        try {
    10881120                                                                                                wunlock();
    1089                                                                                         } catch(Exception ex) {
     1121                                                                                        } catch (Exception ex) {
    10901122                                                                                                break die;
    10911123                                                                                        }
     
    10941126                                                                                }
    10951127
    1096                                                                         } catch(Exception ex) {
     1128                                                                        } catch (Exception ex) {
    10971129                                                                                break die;
    10981130                                                                        }
     
    11011133                                                                        try {
    11021134                                                                                nns(out);
    1103                                                                         } catch(Exception ex) {
    1104                                                                                 break die;
    1105                                                                         }
    1106                                                                 }
    1107 
    1108                                                         } else if(Command.equals(C_outhost)) {
    1109                                                                 if(ns) {
    1110                                                                         try {
    1111                                                                                 if(tunnelactive(nickinfo)) {
     1135                                                                        } catch (Exception ex) {
     1136                                                                                break die;
     1137                                                                        }
     1138                                                                }
     1139
     1140                                                        } else if (Command.equals(C_outhost)) {
     1141                                                                if (ns) {
     1142                                                                        try {
     1143                                                                                if (tunnelactive(nickinfo)) {
    11121144                                                                                        out.println("ERROR tunnel is active");
    11131145                                                                                } else {
    11141146                                                                                        try {
    11151147                                                                                                wlock();
    1116                                                                                         } catch(Exception ex) {
     1148                                                                                        } catch (Exception ex) {
    11171149                                                                                                break die;
    11181150                                                                                        }
    11191151                                                                                        try {
    11201152                                                                                                nickinfo.add(P_OUTHOST, Arg);
    1121                                                                                         } catch(Exception ex) {
     1153                                                                                        } catch (Exception ex) {
    11221154                                                                                                try {
    11231155                                                                                                        wunlock();
    1124                                                                                                 } catch(Exception ee) {
     1156                                                                                                } catch (Exception ee) {
    11251157                                                                                                        break die;
    11261158                                                                                                }
     
    11291161                                                                                        try {
    11301162                                                                                                wunlock();
    1131                                                                                         } catch(Exception ex) {
     1163                                                                                        } catch (Exception ex) {
    11321164                                                                                                break die;
    11331165                                                                                        }
     
    11361168                                                                                }
    11371169
    1138                                                                         } catch(Exception ex) {
     1170                                                                        } catch (Exception ex) {
    11391171                                                                                break die;
    11401172                                                                        }
     
    11431175                                                                        try {
    11441176                                                                                nns(out);
    1145                                                                         } catch(Exception ex) {
    1146                                                                                 break die;
    1147                                                                         }
    1148                                                                 }
    1149 
    1150                                                         } else if(Command.equals(C_show)) {
     1177                                                                        } catch (Exception ex) {
     1178                                                                                break die;
     1179                                                                        }
     1180                                                                }
     1181
     1182                                                        } else if (Command.equals(C_show)) {
    11511183                                                                // Get the current NamedDB properties
    1152                                                                 if(ns) {
     1184                                                                if (ns) {
    11531185                                                                        out.print("OK");
    11541186                                                                        try {
    11551187                                                                                rlock();
    1156                                                                         } catch(Exception e) {
     1188                                                                        } catch (Exception e) {
    11571189                                                                                break die;
    11581190                                                                        }
     
    11601192                                                                        try {
    11611193                                                                                nickprint(out, nickinfo);
    1162                                                                         } catch(Exception e) {
     1194                                                                        } catch (Exception e) {
    11631195                                                                                try {
    11641196                                                                                        runlock();
    1165                                                                                 } catch(Exception ee) {
     1197                                                                                } catch (Exception ee) {
    11661198                                                                                        break die;
    11671199                                                                                }
     
    11731205                                                                        try {
    11741206                                                                                runlock();
    1175                                                                         } catch(Exception e) {
     1207                                                                        } catch (Exception e) {
    11761208                                                                                break die;
    11771209                                                                        }
     
    11801212                                                                        try {
    11811213                                                                                nns(out);
    1182                                                                         } catch(Exception e) {
    1183                                                                                 break die;
    1184                                                                         }
    1185                                                                 }
    1186 
    1187                                                         } else if(Command.equals(C_start)) {
     1214                                                                        } catch (Exception e) {
     1215                                                                                break die;
     1216                                                                        }
     1217                                                                }
     1218
     1219                                                        } else if (Command.equals(C_show_props)) {
     1220                                                                // Get the current options properties
     1221                                                                if (ns) {
     1222                                                                        out.print("OK");
     1223                                                                        try {
     1224                                                                                rlock();
     1225                                                                        } catch (Exception e) {
     1226                                                                                break die;
     1227                                                                        }
     1228
     1229                                                                        try {
     1230                                                                                propprint(out, nickinfo);
     1231                                                                        } catch (Exception e) {
     1232                                                                                try {
     1233                                                                                        runlock();
     1234                                                                                } catch (Exception ee) {
     1235                                                                                        break die;
     1236                                                                                }
     1237
     1238                                                                                out.println(); // this will cause an IOE if IOE
     1239                                                                                break die;
     1240                                                                        }
     1241
     1242                                                                        try {
     1243                                                                                runlock();
     1244                                                                        } catch (Exception e) {
     1245                                                                                break die;
     1246                                                                        }
     1247
     1248                                                                } else {
     1249                                                                        try {
     1250                                                                                nns(out);
     1251                                                                        } catch (Exception e) {
     1252                                                                                break die;
     1253                                                                        }
     1254                                                                }
     1255
     1256                                                        } else if (Command.equals(C_start)) {
    11881257                                                                // Start the tunnel, if we have all the information
    1189                                                                 if(ns && dk && (ip || op)) {
    1190                                                                         try {
    1191                                                                                 if(tunnelactive(nickinfo)) {
     1258                                                                if (ns && dk && (ip || op)) {
     1259                                                                        try {
     1260                                                                                if (tunnelactive(nickinfo)) {
    11921261                                                                                        out.println("ERROR tunnel is active");
    11931262                                                                                } else {
     
    11981267                                                                                                t.start();
    11991268                                                                                                out.println("OK tunnel starting");
    1200                                                                                         } catch(I2PException e) {
     1269                                                                                        } catch (I2PException e) {
    12011270                                                                                                out.println("ERROR starting tunnel: " + e);
    1202                                                                                         } catch(IOException e) {
     1271                                                                                        } catch (IOException e) {
    12031272                                                                                                out.println("ERROR starting tunnel: " + e);
    12041273                                                                                        }
    12051274
    12061275                                                                                }
    1207                                                                         } catch(Exception ex) {
     1276                                                                        } catch (Exception ex) {
    12081277                                                                                break die;
    12091278                                                                        }
     
    12131282                                                                }
    12141283
    1215                                                         } else if(Command.equals(C_stop)) {
     1284                                                        } else if (Command.equals(C_stop)) {
    12161285                                                                // Stop the tunnel, if it is running
    1217                                                                 if(ns) {
     1286                                                                if (ns) {
    12181287                                                                        try {
    12191288                                                                                rlock();
    1220                                                                         } catch(Exception e) {
    1221                                                                                 break die;
    1222                                                                         }
    1223 
    1224                                                                         try {
    1225                                                                                 if(nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
     1289                                                                        } catch (Exception e) {
     1290                                                                                break die;
     1291                                                                        }
     1292
     1293                                                                        try {
     1294                                                                                if (nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
    12261295                                                                                        try {
    12271296                                                                                                runlock();
    1228                                                                                         } catch(Exception e) {
     1297                                                                                        } catch (Exception e) {
    12291298                                                                                                break die;
    12301299                                                                                        }
     
    12321301                                                                                        try {
    12331302                                                                                                wlock();
    1234                                                                                         } catch(Exception e) {
     1303                                                                                        } catch (Exception e) {
    12351304                                                                                                break die;
    12361305                                                                                        }
     
    12401309                                                                                                wunlock();
    12411310
    1242                                                                                         } catch(Exception e) {
     1311                                                                                        } catch (Exception e) {
    12431312                                                                                                break die;
    12441313                                                                                        }
     
    12481317                                                                                        try {
    12491318                                                                                                runlock();
    1250                                                                                         } catch(Exception e) {
     1319                                                                                        } catch (Exception e) {
    12511320                                                                                                break die;
    12521321                                                                                        }
     
    12541323                                                                                        out.println("ERROR tunnel is inactive");
    12551324                                                                                }
    1256                                                                         } catch(Exception e) {
     1325                                                                        } catch (Exception e) {
    12571326                                                                                try {
    12581327                                                                                        runlock();
    1259                                                                                 } catch(Exception ee) {
     1328                                                                                } catch (Exception ee) {
    12601329                                                                                        break die;
    12611330                                                                                }
     
    12661335                                                                        try {
    12671336                                                                                nns(out);
    1268                                                                         } catch(Exception e) {
    1269                                                                                 break die;
    1270                                                                         }
    1271                                                                 }
    1272 
    1273                                                         } else if(Command.equals(C_clear)) {
     1337                                                                        } catch (Exception e) {
     1338                                                                                break die;
     1339                                                                        }
     1340                                                                }
     1341
     1342                                                        } else if (Command.equals(C_clear)) {
    12741343                                                                // Clear use of the NamedDB if stopped
    1275                                                                 if(ns) {
    1276                                                                         try {
    1277                                                                                 if(tunnelactive(nickinfo)) {
     1344                                                                if (ns) {
     1345                                                                        try {
     1346                                                                                if (tunnelactive(nickinfo)) {
    12781347                                                                                        out.println("ERROR tunnel is active");
    12791348                                                                                } else {
    12801349                                                                                        try {
    12811350                                                                                                database.getWriteLock();
    1282                                                                                         } catch(Exception e) {
     1351                                                                                        } catch (Exception e) {
    12831352                                                                                                break die;
    12841353                                                                                        }
    12851354                                                                                        try {
    12861355                                                                                                database.kill(nickinfo.get(P_NICKNAME));
    1287                                                                                         } catch(Exception e) {
     1356                                                                                        } catch (Exception e) {
    12881357                                                                                                try {
    12891358                                                                                                        database.releaseWriteLock();
    1290                                                                                                 } catch(Exception ee) {
     1359                                                                                                } catch (Exception ee) {
    12911360                                                                                                        break die;
    12921361                                                                                                }
     
    12951364                                                                                        try {
    12961365                                                                                                database.releaseWriteLock();
    1297                                                                                         } catch(Exception e) {
     1366                                                                                        } catch (Exception e) {
    12981367                                                                                                break die;
    12991368                                                                                        }
     
    13021371                                                                                }
    13031372
    1304                                                                         } catch(Exception ex) {
     1373                                                                        } catch (Exception ex) {
    13051374                                                                                break die;
    13061375                                                                        }
     
    13091378                                                                        try {
    13101379                                                                                nns(out);
    1311                                                                         } catch(Exception e) {
    1312                                                                                 break die;
    1313                                                                         }
    1314                                                                 }
    1315 
    1316                                                         } else if(Command.equals(C_status)) {
     1380                                                                        } catch (Exception e) {
     1381                                                                                break die;
     1382                                                                        }
     1383                                                                }
     1384
     1385                                                        } else if (Command.equals(C_status)) {
    13171386                                                                try {
    1318                                                                         if(database.exists(Arg)) {
     1387                                                                        if (database.exists(Arg)) {
    13191388                                                                                // Show status of a NamedDB
    13201389                                                                                out.print("OK ");
    13211390                                                                                try {
    13221391                                                                                        ttlpnt(out, Arg);
    1323                                                                                 } catch(Exception e) {
     1392                                                                                } catch (Exception e) {
    13241393                                                                                        out.println(); // this will cause an IOE if IOE
    13251394                                                                                        break die;
     
    13291398                                                                                try {
    13301399                                                                                        nns(out);
    1331                                                                                 } catch(Exception e) {
     1400                                                                                } catch (Exception e) {
    13321401                                                                                        break die;
    13331402                                                                                }
    13341403                                                                        }
    1335                                                                 } catch(Exception e) {
     1404                                                                } catch (Exception e) {
    13361405                                                                        break die;
    13371406                                                                }
     
    13511420
    13521421                        server.close();
    1353                 } catch(IOException ioe) {
     1422                } catch (IOException ioe) {
    13541423                        BOB.warn("IOException on socket listen: " + ioe);
    13551424                        ioe.printStackTrace();
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    rba8de6c r841feae  
    7575                N = this.info.get("NICKNAME").toString();
    7676                prikey = new ByteArrayInputStream((byte[])info.get("KEYS"));
    77                 Properties Q = (Properties)info.get("PROPERTIES");
     77                // Make a new copy so that anything else won't muck with our database.
     78                Properties R = (Properties)info.get("PROPERTIES");
     79                Properties Q = new Properties();
     80                Lifted.copyProperties(R, Q);
    7881                this.database.releaseReadLock();
    7982                this.info.releaseReadLock();
Note: See TracChangeset for help on using the changeset viewer.