core/CoreDBControl.java

   1 /**
   2 #
   3 # BorkNet Services Core
   4 #
   5
   6 #
   7 # Copyright (C) 2004 Ozafy - ozafy@borknet.org - http://www.borknet.org
   8 #
   9 # This program is free software; you can redistribute it and/or
  10 # modify it under the terms of the GNU General Public License
  11 # as published by the Free Software Foundation; either version 2
  12 # of the License, or (at your option) any later version.
  13 #
  14 # This program is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with this program; if not, write to the Free Software
  21 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22 #
  23 */
  24 package borknet_services.core;
  25 import java.sql.*;
  26 import java.util.*;
  27 import java.io.*;
  28 import java.security.*;
  29 import borknet_services.core.*;
  30
  31 public class CoreDBControl
  32 {
  33         private Core C;
  34
  35         private HashMap<String,User> usersByNumeric = new HashMap<String,User>();
  36         private HashMap<String,User> usersByNick = new HashMap<String,User>();
  37         private HashMap<String,ArrayList<User>> usersByAuth = new HashMap<String,ArrayList<User>>();
  38         private HashMap<String,ArrayList<User>> usersByHost = new HashMap<String,ArrayList<User>>();
  39         private HashMap<String,ArrayList<User>> usersByIP = new HashMap<String,ArrayList<User>>();
  40
  41         private HashMap<String,Server> serversByNumeric = new HashMap<String,Server>();
  42         private HashMap<String,ArrayList<Server>> serversByHub = new HashMap<String,ArrayList<Server>>();
  43         private HashMap<String,Server> serversByHost = new HashMap<String,Server>();
  44
  45         private HashMap<String,Channel> channels = new HashMap<String,Channel>();
  46
  47         public CoreDBControl(Core C)
  48         {
  49                 this.C = C;
  50         }
  51
  52         public void cleanDB()
  53         {
  54   usersByNumeric = new HashMap<String,User>();
  55   usersByNick = new HashMap<String,User>();
  56   usersByAuth = new HashMap<String,ArrayList<User>>();
  57   usersByHost = new HashMap<String,ArrayList<User>>();
  58   usersByIP = new HashMap<String,ArrayList<User>>();
  59         }
  60
  61         public boolean chanExists(String chan)
  62         {
  63   Channel c = channels.get(chan.toLowerCase());
  64                 return (c instanceof Channel);
  65         }
  66
  67         public Channel getChannel(String chan)
  68         {
  69                 return channels.get(chan.toLowerCase());
  70         }
  71
  72         public boolean authOnline(String auth)
  73         {
  74                 return usersByAuth.containsKey(auth.toLowerCase());
  75         }
  76
  77         public String getNumViaAuth(String auth)
  78         {
  79                 User u = usersByAuth.get(auth.toLowerCase()).get(0);
  80                 if(u instanceof User)
  81                 {
  82                         return u.getNumeric();
  83                 }
  84                 else
  85                 {
  86                         return "0";
  87                 }
  88         }
  89
  90         public String getNumViaNick(String nick)
  91         {
  92                 User u = usersByNick.get(nick.toLowerCase());
  93                 if(u instanceof User)
  94                 {
  95                         return u.getNumeric();
  96                 }
  97                 else
  98                 {
  99                         return "0";
 100                 }
 101         }
 102
 103         public boolean isService(String numeric)
 104         {
 105                 Server s = serversByNumeric.get(numeric.substring(0,2));
 106                 if(s instanceof Server)
 107                 {
 108                         return s.getService();
 109                 }
 110                 else
 111                 {
 112                         return false;
 113                 }
 114         }
 115
 116         public String getServer(String numeric)
 117         {
 118                 Server s = serversByNumeric.get(numeric.substring(0,2));
 119                 if(s instanceof Server)
 120                 {
 121                         return s.getHost();
 122                 }
 123                 else
 124                 {
 125                         return "unknown";
 126                 }
 127         }
 128
 129         public int getServerCount()
 130         {
 131                 return serversByNumeric.size();
 132         }
 133
 134         public boolean isServerNumeric(String numer)
 135         {
 136                 Server s = serversByNumeric.get(numer);
 137                 if(s instanceof Server)
 138                 {
 139                         return true;
 140                 }
 141                 else
 142                 {
 143                         return false;
 144                 }
 145         }
 146
 147         public boolean isOpChan(String user, String channel)
 148         {
 149                 Channel c = channels.get(channel.toLowerCase());
 150                 if(c instanceof Channel)
 151                 {
 152                         return c.isop(user);
 153                 }
 154                 else
 155                 {
 156                         return false;
 157                 }
 158         }
 159
 160         public boolean isNickUsed(String nick)
 161         {
 162                 return usersByNick.containsKey(nick.toLowerCase());
 163         }
 164
 165         public boolean isOnChan(String user, String channel)
 166         {
 167                 Channel c = channels.get(channel.toLowerCase());
 168                 if(c instanceof Channel)
 169                 {
 170                         return c.ison(user);
 171                 }
 172                 else
 173                 {
 174                         return false;
 175                 }
 176         }
 177
 178         public boolean chanHasOps(String channel)
 179         {
 180                 Channel c = channels.get(channel.toLowerCase());
 181                 if(c instanceof Channel)
 182                 {
 183                         return c.hasop();
 184                 }
 185                 else
 186                 {
 187                         return false;
 188                 }
 189         }
 190
 191         public int getChanUsers(String channel)
 192         {
 193                 Channel c = channels.get(channel.toLowerCase());
 194                 if(c instanceof Channel)
 195                 {
 196                         return c.getUsercount();
 197                 }
 198                 else
 199                 {
 200                         return 0;
 201                 }
 202         }
 203
 204         public int getAuthUsers(String auth)
 205         {
 206                 try
 207                 {
 208                         return usersByAuth.get(auth.toLowerCase()).size();
 209                 }
 210                 catch(Exception e)
 211                 {
 212                         return 0;
 213                 }
 214         }
 215
 216         public int getHostCount(String host)
 217         {
 218                 try
 219                 {
 220                         return usersByHost.get(host.toLowerCase()).size();
 221                 }
 222                 catch(Exception e)
 223                 {
 224                         return 0;
 225                 }
 226         }
 227
 228         public int getIpCount(String ip)
 229         {
 230                 try
 231                 {
 232                         return usersByIP.get(ip).size();
 233                 }
 234                 catch(Exception e)
 235                 {
 236                         return 0;
 237                 }
 238         }
 239
 240         public HashMap<String,User> getUsers()
 241         {
 242                 return usersByNumeric;
 243         }
 244
 245         public User getUserViaAuth(String auth)
 246         {
 247                 return usersByAuth.get(auth.toLowerCase()).get(0);
 248         }
 249
 250         public User getUserViaHost(String host)
 251         {
 252                 return usersByHost.get(host.toLowerCase()).get(0);
 253         }
 254
 255         public User getUserViaNick(String nick)
 256         {
 257                 return usersByNick.get(nick.toLowerCase());
 258         }
 259
 260         public User getUser(String user)
 261         {
 262   return usersByNumeric.get(user);
 263         }
 264
 265         public ArrayList<String> getUserChans(String user)
 266         {
 267   User u = usersByNumeric.get(user);
 268   if(u instanceof User)
 269   {
 270    return u.getChannels();
 271   }
 272   else
 273   {
 274    return new ArrayList<String>();
 275   }
 276         }
 277
 278         public int getChannelCount()
 279         {
 280   return channels.size();
 281         }
 282
 283         public ArrayList<User> getUserRowsViaAuth(String auth)
 284         {
 285                 return usersByAuth.get(auth.toLowerCase());
 286         }
 287
 288         public void setUserField(String numer, int colum, String info)
 289         {
 290                 User u = usersByNumeric.get(numer);
 291                 if(u instanceof User)
 292                 {
 293                         try
 294                         {
 295                                 switch(colum)
 296                                 {
 297                                         case 0:
 298                                                 u.setNumeric(info);
 299                                                 usersByNumeric.remove(numer);
 300                                                 usersByNumeric.put(info,u);
 301                                                 break;
 302                                         case 1:
 303                                                 String oldkey = u.getNick();
 304                                                 u.setNick(info);
 305                                                 if(usersByNick.containsKey(oldkey.toLowerCase()))
 306                                                 {
 307                                                         usersByNick.remove(oldkey.toLowerCase());
 308                                                 }
 309                                                 usersByNick.put(info.toLowerCase(),u);
 310                                                 break;
 311                                         case 2:
 312                                                 String[] splithost = info.split("@");
 313                                                 u.setIdent(splithost[0]);
 314                                                 u.setHost(splithost[1]);
 315                                                 if(usersByHost.containsKey(info.toLowerCase()))
 316                                                 {
 317                                                         ArrayList<User> users = usersByHost.get(info.toLowerCase());
 318                                                         users.add(u);
 319                                                         usersByHost.put(info.toLowerCase(),users);
 320                                                 }
 321                                                 else
 322                                                 {
 323                                                         ArrayList<User> users = new ArrayList<User>();
 324                                                         users.add(u);
 325                                                         usersByHost.put(info.toLowerCase(),users);
 326                                                 }
 327                                                 break;
 328                                         case 3:
 329                                                 u.setModes(info);
 330                                                 break;
 331                                         case 4:
 332                                                 u.setAuth(info);
 333                                                 if(usersByAuth.containsKey(info.toLowerCase()))
 334                                                 {
 335                                                         ArrayList<User> users = usersByAuth.get(info.toLowerCase());
 336                                                         users.add(u);
 337                                                         usersByAuth.put(info.toLowerCase(),users);
 338                                                 }
 339                                                 else
 340                                                 {
 341                                                         ArrayList<User> users = new ArrayList<User>();
 342                                                         users.add(u);
 343                                                         usersByAuth.put(info.toLowerCase(),users);
 344                                                 }
 345                                                 break;
 346                                         case 5:
 347                                                         u.setOperator(Boolean.parseBoolean(info));
 348                                                 break;
 349                                         case 6:
 350                                                 u.setServer(info);
 351                                                 break;
 352                                         case 7:
 353                                                 u.setIp(info);
 354                                                 if(usersByIP.containsKey(info))
 355                                                 {
 356                                                         ArrayList<User> users = usersByIP.get(info);
 357                                                         users.add(u);
 358                                                         usersByIP.put(info.toLowerCase(),users);
 359                                                 }
 360                                                 else
 361                                                 {
 362                                                         ArrayList<User> users = new ArrayList<User>();
 363                                                         users.add(u);
 364                                                         usersByIP.put(info,users);
 365                                                 }
 366                                                 break;
 367                                         case 8:
 368                                                 u.setFakehost(info);
 369                                                 break;
 370                                 }
 371                         }
 372                         catch ( Exception e )
 373                         {
 374                                 System.out.println( "Error finding user." );
 375                                 C.debug(e);
 376                                 C.die("SQL error, trying to die gracefully.");
 377                         }
 378                 }
 379                 else
 380                 {
 381                         System.out.println( "Error finding user." );
 382                         C.printDebug("Error finding user.");
 383                 }
 384         }
 385
 386         public void setUserChanMode(String user, String chan, String mode)
 387         {
 388   Channel c = channels.get(chan.toLowerCase());
 389   if(c instanceof Channel)
 390   {
 391    c.setUserChanMode(user,mode);
 392   }
 393         }
 394
 395         public void delUser(String numer)
 396         {
 397                 try
 398                 {
 399                         User u = usersByNumeric.get(numer);
 400                         usersByNick.remove(u.getNick().toLowerCase());
 401                         ArrayList<User> users = usersByAuth.get(u.getAuth().toLowerCase());
 402                         if(users instanceof ArrayList)
 403                         {
 404                                 users.remove(u);
 405                                 if(users.size()>0)
 406                                 {
 407                                         usersByAuth.put(u.getAuth(),users);
 408                                 }
 409                                 else
 410                                 {
 411                                         usersByAuth.remove(u.getAuth());
 412                                 }
 413                         }
 414                         users = usersByHost.get(u.getHost());
 415                         users.remove(u);
 416                         if(users.size()>0)
 417                         {
 418                                 usersByHost.put(u.getHost(),users);
 419                         }
 420                         else
 421                         {
 422                                 usersByHost.remove(u.getHost());
 423                         }
 424                         users = usersByIP.get(u.getIp());
 425                         users.remove(u);
 426                         if(users.size()>0)
 427                         {
 428                                 usersByIP.put(u.getIp(),users);
 429                         }
 430                         else
 431                         {
 432                                 usersByIP.remove(u.getIp());
 433                         }
 434                         usersByNumeric.remove(numer);
 435                         System.gc();
 436    ArrayList<String> userchannels = u.getChannels();
 437    for(String channel: userchannels)
 438    {
 439     delUserChan(channel, numer);
 440    }
 441                 }
 442                 catch ( Exception e )
 443                 {
 444                 }
 445         }
 446
 447         public void delServer(String host)
 448         {
 449                 Server s = serversByHost.get(host.toLowerCase());
 450                 if(s instanceof Server)
 451                 {
 452    delChildren(host);
 453                         String numer = s.getNumeric();
 454    String hub = s.getHub();
 455    ArrayList<Server> servers = serversByHub.get(hub);
 456                         if(servers instanceof ArrayList)
 457                         {
 458                                 for(int i=0; i<servers.size(); i++)
 459                                 {
 460                                         if(servers.get(i).equals(s))
 461      {
 462       servers.remove(i);
 463       break;
 464      }
 465                                 }
 466                         }
 467                 }
 468                 else
 469                 {
 470                         System.out.println ( "Error Removing server: "+host );
 471                         C.die("SQL error, trying to die gracefully.");
 472                 }
 473         }
 474
 475         public void delChildren(String host)
 476         {
 477                 Server s = serversByHost.get(host.toLowerCase());
 478                 if(s instanceof Server)
 479                 {
 480                         String numer = s.getNumeric();
 481                         ArrayList<Server> servers = serversByHub.get(numer);
 482                         if(servers instanceof ArrayList)
 483                         {
 484     for(Server ser : servers)
 485     {
 486      delChildren(ser.getHost());
 487     }
 488                         }
 489                         ArrayList<String> numerics = new ArrayList<String>(usersByNumeric.keySet());
 490                         for(String n : numerics)
 491                         {
 492                                 if(n.startsWith(numer))
 493                                 {
 494                                         delUser(n);
 495                                 }
 496                         }
 497                         serversByHub.remove(numer);
 498                         serversByNumeric.remove(numer);
 499                         serversByHost.remove(host.toLowerCase());
 500                 }
 501                 else
 502                 {
 503                         System.out.println ( "Error Removing server: "+host );
 504                         C.die("SQL error, trying to die gracefully.");
 505                 }
 506         }
 507
 508         public void delUserChan(String chan, String user)
 509         {
 510   Channel c = channels.get(chan.toLowerCase());
 511   if(c instanceof Channel)
 512   {
 513    c.delUser(user);
 514   }
 515   if(c.getUsercount()<=0)
 516   {
 517    channels.remove(chan.toLowerCase());
 518   }
 519   User u = usersByNumeric.get(user);
 520   if(u instanceof User)
 521   {
 522    u.partChannel(chan);
 523   }
 524         }
 525
 526         public void addUser(String nume,String nick, String host, String mode, String auth, boolean isop, String server, String ip, String fake)
 527         {
 528                 try
 529                 {
 530                         User u = new User(nume);
 531                         u.setNick(nick);
 532                         String[] splithost = host.split("@");
 533                         u.setIdent(splithost[0]);
 534                         u.setHost(splithost[1]);
 535                         u.setModes(mode);
 536                         u.setAuth(auth);
 537                         u.setOperator(isop);
 538                         u.setServer(server);
 539                         u.setIp(ip);
 540                         u.setFakehost(fake);
 541                         usersByNumeric.put(nume,u);
 542                         usersByNick.put(nick.toLowerCase(),u);
 543                         if(!auth.equals("0"))
 544                         {
 545                                 if(usersByAuth.containsKey(auth.toLowerCase()))
 546                                 {
 547                                         ArrayList<User> users = usersByAuth.get(auth.toLowerCase());
 548                                         users.add(u);
 549                                         usersByAuth.put(auth.toLowerCase(),users);
 550                                 }
 551                                 else
 552                                 {
 553                                         ArrayList<User> users = new ArrayList<User>();
 554                                         users.add(u);
 555                                         usersByAuth.put(auth.toLowerCase(),users);
 556                                 }
 557                         }
 558                         if(usersByHost.containsKey(splithost[1]))
 559                         {
 560                                 ArrayList<User> users = usersByHost.get(splithost[1]);
 561                                 users.add(u);
 562                                 usersByHost.put(splithost[1],users);
 563                         }
 564                         else
 565                         {
 566                                 ArrayList<User> users = new ArrayList<User>();
 567                                 users.add(u);
 568                                 usersByHost.put(splithost[1],users);
 569                         }
 570                         if(usersByIP.containsKey(ip))
 571                         {
 572                                 ArrayList<User> users = usersByIP.get(ip);
 573                                 users.add(u);
 574                                 usersByIP.put(ip,users);
 575                         }
 576                         else
 577                         {
 578                                 ArrayList<User> users = new ArrayList<User>();
 579                                 users.add(u);
 580                                 usersByIP.put(ip,users);
 581                         }
 582                 }
 583                 catch ( Exception e )
 584                 {
 585                         System.out.println ( "Error executing statement" );
 586                         C.debug(e);
 587                         C.die("SQL error, trying to die gracefully.");
 588                 }
 589         }
 590
 591         public void addServer(String numer, String host ,String hub, boolean service)
 592         {
 593                 try
 594                 {
 595                         Server s = new Server(numer);
 596                         s.setHost(host.toLowerCase());
 597                         s.setHub(hub);
 598                         s.setService(service);
 599                         serversByHost.put(host.toLowerCase(),s);
 600                         serversByNumeric.put(numer,s);
 601                         if(serversByHub.containsKey(hub))
 602                         {
 603                                 ArrayList<Server> servers = serversByHub.get(hub);
 604                                 servers.add(s);
 605                                 serversByHub.put(hub,servers);
 606                         }
 607                         else
 608                         {
 609                                 ArrayList<Server> servers = new ArrayList<Server>();
 610                                 servers.add(s);
 611                                 serversByHub.put(hub,servers);
 612                         }
 613                 }
 614                 catch (Exception e)
 615                 {
 616                         System.out.println ( "Error executing statement" );
 617                         C.debug(e);
 618                         C.die("SQL error, trying to die gracefully.");
 619                 }
 620         }
 621
 622         public void addUserChan(String channel,String user,String timestamp, Boolean isop, Boolean isvoice)
 623         {
 624   Channel c = channels.get(channel.toLowerCase());
 625   if(c instanceof Channel)
 626   {
 627    c.addUser(user,isop,isvoice);
 628   }
 629   else
 630   {
 631    c = new Channel(channel,timestamp,user,isop,isvoice);
 632    channels.put(channel.toLowerCase(),c);
 633   }
 634   User u = usersByNumeric.get(user);
 635   if(u instanceof User)
 636   {
 637    u.joinChannel(channel);
 638   }
 639         }
 640 }