Changeset 27724a80


Ignore:
Timestamp:
Dec 3, 2016 11:10:53 PM (4 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
7734d3d
Parents:
1d6fc40
Message:

BOB:

  • Change NamedDB implementation to HashMap?
  • Change NamedDB locks to ReentrantReadWriteLock?
  • All unlocks in finally blocks, remove redundant unlocking
  • Remove throw declaration from methods that don't
  • Read under write lock when that's simpler
  • Use Boolean fields rather than valueOf()
  • Fix unlock order inversion in I2PtoTCP and MUXlisten
  • Remove unused locking in TCPtoI2P
  • Add missing locking in status command
  • Remove redundant locking
  • Remove unnecessary catch-and-rethrows
  • Spelling fix in error message
  • Set some methods static
  • Blank line removal
Location:
apps/BOB/src/net/i2p/BOB
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • apps/BOB/src/net/i2p/BOB/BOB.java

    r1d6fc40 r27724a80  
    365365                        visitAllThreads();
    366366                        database.getReadLock();
    367                         int all = database.getcount();
    368                         database.releaseReadLock();
    369367                        NamedDB nickinfo;
    370                         for (i = 0; i < all; i++) {
    371                                 database.getReadLock();
    372                                 nickinfo = (NamedDB) database.getnext(i);
    373                                 nickinfo.getReadLock();
    374                                 if (nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
    375                                         nickinfo.releaseReadLock();
    376                                         database.releaseReadLock();
    377                                         database.getWriteLock();
    378                                         nickinfo.getWriteLock();
    379                                         nickinfo.add(P_STOPPING, Boolean.valueOf(true));
    380                                         nickinfo.releaseWriteLock();
    381                                         database.releaseWriteLock();
    382                                 } else {
    383                                         nickinfo.releaseReadLock();
    384                                         database.releaseReadLock();
     368                        try {
     369                                for (Object ndb : database.values()) {
     370                                        nickinfo = (NamedDB) ndb;
     371                                        nickinfo.getReadLock();
     372                                        boolean released = false;
     373                                        try {
     374                                                if (nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
     375                                                        nickinfo.releaseReadLock();
     376                                                        released = true;
     377                                                        nickinfo.getWriteLock();
     378                                                        try {
     379                                                                nickinfo.add(P_STOPPING, Boolean.TRUE);
     380                                                        } finally {
     381                                                                nickinfo.releaseWriteLock();
     382                                                        }
     383                                                }
     384                                        } finally {
     385                                                if (!released)
     386                                                        nickinfo.releaseReadLock();
     387                                        }
    385388                                }
     389                        } finally {
     390                                database.releaseReadLock();
    386391                        }
    387392                        changeState(STOPPED);
  • apps/BOB/src/net/i2p/BOB/DoCMDS.java

    r1d6fc40 r27724a80  
    175175        }
    176176
    177         private void rlock() throws Exception {
     177        private void rlock() {
    178178                rlock(nickinfo);
    179179        }
    180180
    181         private void rlock(NamedDB Arg) throws Exception {
     181        private void rlock(NamedDB Arg) {
    182182                database.getReadLock();
    183183                Arg.getReadLock();
    184184        }
    185185
    186         private void runlock() throws Exception {
     186        private void runlock() {
    187187                runlock(nickinfo);
    188188        }
    189189
    190         private void runlock(NamedDB Arg) throws Exception {
     190        private void runlock(NamedDB Arg) {
    191191                Arg.releaseReadLock();
    192192                database.releaseReadLock();
    193193        }
    194194
    195         private void wlock() throws Exception {
     195        private void wlock() {
    196196                wlock(nickinfo);
    197197        }
    198198
    199         private void wlock(NamedDB Arg) throws Exception {
     199        private void wlock(NamedDB Arg) {
    200200                database.getWriteLock();
    201201                Arg.getWriteLock();
    202202        }
    203203
    204         private void wunlock() throws Exception {
     204        private void wunlock() {
    205205                wunlock(nickinfo);
    206206        }
    207207
    208         private void wunlock(NamedDB Arg) throws Exception {
     208        private void wunlock(NamedDB Arg) {
    209209                Arg.releaseWriteLock();
    210210                database.releaseWriteLock();
     
    217217         * @param info
    218218         * @param key
    219          * @throws Exception
    220          */
    221         private void trypnt(PrintStream out, NamedDB info, Object key) throws Exception {
    222                 try {
    223                         rlock(info);
    224                 } catch (Exception e) {
    225                         throw new Exception(e);
    226                 }
     219         */
     220        private void trypnt(PrintStream out, NamedDB info, String key) {
     221                rlock(info);
    227222                try {
    228223                        out.print(" " + key + ": ");
     
    232227                                out.print("not_set");
    233228                        }
    234                 } catch (Exception e) {
     229                } finally {
    235230                        runlock(info);
    236                         throw new Exception(e);
    237231                }
    238                 runlock(info);
    239232        }
    240233
     
    245238         * @param info
    246239         * @param key
    247          * @throws Exception
    248          */
    249         private void tfpnt(PrintStream out, NamedDB info, Object key) throws Exception {
    250                 try {
    251                         rlock(info);
    252                 } catch (Exception e) {
    253                         throw new Exception(e);
    254                 }
     240         */
     241        private void tfpnt(PrintStream out, NamedDB info, String key) {
     242                rlock(info);
    255243                try {
    256244                        out.print(" " + key + ": ");
    257245                        out.print(info.exists(key));
    258                 } catch (Exception e) {
     246                } finally {
    259247                        runlock(info);
    260                         throw new Exception(e);
    261248                }
    262                 runlock(info);
    263249        }
    264250
     
    268254         * @param out
    269255         */
    270         private void nns(PrintStream out) throws IOException {
     256        private static void nns(PrintStream out) {
    271257                out.println("ERROR no nickname has been set");
    272258        }
     
    277263         * @param out
    278264         * @param info
    279          * @throws Exception
    280          */
    281         private void nickprint(PrintStream out, NamedDB info) throws Exception {
    282                 try {
    283                         rlock(info);
    284                 } catch (Exception e) {
    285                         throw new Exception(e);
    286                 }
    287                 try {
    288 
    289                         trypnt(out, info, P_NICKNAME);
    290                         trypnt(out, info, P_STARTING);
    291                         trypnt(out, info, P_RUNNING);
    292                         trypnt(out, info, P_STOPPING);
    293                         tfpnt(out, info, P_KEYS);
    294                         trypnt(out, info, P_QUIET);
    295                         trypnt(out, info, P_INPORT);
    296                         trypnt(out, info, P_INHOST);
    297                         trypnt(out, info, P_OUTPORT);
    298                         trypnt(out, info, P_OUTHOST);
    299                         out.println();
    300                 } catch (Exception e) {
    301                         runlock(info);
    302                         throw new Exception(e);
    303                 }
    304 
    305                 runlock(info);
     265         */
     266        private void nickprint(PrintStream out, NamedDB info) {
     267                trypnt(out, info, P_NICKNAME);
     268                trypnt(out, info, P_STARTING);
     269                trypnt(out, info, P_RUNNING);
     270                trypnt(out, info, P_STOPPING);
     271                tfpnt(out, info, P_KEYS);
     272                trypnt(out, info, P_QUIET);
     273                trypnt(out, info, P_INPORT);
     274                trypnt(out, info, P_INHOST);
     275                trypnt(out, info, P_OUTPORT);
     276                trypnt(out, info, P_OUTHOST);
     277                out.println();
    306278        }
    307279
     
    311283         * @param out
    312284         * @param info
    313          * @throws Exception
    314          */
    315         private void propprint(PrintStream out, NamedDB info) throws Exception {
    316                 try {
    317                         rlock(info);
    318                 } catch (Exception e) {
    319                         throw new Exception(e);
    320                 }
    321                 try {
    322 
    323                         trypnt(out, info, P_PROPERTIES);
    324                         out.println();
    325                 } catch (Exception e) {
    326                         runlock(info);
    327                         throw new Exception(e);
    328                 }
    329 
    330                 runlock(info);
     285         */
     286        private void propprint(PrintStream out, NamedDB info) {
     287                trypnt(out, info, P_PROPERTIES);
    331288        }
    332289
     
    335292         * @param out
    336293         * @param Arg
    337          * @throws Exception
    338          */
    339         private void ttlpnt(PrintStream out, Object Arg) throws Exception {
    340                 try {
    341                         database.getReadLock();
    342                 } catch (Exception e) {
    343                         throw new Exception(e);
    344                 }
    345 
     294         */
     295        private void ttlpnt(PrintStream out, String Arg) {
     296                database.getReadLock();
    346297                try {
    347298                        if (database.exists(Arg)) {
     
    349300                                nickprint(out, (NamedDB) database.get(Arg));
    350301                        }
    351                 } catch (Exception e) {
     302                } finally {
    352303                        database.releaseReadLock();
    353                         throw new Exception(e);
    354304                }
    355 
    356 
    357                 database.releaseReadLock();
    358305        }
    359306
     
    364311         * @return true if the tunnel is active
    365312         */
    366         private boolean tunnelactive(NamedDB Arg) throws Exception {
     313        private boolean tunnelactive(NamedDB Arg) {
    367314                boolean retval;
    368                 try {
    369                         rlock(Arg);
    370                 } catch (Exception e) {
    371                         throw new Exception(e);
    372                 }
    373 
     315                rlock(Arg);
    374316                try {
    375317                        retval = (Arg.get(P_STARTING).equals(Boolean.TRUE) ||
    376318                                Arg.get(P_STOPPING).equals(Boolean.TRUE) ||
    377319                                Arg.get(P_RUNNING).equals(Boolean.TRUE));
    378                 } catch (Exception e) {
     320                } finally {
    379321                        runlock();
    380                         throw new Exception(e);
    381322                }
    382 
    383                 runlock(Arg);
    384323                return retval;
    385324        }
     
    391330         * @return OK
    392331         */
    393         private boolean is64ok(String data) {
     332        private static boolean is64ok(String data) {
    394333                try {
    395334                        new Destination(data);
     
    441380                                                                                        out.println("OK " + C_ALL[i][1]);
    442381                                                                                }
    443 
    444382                                                                        }
    445383                                                                } else if (Command.equals(C_visit)) {
     
    471409                                                                        if (ns) {
    472410                                                                                if (dk) {
    473                                                                                         try {
    474                                                                                                 rlock();
    475                                                                                         } catch (Exception ex) {
    476                                                                                                 break die;
    477                                                                                         }
    478 
     411                                                                                        rlock();
    479412                                                                                        try {
    480413                                                                                                out.println("OK " + nickinfo.get(P_DEST));
    481414                                                                                        } catch (Exception e) {
    482                                                                                                 try {
    483                                                                                                         runlock();
    484                                                                                                 } catch (Exception ex) {
    485                                                                                                         break die;
    486                                                                                                 }
    487415                                                                                                break die;
    488                                                                                         }
    489 
    490                                                                                         try {
     416                                                                                        } finally {
    491417                                                                                                runlock();
    492                                                                                         } catch (Exception ex) {
    493                                                                                                 break die;
    494                                                                                         }
    495 
     418                                                                                        }
    496419                                                                                } else {
    497420                                                                                        out.println("ERROR keys not set.");
    498421                                                                                }
    499 
    500422                                                                        } else {
    501423                                                                                nns(out);
     
    505427                                                                        // Produce a formatted list of all nicknames
    506428                                                                        database.getReadLock();
    507                                                                         for (int i = 0; i <
    508                                                                                 database.getcount(); i++) {
    509                                                                                 try {
    510                                                                                         info = (NamedDB) database.getnext(i);
    511                                                                                         out.print("DATA");
    512                                                                                 } catch (Exception e) {
    513                                                                                         database.releaseReadLock();
    514                                                                                         break die;
    515                                                                                 }
    516 
    517                                                                                 try {
    518                                                                                         info.getReadLock();
    519                                                                                 } catch (Exception ex) {
    520                                                                                         break die;
    521                                                                                 }
    522                                                                                 try {
     429                                                                        try {
     430                                                                                for (Object ndb : database.values()) {
     431                                                                                        try {
     432                                                                                                info = (NamedDB) ndb;
     433                                                                                                out.print("DATA");
     434                                                                                        } catch (Exception e) {
     435                                                                                                break die;
     436                                                                                        }
    523437                                                                                        nickprint(out, info);
    524                                                                                 } catch (Exception e) {
    525                                                                                         try {
    526                                                                                                 info.releaseReadLock();
    527                                                                                                 database.releaseReadLock();
    528                                                                                         } catch (Exception ex) {
    529                                                                                                 break die;
    530                                                                                         }
    531                                                                                         break die;
    532                                                                                 }
    533 
    534                                                                                 try {
    535                                                                                         info.releaseReadLock();
    536                                                                                 } catch (Exception ex) {
    537                                                                                         break die;
    538                                                                                 }
    539                                                                         }
    540 
    541                                                                         try {
     438                                                                                }
     439                                                                        } finally {
    542440                                                                                database.releaseReadLock();
    543                                                                         } catch (Exception ex) {
    544                                                                                 break die;
    545441                                                                        }
    546442                                                                        out.println("OK Listing done");
     
    563459                                                                                                        prikey = new ByteArrayOutputStream();
    564460                                                                                                        d = I2PClientFactory.createClient().createDestination(prikey);
    565                                                                                                         try {
    566                                                                                                                 wlock();
    567                                                                                                         } catch (Exception e) {
    568                                                                                                                 break die;
    569                                                                                                         }
    570 
     461                                                                                                        wlock();
    571462                                                                                                        try {
    572463                                                                                                                nickinfo.add(P_KEYS, prikey.toByteArray());
    573464                                                                                                                nickinfo.add(P_DEST, d.toBase64());
    574                                                                                                         } catch (Exception e) {
    575                                                                                                                 try {
    576                                                                                                                         wunlock();
    577                                                                                                                 } catch (Exception ex) {
    578                                                                                                                         break die;
    579                                                                                                                 }
    580                                                                                                                 break die;
    581                                                                                                         }
    582 
    583                                                                                                         dk = true;
    584                                                                                                         try {
    585                                                                                                                 wunlock();
    586                                                                                                         } catch (Exception ex) {
    587                                                                                                                 break die;
    588                                                                                                         }
    589 
    590                                                                                                         try {
    591                                                                                                                 rlock();
    592                                                                                                         } catch (Exception ex) {
    593                                                                                                                 break die;
    594                                                                                                         }
    595 
    596                                                                                                         try {
    597465                                                                                                                out.println("OK " + nickinfo.get(P_DEST));
    598466                                                                                                        } catch (Exception e) {
    599                                                                                                                 runlock();
    600467                                                                                                                break die;
     468                                                                                                        } finally {
     469                                                                                                                wunlock();
    601470                                                                                                        }
    602 
    603                                                                                                         try {
    604                                                                                                                 runlock();
    605                                                                                                         } catch (Exception ex) {
    606                                                                                                                 break die;
    607                                                                                                         }
     471                                                                                                        dk = true;
    608472                                                                                                } catch (I2PException ipe) {
    609473                                                                                                        _log.error("Error generating keys", ipe);
    610474                                                                                                        out.println("ERROR generating keys");
    611475                                                                                                }
    612 
    613476                                                                                        }
    614477                                                                                } catch (Exception e) {
    615478                                                                                        break die;
    616479                                                                                }
    617 
    618                                                                         } else {
    619                                                                                 try {
    620                                                                                         nns(out);
    621                                                                                 } catch (Exception ex) {
    622                                                                                         break die;
    623                                                                                 }
     480                                                                        } else {
     481                                                                                nns(out);
    624482                                                                        }
    625483
     
    628486                                                                        if (dk) {
    629487                                                                                prikey = new ByteArrayOutputStream();
    630                                                                                 try {
    631                                                                                         rlock();
    632                                                                                 } catch (Exception e) {
    633                                                                                         break die;
    634                                                                                 }
     488                                                                                rlock();
    635489                                                                                try {
    636490                                                                                        prikey.write(((byte[]) nickinfo.get(P_KEYS)));
    637491                                                                                } catch (Exception ex) {
    638                                                                                         try {
    639                                                                                                 runlock();
    640                                                                                         } catch (Exception ee) {
    641                                                                                                 break die;
    642                                                                                         }
    643                                                                                         break die;
    644                                                                                 }
    645                                                                                 try {
     492                                                                                        break die;
     493                                                                                } finally {
    646494                                                                                        runlock();
    647                                                                                 } catch (Exception e) {
    648                                                                                         break die;
    649                                                                                 }
    650 
     495                                                                                }
    651496                                                                                out.println("OK " + net.i2p.data.Base64.encode(prikey.toByteArray()));
    652497                                                                        } else {
     
    660505                                                                                                out.println("ERROR tunnel is active");
    661506                                                                                        } else {
    662                                                                                                 try {
    663                                                                                                         wlock();
    664                                                                                                 } catch (Exception ex) {
    665                                                                                                         break die;
    666                                                                                                 }
     507                                                                                                wlock();
    667508                                                                                                try {
    668509                                                                                                        nickinfo.add(P_QUIET, Boolean.valueOf(Arg));
    669510                                                                                                } catch (Exception ex) {
    670                                                                                                         try {
    671                                                                                                                 wunlock();
    672                                                                                                         } catch (Exception ee) {
    673                                                                                                                 break die;
    674                                                                                                         }
    675511                                                                                                        break die;
    676                                                                                                 }
    677 
    678                                                                                                 try {
     512                                                                                                } finally {
    679513                                                                                                        wunlock();
    680                                                                                                 } catch (Exception ex) {
    681                                                                                                         break die;
    682                                                                                                 }
    683 
     514                                                                                                }
    684515                                                                                                out.println("OK Quiet set");
    685516                                                                                        }
    686 
    687                                                                                 } catch (Exception ex) {
    688                                                                                         break die;
    689                                                                                 }
    690 
    691                                                                         } else {
    692                                                                                 try {
    693                                                                                         nns(out);
    694                                                                                 } catch (Exception ex) {
    695                                                                                         break die;
    696                                                                                 }
     517                                                                                } catch (Exception ex) {
     518                                                                                        break die;
     519                                                                                }
     520                                                                        } else {
     521                                                                                nns(out);
    697522                                                                        }
    698523
     
    720545
    721546                                                                                                if ((Arg.length() == 884) && is64ok(Arg)) {
    722                                                                                                         try {
    723                                                                                                                 wlock();
    724                                                                                                         } catch (Exception ex) {
    725                                                                                                                 break die;
    726                                                                                                         }
     547                                                                                                        wlock();
    727548                                                                                                        try {
    728549                                                                                                                nickinfo.add(P_KEYS, prikey.toByteArray());
    729550                                                                                                                nickinfo.add(P_DEST, d.toBase64());
     551                                                                                                                out.println("OK " + nickinfo.get(P_DEST));
    730552                                                                                                        } catch (Exception ex) {
    731                                                                                                                 try {
    732                                                                                                                         wunlock();
    733                                                                                                                 } catch (Exception ee) {
    734                                                                                                                         break die;
    735                                                                                                                 }
    736553                                                                                                                break die;
     554                                                                                                        } finally {
     555                                                                                                                wunlock();
    737556                                                                                                        }
    738557                                                                                                        dk = true;
    739                                                                                                         try {
    740                                                                                                                 wunlock();
    741                                                                                                         } catch (Exception ex) {
    742                                                                                                                 break die;
    743                                                                                                         }
    744 
    745                                                                                                         try {
    746                                                                                                                 rlock();
    747                                                                                                         } catch (Exception ex) {
    748                                                                                                                 break die;
    749                                                                                                         }
    750 
    751                                                                                                         try {
    752                                                                                                                 out.println("OK " + nickinfo.get(P_DEST));
    753                                                                                                         } catch (Exception e) {
    754                                                                                                                 try {
    755                                                                                                                         runlock();
    756                                                                                                                 } catch (Exception ex) {
    757                                                                                                                         break die;
    758                                                                                                                 }
    759                                                                                                                 break die;
    760                                                                                                         }
    761 
    762                                                                                                         try {
    763                                                                                                                 runlock();
    764                                                                                                         } catch (Exception ex) {
    765                                                                                                                 break die;
    766                                                                                                         }
    767558                                                                                                } else {
    768559                                                                                                        out.println("ERROR not in BASE64 format");
    769560                                                                                                }
    770 
    771                                                                                         }
    772                                                                                 } catch (Exception ex) {
    773                                                                                         break die;
    774                                                                                 }
    775 
    776                                                                         } else {
    777                                                                                 try {
    778                                                                                         nns(out);
    779                                                                                 } catch (Exception ex) {
    780                                                                                         break die;
    781                                                                                 }
     561                                                                                        }
     562                                                                                } catch (Exception ex) {
     563                                                                                        break die;
     564                                                                                }
     565                                                                        } else {
     566                                                                                nns(out);
    782567                                                                        }
    783568
    784569                                                                } else if (Command.equals(C_setnick)) {
    785570                                                                        ns = dk = ip = op = false;
    786                                                                         try {
    787                                                                                 database.getReadLock();
    788                                                                         } catch (Exception ex) {
    789                                                                                 break die;
    790                                                                         }
     571                                                                        database.getReadLock();
    791572                                                                        try {
    792573                                                                                nickinfo = (NamedDB) database.get(Arg);
     
    799580                                                                                nickinfo = null;
    800581                                                                                ns = true;
    801                                                                         }
    802 
    803                                                                         try {
     582                                                                        } finally {
    804583                                                                                database.releaseReadLock();
    805                                                                         } catch (Exception ex) {
    806                                                                                 break die;
    807584                                                                        }
    808585                                                                        // Clears and Sets the initial NamedDB structure to work with
    809586                                                                        if (ns) {
    810587                                                                                nickinfo = new NamedDB();
    811                                                                                 try {
    812                                                                                         wlock();
    813                                                                                 } catch (Exception e) {
    814                                                                                         break die;
    815                                                                                 }
    816 
     588                                                                                wlock();
    817589                                                                                try {
    818590                                                                                        database.add(Arg, nickinfo);
    819591                                                                                        nickinfo.add(P_NICKNAME, Arg);
    820                                                                                         nickinfo.add(P_STARTING, Boolean.valueOf(false));
    821                                                                                         nickinfo.add(P_RUNNING, Boolean.valueOf(false));
    822                                                                                         nickinfo.add(P_STOPPING, Boolean.valueOf(false));
    823                                                                                         nickinfo.add(P_QUIET, Boolean.valueOf(false));
     592                                                                                        nickinfo.add(P_STARTING, Boolean.FALSE);
     593                                                                                        nickinfo.add(P_RUNNING, Boolean.FALSE);
     594                                                                                        nickinfo.add(P_STOPPING, Boolean.FALSE);
     595                                                                                        nickinfo.add(P_QUIET, Boolean.FALSE);
    824596                                                                                        nickinfo.add(P_INHOST, "localhost");
    825597                                                                                        nickinfo.add(P_OUTHOST, "localhost");
     
    830602                                                                                        nickinfo.add(P_PROPERTIES, Q);
    831603                                                                                } catch (Exception e) {
    832                                                                                         try {
    833                                                                                                 wunlock();
    834                                                                                                 break die;
    835                                                                                         } catch (Exception ee) {
    836                                                                                                 break die;
    837                                                                                         }
    838 
    839                                                                                 }
    840                                                                                 try {
     604                                                                                        break die;
     605                                                                                } finally {
    841606                                                                                        wunlock();
    842                                                                                 } catch (Exception e) {
    843                                                                                         break die;
    844                                                                                 }
    845 
     607                                                                                }
    846608                                                                                out.println("OK Nickname set to " + Arg);
    847609                                                                        } else {
     
    857619                                                                                                StringTokenizer otoken = new StringTokenizer(Arg, "="); // use an equal sign as a delimiter
    858620                                                                                                if (otoken.countTokens() != 2) {
    859                                                                                                         out.println("ERROR to many or no options.");
     621                                                                                                        out.println("ERROR too many or no options.");
    860622                                                                                                } else {
    861623                                                                                                        String pname = otoken.nextToken();
    862624                                                                                                        String pval = otoken.nextToken();
     625                                                                                                        wlock();
    863626                                                                                                        try {
    864                                                                                                                 rlock();
     627                                                                                                                Properties Q = (Properties) nickinfo.get(P_PROPERTIES);
     628                                                                                                                Q.setProperty(pname, pval);
     629                                                                                                                nickinfo.add(P_PROPERTIES, Q);
    865630                                                                                                        } catch (Exception ex) {
    866631                                                                                                                break die;
     632                                                                                                        } finally {
     633                                                                                                                wunlock();
    867634                                                                                                        }
    868 
    869                                                                                                         Properties Q = (Properties) nickinfo.get(P_PROPERTIES);
    870                                                                                                         try {
    871                                                                                                                 runlock();
    872                                                                                                         } catch (Exception ex) {
    873                                                                                                                 break die;
    874                                                                                                         }
    875 
    876                                                                                                         Q.setProperty(pname, pval);
    877                                                                                                         try {
    878                                                                                                                 wlock();
    879                                                                                                         } catch (Exception ex) {
    880                                                                                                                 break die;
    881                                                                                                         }
    882 
    883                                                                                                         try {
    884                                                                                                                 nickinfo.add(P_PROPERTIES, Q);
    885                                                                                                         } catch (Exception ex) {
    886                                                                                                                 try {
    887                                                                                                                         wunlock();
    888                                                                                                                 } catch (Exception ee) {
    889                                                                                                                         break die;
    890                                                                                                                 }
    891                                                                                                                 break die;
    892                                                                                                         }
    893                                                                                                         try {
    894                                                                                                                 wunlock();
    895                                                                                                         } catch (Exception ex) {
    896                                                                                                                 break die;
    897                                                                                                         }
    898 
    899635                                                                                                        out.println("OK " + pname + " set to " + pval);
    900636                                                                                                }
    901 
    902                                                                                         }
    903                                                                                 } catch (Exception ex) {
    904                                                                                         break die;
    905                                                                                 }
    906 
     637                                                                                        }
     638                                                                                } catch (Exception ex) {
     639                                                                                        break die;
     640                                                                                }
    907641                                                                        } else {
    908642                                                                                nns(out);
     
    912646                                                                        // Get the NamedDB to work with...
    913647                                                                        boolean nsfail = false;
    914 
    915                                                                         try {
    916                                                                                 database.getReadLock();
    917                                                                         } catch (Exception ex) {
    918                                                                                 break die;
    919                                                                         }
     648                                                                        database.getReadLock();
    920649                                                                        try {
    921650                                                                                nickinfo = (NamedDB) database.get(Arg);
    922651                                                                                ns = true;
    923652                                                                        } catch (RuntimeException b) {
    924                                                                                 try {
    925                                                                                         nsfail = true;
    926                                                                                         nns(out);
    927                                                                                 } catch (Exception ex) {
    928                                                                                         try {
    929                                                                                                 database.releaseReadLock();
    930                                                                                         } catch (Exception ee) {
    931                                                                                                 break die;
    932                                                                                         }
    933                                                                                         break die;
    934                                                                                 }
    935                                                                         }
    936 
    937                                                                         database.releaseReadLock();
     653                                                                                nsfail = true;
     654                                                                                nns(out);
     655                                                                        } finally {
     656                                                                                database.releaseReadLock();
     657                                                                        }
    938658                                                                        if (ns && !nsfail) {
    939                                                                                 try {
    940                                                                                         rlock();
    941                                                                                 } catch (Exception e) {
    942                                                                                         break die;
    943                                                                                 }
     659                                                                                rlock();
    944660                                                                                try {
    945661                                                                                        dk = nickinfo.exists(P_KEYS);
     
    947663                                                                                        op = nickinfo.exists(P_OUTPORT);
    948664                                                                                } catch (Exception ex) {
    949                                                                                         try {
    950                                                                                                 runlock();
    951                                                                                         } catch (Exception ee) {
    952                                                                                                 break die;
    953                                                                                         }
    954                                                                                         break die;
    955                                                                                 }
    956                                                                                 try {
     665                                                                                        break die;
     666                                                                                } finally {
    957667                                                                                        runlock();
    958                                                                                 } catch (Exception e) {
    959                                                                                         break die;
    960668                                                                                }
    961669                                                                                // Finally say OK.
     
    972680                                                                                        } else {
    973681                                                                                                int prt;
    974                                                                                                 try {
    975                                                                                                         wlock();
    976                                                                                                 } catch (Exception ex) {
    977                                                                                                         break die;
    978                                                                                                 }
    979 
     682                                                                                                wlock();
    980683                                                                                                try {
    981684                                                                                                        nickinfo.kill(P_INPORT);
    982                                                                                                 } catch (Exception ex) {
    983                                                                                                         try {
    984                                                                                                                 wunlock();
    985                                                                                                         } catch (Exception ee) {
    986                                                                                                                 break die;
    987                                                                                                         }
    988 
    989                                                                                                         break die;
    990                                                                                                 }
    991                                                                                                 try {
    992685                                                                                                        prt = Integer.parseInt(Arg);
    993686                                                                                                        if (prt > 1 && prt < 65536) {
     
    995688                                                                                                                        nickinfo.add(P_INPORT, Integer.valueOf(prt));
    996689                                                                                                                } catch (Exception ex) {
    997                                                                                                                         try {
    998                                                                                                                                 wunlock();
    999                                                                                                                         } catch (Exception ee) {
    1000                                                                                                                                 break die;
    1001                                                                                                                         }
    1002 
    1003690                                                                                                                        break die;
    1004691                                                                                                                }
    1005692                                                                                                        }
    1006 
     693                                                                                                        ip = nickinfo.exists(P_INPORT);
    1007694                                                                                                } catch (NumberFormatException nfe) {
    1008695                                                                                                        out.println("ERROR not a number");
    1009                                                                                                 }
    1010 
    1011                                                                                                 try {
     696                                                                                                } finally {
    1012697                                                                                                        wunlock();
    1013                                                                                                 } catch (Exception ex) {
    1014                                                                                                         break die;
    1015                                                                                                 }
    1016                                                                                                 try {
    1017                                                                                                         rlock();
    1018                                                                                                 } catch (Exception ex) {
    1019                                                                                                         break die;
    1020                                                                                                 }
    1021 
    1022                                                                                                 try {
    1023                                                                                                         ip = nickinfo.exists(P_INPORT);
    1024                                                                                                 } catch (Exception ex) {
    1025                                                                                                         try {
    1026                                                                                                                 runlock();
    1027                                                                                                         } catch (Exception ee) {
    1028                                                                                                                 break die;
    1029                                                                                                         }
    1030                                                                                                         break die;
    1031                                                                                                 }
    1032                                                                                                 try {
    1033                                                                                                         runlock();
    1034                                                                                                 } catch (Exception ex) {
    1035                                                                                                         break die;
    1036                                                                                                 }
    1037 
     698                                                                                                }
    1038699                                                                                                if (ip) {
    1039700                                                                                                        out.println("OK inbound port set");
     
    1041702                                                                                                        out.println("ERROR port out of range");
    1042703                                                                                                }
    1043 
    1044                                                                                         }
    1045                                                                                 } catch (Exception ex) {
    1046                                                                                         break die;
    1047                                                                                 }
    1048 
     704                                                                                        }
     705                                                                                } catch (Exception ex) {
     706                                                                                        break die;
     707                                                                                }
    1049708                                                                        } else {
    1050709                                                                                nns(out);
     
    1060719                                                                                        } else {
    1061720                                                                                                int prt;
     721                                                                                                wlock();
    1062722                                                                                                try {
    1063                                                                                                         wlock();
     723                                                                                                        nickinfo.kill(P_OUTPORT);
     724                                                                                                        prt = Integer.parseInt(Arg);
     725                                                                                                        if (prt > 1 && prt < 65536) {
     726                                                                                                                nickinfo.add(P_OUTPORT, Integer.valueOf(prt));
     727                                                                                                        }
     728                                                                                                        ip = nickinfo.exists(P_OUTPORT);
     729                                                                                                } catch (NumberFormatException nfe) {
     730                                                                                                        out.println("ERROR not a number");
    1064731                                                                                                } catch (Exception ex) {
    1065732                                                                                                        break die;
    1066                                                                                                 }
    1067 
    1068                                                                                                 try {
    1069                                                                                                         nickinfo.kill(P_OUTPORT);
    1070                                                                                                 } catch (Exception ex) {
    1071                                                                                                         try {
    1072                                                                                                                 wunlock();
    1073                                                                                                         } catch (Exception ee) {
    1074                                                                                                                 break die;
    1075                                                                                                         }
    1076                                                                                                         break die;
    1077                                                                                                 }
    1078                                                                                                 try {
    1079                                                                                                         prt = Integer.parseInt(Arg);
    1080                                                                                                         if (prt > 1 && prt < 65536) {
    1081                                                                                                                 try {
    1082                                                                                                                         nickinfo.add(P_OUTPORT, Integer.valueOf(prt));
    1083                                                                                                                 } catch (Exception ex) {
    1084                                                                                                                         try {
    1085                                                                                                                                 wunlock();
    1086                                                                                                                         } catch (Exception ee) {
    1087                                                                                                                                 break die;
    1088                                                                                                                         }
    1089                                                                                                                         break die;
    1090                                                                                                                 }
    1091                                                                                                         }
    1092 
    1093                                                                                                 } catch (NumberFormatException nfe) {
    1094                                                                                                         out.println("ERROR not a number");
    1095                                                                                                 }
    1096 
    1097                                                                                                 try {
     733                                                                                                } finally {
    1098734                                                                                                        wunlock();
    1099                                                                                                 } catch (Exception ex) {
    1100                                                                                                         break die;
    1101                                                                                                 }
    1102                                                                                                 try {
    1103                                                                                                         rlock();
    1104                                                                                                 } catch (Exception ex) {
    1105                                                                                                         break die;
    1106                                                                                                 }
    1107 
    1108                                                                                                 try {
    1109                                                                                                         ip = nickinfo.exists(P_OUTPORT);
    1110                                                                                                 } catch (Exception ex) {
    1111                                                                                                         try {
    1112                                                                                                                 runlock();
    1113                                                                                                         } catch (Exception ee) {
    1114                                                                                                                 break die;
    1115                                                                                                         }
    1116                                                                                                         break die;
    1117                                                                                                 }
    1118                                                                                                 try {
    1119                                                                                                         runlock();
    1120                                                                                                 } catch (Exception ex) {
    1121                                                                                                         break die;
    1122                                                                                                 }
    1123 
     735                                                                                                }
    1124736                                                                                                if (ip) {
    1125737                                                                                                        out.println("OK outbound port set");
     
    1127739                                                                                                        out.println("ERROR port out of range");
    1128740                                                                                                }
    1129 
    1130                                                                                         }
    1131                                                                                 } catch (Exception ex) {
    1132                                                                                         break die;
    1133                                                                                 }
    1134 
    1135                                                                         } else {
    1136                                                                                 try {
    1137                                                                                         nns(out);
    1138                                                                                 } catch (Exception ex) {
    1139                                                                                         break die;
    1140                                                                                 }
     741                                                                                        }
     742                                                                                } catch (Exception ex) {
     743                                                                                        break die;
     744                                                                                }
     745                                                                        } else {
     746                                                                                nns(out);
    1141747                                                                        }
    1142748
     
    1147753                                                                                                out.println("ERROR tunnel is active");
    1148754                                                                                        } else {
    1149                                                                                                 try {
    1150                                                                                                         wlock();
    1151                                                                                                 } catch (Exception ex) {
    1152                                                                                                         break die;
    1153                                                                                                 }
     755                                                                                                wlock();
    1154756                                                                                                try {
    1155757                                                                                                        nickinfo.add(P_INHOST, Arg);
    1156758                                                                                                } catch (Exception ex) {
    1157                                                                                                         try {
    1158                                                                                                                 wunlock();
    1159                                                                                                         } catch (Exception ee) {
    1160                                                                                                                 break die;
    1161                                                                                                         }
    1162759                                                                                                        break die;
    1163                                                                                                 }
    1164                                                                                                 try {
     760                                                                                                } finally {
    1165761                                                                                                        wunlock();
    1166                                                                                                 } catch (Exception ex) {
    1167                                                                                                         break die;
    1168                                                                                                 }
    1169 
     762                                                                                                }
    1170763                                                                                                out.println("OK inhost set");
    1171764                                                                                        }
    1172 
    1173                                                                                 } catch (Exception ex) {
    1174                                                                                         break die;
    1175                                                                                 }
    1176 
    1177                                                                         } else {
    1178                                                                                 try {
    1179                                                                                         nns(out);
    1180                                                                                 } catch (Exception ex) {
    1181                                                                                         break die;
    1182                                                                                 }
     765                                                                                } catch (Exception ex) {
     766                                                                                        break die;
     767                                                                                }
     768                                                                        } else {
     769                                                                                nns(out);
    1183770                                                                        }
    1184771
     
    1189776                                                                                                out.println("ERROR tunnel is active");
    1190777                                                                                        } else {
    1191                                                                                                 try {
    1192                                                                                                         wlock();
    1193                                                                                                 } catch (Exception ex) {
    1194                                                                                                         break die;
    1195                                                                                                 }
     778                                                                                                wlock();
    1196779                                                                                                try {
    1197780                                                                                                        nickinfo.add(P_OUTHOST, Arg);
    1198781                                                                                                } catch (Exception ex) {
    1199                                                                                                         try {
    1200                                                                                                                 wunlock();
    1201                                                                                                         } catch (Exception ee) {
    1202                                                                                                                 break die;
    1203                                                                                                         }
    1204782                                                                                                        break die;
    1205                                                                                                 }
    1206                                                                                                 try {
     783                                                                                                } finally {
    1207784                                                                                                        wunlock();
    1208                                                                                                 } catch (Exception ex) {
    1209                                                                                                         break die;
    1210                                                                                                 }
    1211 
     785                                                                                                }
    1212786                                                                                                out.println("OK outhost set");
    1213787                                                                                        }
    1214 
    1215                                                                                 } catch (Exception ex) {
    1216                                                                                         break die;
    1217                                                                                 }
    1218 
    1219                                                                         } else {
    1220                                                                                 try {
    1221                                                                                         nns(out);
    1222                                                                                 } catch (Exception ex) {
    1223                                                                                         break die;
    1224                                                                                 }
     788                                                                                } catch (Exception ex) {
     789                                                                                        break die;
     790                                                                                }
     791                                                                        } else {
     792                                                                                nns(out);
    1225793                                                                        }
    1226794
     
    1229797                                                                        if (ns) {
    1230798                                                                                out.print("OK");
    1231                                                                                 try {
    1232                                                                                         rlock();
    1233                                                                                 } catch (Exception e) {
    1234                                                                                         break die;
    1235                                                                                 }
    1236 
    1237                                                                                 try {
    1238                                                                                         nickprint(out, nickinfo);
    1239                                                                                 } catch (Exception e) {
    1240                                                                                         try {
    1241                                                                                                 runlock();
    1242                                                                                         } catch (Exception ee) {
    1243                                                                                                 break die;
    1244                                                                                         }
    1245 
    1246                                                                                         out.println(); // this will cause an IOE if IOE
    1247                                                                                         break die;
    1248                                                                                 }
    1249 
    1250                                                                                 try {
    1251                                                                                         runlock();
    1252                                                                                 } catch (Exception e) {
    1253                                                                                         break die;
    1254                                                                                 }
    1255 
    1256                                                                         } else {
    1257                                                                                 try {
    1258                                                                                         nns(out);
    1259                                                                                 } catch (Exception e) {
    1260                                                                                         break die;
    1261                                                                                 }
     799                                                                                nickprint(out, nickinfo);
     800                                                                        } else {
     801                                                                                nns(out);
    1262802                                                                        }
    1263803
     
    1266806                                                                        if (ns) {
    1267807                                                                                out.print("OK");
    1268                                                                                 try {
    1269                                                                                         rlock();
    1270                                                                                 } catch (Exception e) {
    1271                                                                                         break die;
    1272                                                                                 }
    1273 
    1274                                                                                 try {
    1275                                                                                         propprint(out, nickinfo);
    1276                                                                                 } catch (Exception e) {
    1277                                                                                         try {
    1278                                                                                                 runlock();
    1279                                                                                         } catch (Exception ee) {
    1280                                                                                                 break die;
    1281                                                                                         }
    1282 
    1283                                                                                         out.println(); // this will cause an IOE if IOE
    1284                                                                                         break die;
    1285                                                                                 }
    1286 
    1287                                                                                 try {
    1288                                                                                         runlock();
    1289                                                                                 } catch (Exception e) {
    1290                                                                                         break die;
    1291                                                                                 }
    1292 
    1293                                                                         } else {
    1294                                                                                 try {
    1295                                                                                         nns(out);
    1296                                                                                 } catch (Exception e) {
    1297                                                                                         break die;
    1298                                                                                 }
     808                                                                                propprint(out, nickinfo);
     809                                                                        } else {
     810                                                                                nns(out);
    1299811                                                                        }
    1300812
     
    1339851                                                                        // Stop the tunnel, if it is running
    1340852                                                                        if (ns) {
    1341                                                                                 try {
    1342                                                                                         rlock();
    1343                                                                                 } catch (Exception e) {
    1344                                                                                         break die;
    1345                                                                                 }
    1346 
     853                                                                                rlock();
     854                                                                                boolean released = false;
    1347855                                                                                try {
    1348856                                                                                        if (nickinfo.get(P_RUNNING).equals(Boolean.TRUE) && nickinfo.get(P_STOPPING).equals(Boolean.FALSE) && nickinfo.get(P_STARTING).equals(Boolean.FALSE)) {
     857                                                                                                runlock();
     858                                                                                                released = true;
     859                                                                                                wlock();
    1349860                                                                                                try {
    1350                                                                                                         runlock();
     861                                                                                                        nickinfo.add(P_STOPPING, Boolean.TRUE);
    1351862                                                                                                } catch (Exception e) {
    1352863                                                                                                        break die;
    1353                                                                                                 }
    1354 
    1355                                                                                                 try {
    1356                                                                                                         wlock();
    1357                                                                                                 } catch (Exception e) {
    1358                                                                                                         break die;
    1359                                                                                                 }
    1360 
    1361                                                                                                 nickinfo.add(P_STOPPING, Boolean.valueOf(true));
    1362                                                                                                 try {
     864                                                                                                } finally {
    1363865                                                                                                        wunlock();
    1364 
    1365                                                                                                 } catch (Exception e) {
    1366                                                                                                         break die;
    1367                                                                                                 }
    1368 
     866                                                                                                }
    1369867                                                                                                out.println("OK tunnel stopping");
    1370868                                                                                        } else {
    1371                                                                                                 try {
    1372                                                                                                         runlock();
    1373                                                                                                 } catch (Exception e) {
    1374                                                                                                         break die;
    1375                                                                                                 }
    1376 
    1377869                                                                                                out.println("ERROR tunnel is inactive");
    1378870                                                                                        }
    1379871                                                                                } catch (Exception e) {
    1380                                                                                         try {
     872                                                                                        break die;
     873                                                                                } finally {
     874                                                                                        if (!released)
    1381875                                                                                                runlock();
    1382                                                                                         } catch (Exception ee) {
    1383                                                                                                 break die;
    1384                                                                                         }
    1385                                                                                         break die;
    1386                                                                                 }
    1387 
    1388                                                                         } else {
    1389                                                                                 try {
    1390                                                                                         nns(out);
    1391                                                                                 } catch (Exception e) {
    1392                                                                                         break die;
    1393                                                                                 }
     876                                                                                }
     877                                                                        } else {
     878                                                                                nns(out);
    1394879                                                                        }
    1395880
     
    1401886                                                                                                out.println("ERROR tunnel is active");
    1402887                                                                                        } else {
     888                                                                                                database.getWriteLock();
    1403889                                                                                                try {
    1404                                                                                                         database.getWriteLock();
     890                                                                                                        database.kill((String) nickinfo.get(P_NICKNAME));
    1405891                                                                                                } catch (Exception e) {
    1406                                                                                                         break die;
    1407                                                                                                 }
    1408                                                                                                 try {
    1409                                                                                                         database.kill(nickinfo.get(P_NICKNAME));
    1410                                                                                                 } catch (Exception e) {
    1411                                                                                                         try {
    1412                                                                                                                 database.releaseWriteLock();
    1413                                                                                                         } catch (Exception ee) {
    1414                                                                                                                 break die;
    1415                                                                                                         }
    1416                                                                                                         break die;
    1417                                                                                                 }
    1418                                                                                                 try {
     892                                                                                                } finally {
    1419893                                                                                                        database.releaseWriteLock();
    1420                                                                                                 } catch (Exception e) {
    1421                                                                                                         break die;
    1422894                                                                                                }
    1423895                                                                                                dk = ns = ip = op = false;
     
    1428900                                                                                        break die;
    1429901                                                                                }
    1430 
    1431                                                                         } else {
    1432                                                                                 try {
    1433                                                                                         nns(out);
    1434                                                                                 } catch (Exception e) {
    1435                                                                                         break die;
    1436                                                                                 }
     902                                                                        } else {
     903                                                                                nns(out);
    1437904                                                                        }
    1438905
    1439906                                                                } else if (Command.equals(C_status)) {
     907                                                                        database.getReadLock();
    1440908                                                                        try {
    1441909                                                                                if (database.exists(Arg)) {
     
    1448916                                                                                                break die;
    1449917                                                                                        }
    1450 
    1451918                                                                                } else {
    1452                                                                                         try {
    1453                                                                                                 nns(out);
    1454                                                                                         } catch (Exception e) {
    1455                                                                                                 break die;
    1456                                                                                         }
     919                                                                                        nns(out);
    1457920                                                                                }
    1458921                                                                        } catch (Exception e) {
    1459922                                                                                break die;
    1460                                                                         }
    1461 
     923                                                                        } finally {
     924                                                                                database.releaseReadLock();
     925                                                                        }
    1462926                                                                } else {
    1463927                                                                        out.println("ERROR UNKNOWN COMMAND! Try help");
  • apps/BOB/src/net/i2p/BOB/I2PtoTCP.java

    r1d6fc40 r27724a80  
    5757
    5858        private void runlock() {
     59                info.releaseReadLock();
    5960                database.releaseReadLock();
    60                 info.releaseReadLock();
    6161        }
    6262
     
    7979                        {
    8080                                try {
    81                                         try {
    82                                                 rlock();
    83                                         } catch (Exception e) {
    84                                                 break die;
    85                                         }
     81                                        rlock();
    8682                                        try {
    8783                                                host = info.get("OUTHOST").toString();
     
    8985                                                tell = info.get("QUIET").equals(Boolean.FALSE);
    9086                                        } catch (Exception e) {
     87                                                break die;
     88                                        } finally {
    9189                                                runlock();
    92                                                 break die;
    93                                         }
    94                                         try {
    95                                                 runlock();
    96                                         } catch (Exception e) {
    97                                                 break die;
    9890                                        }
    9991                                        sock = new Socket(host, port);
  • apps/BOB/src/net/i2p/BOB/MUXlisten.java

    r1d6fc40 r27724a80  
    7171                lives = new AtomicBoolean(false);
    7272                try {
    73                         this.database.getWriteLock();
    74                         this.info.getWriteLock();
    75                         this.info.add("STARTING", Boolean.valueOf(true));
    76                         this.info.releaseWriteLock();
    77                         this.database.releaseWriteLock();
    78                         this.database.getReadLock();
    79                         this.info.getReadLock();
    80 
    81                         N = this.info.get("NICKNAME").toString();
    82                         prikey = new ByteArrayInputStream((byte[]) info.get("KEYS"));
    83                         // Make a new copy so that anything else won't muck with our database.
    84                         Properties R = (Properties) info.get("PROPERTIES");
     73                        wlock();
     74                        try {
     75                                this.info.add("STARTING", Boolean.TRUE);
     76                        } finally {
     77                                wunlock();
     78                        }
    8579                        Properties Q = new Properties();
    86                         Lifted.copyProperties(R, Q);
    87                         this.database.releaseReadLock();
    88                         this.info.releaseReadLock();
    89 
    90                         this.database.getReadLock();
    91                         this.info.getReadLock();
    92                         this.go_out = info.exists("OUTPORT");
    93                         this.come_in = info.exists("INPORT");
    94                         if (this.come_in) {
    95                                 port = Integer.parseInt(info.get("INPORT").toString());
    96                                 host = InetAddress.getByName(info.get("INHOST").toString());
    97                         }
    98                         this.database.releaseReadLock();
    99                         this.info.releaseReadLock();
     80                        rlock();
     81                        try {
     82                                N = this.info.get("NICKNAME").toString();
     83                                prikey = new ByteArrayInputStream((byte[]) info.get("KEYS"));
     84                                // Make a new copy so that anything else won't muck with our database.
     85                                Properties R = (Properties) info.get("PROPERTIES");
     86                                Lifted.copyProperties(R, Q);
     87
     88                                this.go_out = info.exists("OUTPORT");
     89                                this.come_in = info.exists("INPORT");
     90                                if (this.come_in) {
     91                                        port = Integer.parseInt(info.get("INPORT").toString());
     92                                        host = InetAddress.getByName(info.get("INHOST").toString());
     93                                }
     94                        } finally {
     95                                runlock();
     96                        }
    10097
    10198                        String i2cpHost = Q.getProperty(I2PClient.PROP_TCP_HOST, "127.0.0.1");
     
    115112                } catch (IOException e) {
    116113                        // Something went bad.
    117                         this.database.getWriteLock();
    118                         this.info.getWriteLock();
    119                         this.info.add("STARTING", Boolean.valueOf(false));
    120                         this.info.releaseWriteLock();
    121                         this.database.releaseWriteLock();
    122                         throw new IOException(e.toString());
     114                        wlock();
     115                        try {
     116                                this.info.add("STARTING", Boolean.FALSE);
     117                        } finally {
     118                                wunlock();
     119                        }
     120                        throw e;
    123121                } catch (RuntimeException e) {
    124122                        // Something went bad.
    125                         this.database.getWriteLock();
    126                         this.info.getWriteLock();
    127                         this.info.add("STARTING", Boolean.valueOf(false));
    128                         this.info.releaseWriteLock();
    129                         this.database.releaseWriteLock();
    130                         throw new RuntimeException(e);
     123                        wlock();
     124                        try {
     125                                this.info.add("STARTING", Boolean.FALSE);
     126                        } finally {
     127                                wunlock();
     128                        }
     129                        throw e;
    131130                } catch (Exception e) {
    132131                        // Something else went bad.
    133                         this.database.getWriteLock();
    134                         this.info.getWriteLock();
    135                         this.info.add("STARTING", Boolean.valueOf(false));
    136                         this.info.releaseWriteLock();
    137                         this.database.releaseWriteLock();
     132                        wlock();
     133                        try {
     134                                this.info.add("STARTING", Boolean.FALSE);
     135                        } finally {
     136                                wunlock();
     137                        }
    138138                        e.printStackTrace();
    139139                        throw new RuntimeException(e);
     
    141141        }
    142142
    143         private void rlock() throws Exception {
     143        private void rlock() {
    144144                database.getReadLock();
    145145                info.getReadLock();
    146146        }
    147147
    148         private void runlock() throws Exception {
     148        private void runlock() {
     149                info.releaseReadLock();
    149150                database.releaseReadLock();
    150                 info.releaseReadLock();
    151         }
    152 
    153         private void wlock() throws Exception {
     151        }
     152
     153        private void wlock() {
    154154                database.getWriteLock();
    155155                info.getWriteLock();
    156156        }
    157157
    158         private void wunlock() throws Exception {
     158        private void wunlock() {
    159159                info.releaseWriteLock();
    160160                database.releaseWriteLock();
     
    170170                Thread q = null;
    171171                try {
    172                         try {
    173                                 wlock();
    174                                 try {
    175                                         info.add("RUNNING", Boolean.valueOf(true));
     172                        wlock();
     173                        try {
     174                                try {
     175                                        info.add("RUNNING", Boolean.TRUE);
    176176                                } catch (Exception e) {
    177177                                        lock.set(false);
    178                                         wunlock();
    179178                                        return;
    180179                                }
     
    182181                                lock.set(false);
    183182                                return;
    184                         }
    185                         try {
    186                                 wunlock();
    187                         } catch (Exception e) {
    188                                 lock.set(false);
    189                                 return;
     183                        } finally {
     184                                wunlock();
    190185                        }
    191186                        lives.set(true);
     
    214209                                                }
    215210
     211                                                wlock();
    216212                                                try {
    217                                                         wlock();
    218213                                                        try {
    219                                                                 info.add("STARTING", Boolean.valueOf(false));
     214                                                                info.add("STARTING", Boolean.FALSE);
    220215                                                        } catch (Exception e) {
    221                                                                 wunlock();
    222216                                                                break quit;
    223217                                                        }
    224218                                                } catch (Exception e) {
    225219                                                        break quit;
    226                                                 }
    227                                                 try {
     220                                                } finally {
    228221                                                        wunlock();
    229                                                 } catch (Exception e) {
    230                                                         break quit;
    231222                                                }
    232223                                                boolean spin = true;
     
    237228                                                                break quit;
    238229                                                        }
     230                                                        rlock();
    239231                                                        try {
    240                                                                 rlock();
    241232                                                                try {
    242233                                                                        spin = info.get("STOPPING").equals(Boolean.FALSE);
    243234                                                                } catch (Exception e) {
    244                                                                         runlock();
    245235                                                                        break quit;
    246236                                                                }
    247237                                                        } catch (Exception e) {
    248238                                                                break quit;
    249                                                         }
    250                                                         try {
     239                                                        } finally {
    251240                                                                runlock();
    252                                                         } catch (Exception e) {
    253                                                                 break quit;
    254241                                                        }
    255242                                                }
     
    271258                                wlock();
    272259                                try {
    273                                         info.add("STARTING", Boolean.valueOf(false));
    274                                         info.add("STOPPING", Boolean.valueOf(true));
    275                                         info.add("RUNNING", Boolean.valueOf(false));
     260                                        info.add("STARTING", Boolean.FALSE);
     261                                        info.add("STOPPING", Boolean.TRUE);
     262                                        info.add("RUNNING", Boolean.FALSE);
    276263                                } catch (Exception e) {
    277264                                        lock.set(false);
    278                                         wunlock();
    279265                                        return;
    280266                                }
    281                                 wunlock();
    282267                        } catch (Exception e) {
     268                        } finally {
     269                                wunlock();
    283270                        }
    284271                        // Start cleanup.
     
    322309                                wlock();
    323310                                try {
    324                                         info.add("STARTING", Boolean.valueOf(false));
    325                                         info.add("STOPPING", Boolean.valueOf(false));
    326                                         info.add("RUNNING", Boolean.valueOf(false));
     311                                        info.add("STARTING", Boolean.FALSE);
     312                                        info.add("STOPPING", Boolean.FALSE);
     313                                        info.add("RUNNING", Boolean.FALSE);
    327314                                } catch (Exception e) {
    328315                                        lock.set(false);
     316                                        return;
     317                                } finally {
    329318                                        wunlock();
    330                                         return;
    331                                 }
    332                                 wunlock();
     319                                }       
    333320                        } catch (Exception e) {
    334321                        }
  • apps/BOB/src/net/i2p/BOB/NamedDB.java

    r1d6fc40 r27724a80  
    1616package net.i2p.BOB;
    1717
     18import java.util.Collection;
     19import java.util.HashMap;
     20import java.util.Map;
     21import java.util.concurrent.locks.ReentrantReadWriteLock;
     22
     23
    1824/**
    1925 * Internal database to relate nicknames to options to values
     
    2329public class NamedDB {
    2430
    25         private volatile Object[][] data;
    26         private int index,  writersWaiting,  readers;
     31        private final Map<String, Object> data;
     32        private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);
    2733
    2834        /**
    29          * make initial NULL object
    3035         *
    3136         */
    3237        public NamedDB() {
    33                 this.data = new Object[1][2];
     38                this.data = new HashMap<String, Object>();
    3439        }
    3540
    36         synchronized public void getReadLock() {
    37                 while ((writersWaiting != 0)) {
    38                         try {
    39                                 wait();
    40                         } catch (InterruptedException ie) {
    41                         }
    42                 }
    43                 readers++;
     41        public void getReadLock() {
     42                lock.readLock().lock();
    4443        }
    4544
    46         synchronized public void releaseReadLock() {
    47                 readers--;
    48                 notifyAll();
     45        public void releaseReadLock() {
     46                lock.readLock().unlock();
    4947        }
    5048
    51         synchronized public void getWriteLock() {
    52                 writersWaiting++;
    53                 while (readers != 0 && writersWaiting != 1) {
    54                         try {
    55                                 wait();
    56                         } catch (InterruptedException ie) {
    57                         }
    58                 }
     49        public void getWriteLock() {
     50                lock.writeLock().lock();
    5951        }
    6052
    61         synchronized public void releaseWriteLock() {
    62                 writersWaiting--;
    63                 notifyAll();
     53        public void releaseWriteLock() {
     54                lock.writeLock().unlock();
    6455        }
    6556
    6657        /**
    67          * Find objects in the array, returns its index or throws exception
     58         * Delete an object if it exists
     59         *
    6860         * @param key
    69          * @return an objects index
    70          * @throws ArrayIndexOutOfBoundsException when key does not exist
    7161         */
    72         public int idx(Object key) throws ArrayIndexOutOfBoundsException {
    73                 for (int i = 0; i < index; i++) {
    74                         if (key.equals(data[i][0])) {
    75                                 return i;
    76                         }
    77                 }
    78                 throw new ArrayIndexOutOfBoundsException("Can't locate key for index");
     62        public void kill(String key) {
     63                data.remove(key);
    7964        }
    8065
    8166        /**
    82          * Delete an object from array if it exists
    83          *
    84          * @param key
    85          */
    86         public void kill(Object key) {
    87 
    88                 int i, j, k, l;
    89                 Object[][] olddata;
    90                 int didsomething = 0;
    91 
    92                 try {
    93                         k = idx(key);
    94                 } catch (ArrayIndexOutOfBoundsException b) {
    95                         return;
    96                 }
    97                 olddata = new Object[index + 2][2];
    98                 // copy to olddata, skipping 'k'
    99                 for (i = 0, l = 0; l < index; i++, l++) {
    100                         if (i == k) {
    101                                 l++;
    102                                 didsomething++;
    103                         }
    104                         for (j = 0; j < 2; j++) {
    105                                 olddata[i][j] = data[l][j];
    106                         }
    107                 }
    108                 index -= didsomething;
    109                 data = olddata;
    110         }
    111 
    112         /**
    113          * Add object to the array, deletes the old one if it exists
     67         * Add object, deletes the old one if it exists
    11468         *
    11569         * @param key
    11670         * @param val
    11771         */
    118         public void add(Object key, Object val) {
    119                 Object[][] olddata;
    120                 int i, j;
    121                 i = 0;
    122                 kill(key);
    123 
    124                 olddata = new Object[index + 2][2];
    125                 // copy to olddata
    126                 for (i = 0; i < index; i++) {
    127                         for (j = 0; j < 2; j++) {
    128                                 olddata[i][j] = data[i][j];
    129                         }
    130                 }
    131                 data = olddata;
    132                 data[index++] = new Object[]{key, val};
     72        public void add(String key, Object val) {
     73                data.put(key, val);
    13374        }
    13475
    13576        /**
    136          * Get the object, and return it, throws RuntimeException
     77         * Get the object, and return it, throws RuntimeException if not found
    13778         *
    138          * @param key
    139          * @return Object
    140          * @throws java.lang.RuntimeException
     79         * @param key non-null
     80         * @return Object non-null
     81         * @throws java.lang.RuntimeException if not found
    14182         */
    142         public Object get(Object key) throws RuntimeException {
    143                 for (int i = 0; i < index; i++) {
    144                         if (key.equals(data[i][0])) {
    145                                 return data[i][1];
    146                         }
    147                 }
     83        public Object get(String key) throws RuntimeException {
     84                Object rv = data.get(key);
     85                if (rv != null)
     86                        return rv;
    14887                throw new RuntimeException("Key not found");
    14988        }
     
    15594         * @return true if an object exists, else returns false
    15695         */
    157         public boolean exists(Object key) {
    158                 for (int i = 0; i < index; i++) {
    159                         if (key.equals(data[i][0])) {
    160                                 return true;
    161                         }
    162                 }
    163                 return false;
    164 
     96        public boolean exists(String key) {
     97                return data.containsKey(key);
    16598        }
    16699
    167100        /**
    168          *
    169          * @param i index
    170          * @return an indexed Object
    171          * @throws java.lang.RuntimeException
     101         * @since 0.9.29 replaces getcount() and getnext(int)
    172102         */
    173         public Object getnext(int i) throws RuntimeException {
    174                 if (i < index && i > -1) {
    175                         return data[i][1];
    176                 }
    177                 throw new RuntimeException("No more data");
    178         }
    179 
    180         /**
    181          * @return the count of how many objects
    182          */
    183         public int getcount() {
    184                 return index;
     103        public Collection<Object> values() {
     104                return data.values();
    185105        }
    186106}
  • apps/BOB/src/net/i2p/BOB/TCPtoI2P.java

    r1d6fc40 r27724a80  
    4343
    4444        private I2PSocket I2P;
    45         private final NamedDB info, database;
    4645        private final Socket sock;
    4746        private final I2PSocketManager socketManager;
     
    5251         * @param i2p
    5352         * @param socket
    54          * param info
    55          * param database
     53         * @param info unused
     54         * @param database unused
    5655         */
    5756        TCPtoI2P(I2PSocketManager i2p, Socket socket, NamedDB info, NamedDB database, AtomicBoolean lives) {
    5857                this.sock = socket;
    59                 this.info = info;
    60                 this.database = database;
    6158                this.socketManager = i2p;
    6259                this.lives = lives;
     
    105102                out.write(10);
    106103                out.flush();
    107         }
    108 
    109         private void rlock() {
    110                 database.getReadLock();
    111                 info.getReadLock();
    112         }
    113 
    114         private void runlock() {
    115                 info.releaseReadLock();
    116                 database.releaseReadLock();
    117104        }
    118105
Note: See TracChangeset for help on using the changeset viewer.