1 package net.ercatec.hw2ircsvr;

     2 

     3 import net.ercatec.hw.INetClient;

     4 import net.ercatec.hw.ProtocolConnection;

     5 

     6 import java.io.BufferedReader;

     7 import java.io.InputStream;

     8 import java.io.InputStreamReader;

     9 import java.io.OutputStream;

    10 import java.net.InetSocketAddress;

    11 import java.net.ServerSocket;

    12 import java.net.Socket;

    13 import java.util.ArrayList;

    14 import java.util.Arrays;

    15 import java.util.HashMap;

    16 import java.util.Hashtable;

    17 import java.util.List;

    18 import java.util.Map;

    19 import java.util.Queue;

    20 import java.util.concurrent.LinkedBlockingQueue;

    21 import java.util.Collections;

    22 import java.util.Vector;

    23 

    24 import java.util.regex.Pattern;

    25 import java.util.regex.PatternSyntaxException;

    26 

    27 import java.lang.IllegalArgumentException;

    28 

    29 // for auth files

    30 import java.util.Properties;

    31 import java.io.FileInputStream;

    32 import java.io.IOException;

    33 

    34 /* TODO

    35  * disconnect clients that are not irc clients

    36  * disconnect excess flooders

    37  * recognizes stuff after : as single arg

    38  * collect pre-irc-join messages and show on join

    39  * allow negating regexps

    40  * ban

    41  * banlist

    42  * commandquery // wth did I mean by that?

    43  * more room info

    44  * filter rooms

    45  * warnings

    46  * global notice

    47  */

    48 

    49 /**

    50  * @author sheepluva

    51  * 

    52  * based on jircs by Alexander Boyd

    53  */

    54 public class Connection implements INetClient, Runnable

    55 {

    56     private static final String DESCRIPTION_SHORT

    57         = "connect to hedgewars via irc!";

    58 

    59     private static final String VERSION = "0.6.7-Alpha_2015-11-07";

    60 

    61 

    62     private static final String MAGIC_BYTES       = "[\1\2\3]";

    63     private static final char   MAGIC_BYTE_ACTION = ((char)1); // ^A

    64     private static final char   MAGIC_BYTE_BOLD   = ((char)2); // ^B

    65     private static final char   MAGIC_BYTE_COLOR  = ((char)3); // ^C

    66 

    67     private static final String[] DEFAULT_MOTD = {

    68         "                                         ",

    69         " "+MAGIC_BYTE_COLOR+"06"+MAGIC_BYTE_BOLD+"                            SUCH FLUFFY!",

    70         "                                         ",

    71         " "+MAGIC_BYTE_COLOR+"04 MUCH BAH     "+MAGIC_BYTE_COLOR+"00__  _                     ",

    72         " "+MAGIC_BYTE_COLOR+"00          .-.'  `; `-."+MAGIC_BYTE_COLOR+"00_  __  _          ",

    73         " "+MAGIC_BYTE_COLOR+"00         (_,         .-:'  `; `"+MAGIC_BYTE_COLOR+"00-._      ",

    74         " "+MAGIC_BYTE_COLOR+"14       ,'"+MAGIC_BYTE_COLOR+"02o "+MAGIC_BYTE_COLOR+"00(        (_,           )     ",

    75         " "+MAGIC_BYTE_COLOR+"14      (__"+MAGIC_BYTE_COLOR+"00,-'      "+MAGIC_BYTE_COLOR+"15,'"+MAGIC_BYTE_COLOR+"12o "+MAGIC_BYTE_COLOR+"00(            )>   ",

    76         " "+MAGIC_BYTE_COLOR+"00         (       "+MAGIC_BYTE_COLOR+"15(__"+MAGIC_BYTE_COLOR+"00,-'            )    ",

    77         " "+MAGIC_BYTE_COLOR+"00          `-'._.--._(             )     ",

    78         " "+MAGIC_BYTE_COLOR+"14             |||  |||"+MAGIC_BYTE_COLOR+"00`-'._.--._.-'      ",

    79         " "+MAGIC_BYTE_COLOR+"15                        |||  |||        ",

    80         " "+MAGIC_BYTE_COLOR+"07"+MAGIC_BYTE_BOLD+"  WOW!                                  ",

    81         " "+MAGIC_BYTE_COLOR+"09                   VERY SHEEP           ",

    82         "                                         ",

    83         "                                         ",

    84         "                                         ",

    85         " "+MAGIC_BYTE_COLOR+"4 Latest hw2irc crimes/changes:",

    86         "     ping: ping of hwserver will only get reply if irc client pingable",

    87         "     ping: pings of irc clients will only get reply if hwserver pingable",

    88         "     rooms: id-rotation, make channel names at least 2 digits wide",

    89         "     auth: support passhash being loaded local auth file and irc pass (sent as cleartext - DO NOT USE!)",

    90         "                                         ",

    91         "                                         ",

    92     };

    93 

    94 

    95     private static final String DEFAULT_QUIT_REASON = "User quit";

    96     // NOT final

    97     private static char CHAT_COMMAND_CHAR = '\\';

    98 

    99     private final class Room {

   100         public final int id;

   101         public final String chan;

   102         public String name;

   103         private String owner = "";

   104         public int nPlayers = 0;

   105         public int nTeams   = 0;

   106 

   107         public Room(final int id, final String name, final String owner) {

   108             this.id = id;

   109             this.chan = (id<10?"#0":"#") + id;

   110             this.name = name;

   111             this.setOwner(owner);

   112         }

   113 

   114         public String getOwner() { return this.owner; }

   115 

   116         public void setOwner(final String owner) {

   117             // don't to this for first owner

   118             if (!this.owner.isEmpty()) {

   119 

   120                 // owner didn't change

   121                 if (this.owner.equals(owner))

   122                     return;

   123 

   124                 // update old room owner

   125                 final Player oldOwner = allPlayers.get(this.owner);

   126 

   127                 if (oldOwner != null)

   128                     oldOwner.isRoomAdm = false;

   129 

   130             }

   131 

   132             // update new room owner

   133             final Player newOwner = allPlayers.get(owner);

   134 

   135             if (newOwner != null)

   136                 newOwner.isRoomAdm = true;

   137 

   138             this.owner = owner;

   139 

   140         }

   141     }

   142 

   143     private final class Player {

   144         public final String nick;

   145         public final String ircNick;

   146         private boolean isAdm;

   147         private boolean isCont;

   148         private boolean isReg;

   149         public boolean inRoom;

   150         public boolean isRoomAdm;

   151         private String ircId;

   152         private String ircHostname;

   153         private boolean announced;

   154 

   155         // server info

   156         private String version = "";

   157         private String ip = "";

   158         private String room = "";

   159 

   160         public Player(final String nick) {

   161             this.nick = nick;

   162             this.ircNick = hwToIrcNick(nick);

   163             this.announced = false;

   164             updateIrcHostname();

   165         }

   166 

   167         public String getIrcHostname() { return ircHostname; }

   168         public String getIrcId()       { return ircId; }

   169 

   170         public String getRoom()        {

   171             if (room.isEmpty())

   172                 return room;

   173 

   174             return "[" + ((isAdm?"@":"") + (isRoomAdm?"+":"") + this.room);

   175         }

   176 

   177         public boolean needsAnnounce() {

   178             return !announced;

   179         }

   180 

   181         public void setAnnounced() {

   182             announced = true;

   183         }

   184 

   185         public void setInfo(final String ip, final String version, final String room) {

   186             if (this.version.isEmpty()) {

   187                 this.version = version;

   188                 this.ip = ip.replaceAll("^\\[|]$", "");

   189                 updateIrcHostname();

   190             }

   191 

   192             if (room.isEmpty())

   193                 this.room = room;

   194             else

   195                 this.room = room.replaceAll("^\\[[@+]*", "");

   196         }

   197 

   198         public boolean isServerAdmin()  { return isAdm; }

   199         //public boolean isContributor()  { return isCont; }

   200         public boolean isRegistered()   { return isReg; }

   201 

   202         public void setServerAdmin(boolean isAdm) {

   203             this.isAdm = isAdm; updateIrcHostname(); }

   204         public void setContributor(boolean isCont) {

   205             this.isCont = isCont; updateIrcHostname(); }

   206         public void setRegistered(boolean isReg) {

   207             this.isReg = isReg; updateIrcHostname(); }

   208 

   209         private void updateIrcHostname() {

   210             ircHostname = ip.isEmpty()?"":(ip + '/');

   211             ircHostname += "hw/";

   212             if (!version.isEmpty())

   213                 ircHostname += version;

   214             if (isAdm)

   215                 ircHostname += "/admin";

   216             else if (isCont)

   217                 ircHostname += "/contributor";

   218             else if (isReg)

   219                 ircHostname += "/member";

   220             else

   221                 ircHostname += "/player";

   222 

   223             updateIrcId();

   224         }

   225 

   226         private void updateIrcId() {

   227             ircId = ircNick + "!~" + ircNick + "@" + ircHostname;

   228         }

   229     }

   230 

   231     public String hw404NickToIrcId(String nick) {

   232         nick = hwToIrcNick(nick);

   233         return nick + "!~" + nick + "@hw/404";

   234     }

   235 

   236     // hash tables are thread-safe

   237     private final Map<String,  Player>  allPlayers = new Hashtable<String,  Player>();

   238     private final Map<String,  Player> roomPlayers = new Hashtable<String,  Player>();

   239     private final Map<Integer, Room>   roomsById   = new Hashtable<Integer, Room>();

   240     private final Map<String,  Room>   roomsByName = new Hashtable<String,  Room>();

   241     private final List<Room> roomsSorted = new Vector<Room>();

   242 

   243     private final List<String> ircPingQueue = new Vector<String>();

   244 

   245     private static final String DEFAULT_SERVER_HOST = "netserver.hedgewars.org";

   246     private static String SERVER_HOST = DEFAULT_SERVER_HOST;

   247     private static int IRC_PORT = 46667;

   248     

   249     private String hostname;

   250 

   251     private static final String LOBBY_CHANNEL_NAME = "#lobby";

   252     private static final String  ROOM_CHANNEL_NAME = "#room";

   253 

   254     // hack

   255     // TODO: ,

   256     private static final char MAGIC_SPACE   = ' ';

   257     private static final char MAGIC_ATSIGN  = '៙';

   258     private static final char MAGIC_PERCENT = '％';

   259     private static final char MAGIC_PLUS    = '＋';

   260     private static final char MAGIC_EXCLAM  = '❢';

   261     private static final char MAGIC_COMMA   = '，';

   262     private static final char MAGIC_COLON   = '：';

   263 

   264     private static String hwToIrcNick(final String nick) {

   265         return nick

   266             .replace(' ', MAGIC_SPACE)

   267             .replace('@', MAGIC_ATSIGN)

   268             .replace('%', MAGIC_PERCENT)

   269             .replace('+', MAGIC_PLUS)

   270             .replace('!', MAGIC_EXCLAM)

   271             .replace('，', MAGIC_COMMA)

   272             .replace('：', MAGIC_COLON)

   273             ;

   274     }

   275     private static String ircToHwNick(final String nick) {

   276         return nick

   277             .replace(MAGIC_COLON,   '：')

   278             .replace(MAGIC_COMMA,   '，')

   279             .replace(MAGIC_EXCLAM,  '!')

   280             .replace(MAGIC_PLUS,    '+')

   281             .replace(MAGIC_PERCENT, '%')

   282             .replace(MAGIC_ATSIGN,  '@')

   283             .replace(MAGIC_SPACE,   ' ')

   284             ;

   285     }

   286 

   287     private ProtocolConnection hwcon;

   288     private boolean joined = false;

   289     private boolean ircJoined = false;

   290 

   291     private void collectFurtherInfo() {

   292         hwcon.sendPing();

   293         hwcon.processNextClientFlagsMessages();

   294     }

   295 

   296     public void onPing() {

   297         send("PING :" + globalServerName);

   298     }

   299 

   300     public void onPong() {

   301         if (!ircPingQueue.isEmpty())

   302                 send(":" + globalServerName + " PONG " + globalServerName

   303                         + " :" + ircPingQueue.remove(0));

   304             

   305     }

   306 

   307     public void onConnectionLoss() {

   308         quit("Connection Loss");

   309     }

   310 

   311     public void onDisconnect(final String reason) {

   312         quit(reason);

   313     }

   314 

   315     public String onPasswordHashNeededForAuth() {

   316         return passwordHash;

   317     }

   318 

   319     public void onMalformedMessage(String contents)

   320     {

   321         this.logError("MALFORMED MESSAGE: " + contents);

   322     }

   323 

   324     public void onChat(final String user, final String message) {

   325         String ircId;

   326         Player player = allPlayers.get(user);

   327         if (player == null) {

   328             // fake user - so probably a notice

   329             sendChannelNotice(message, hwToIrcNick(user));

   330             //logWarning("onChat(): Couldn't find player with specified nick! nick: " + user);

   331             //send(":" + hw404NickToIrcId(user) + " PRIVMSG "

   332                      //+ LOBBY_CHANNEL_NAME + " :" + hwActionToIrc(message));

   333         }

   334         else

   335             send(":" + player.getIrcId() + " PRIVMSG "

   336                      + LOBBY_CHANNEL_NAME + " :" + hwActionToIrc(message));

   337     }

   338 

   339     public void onWelcomeMessage(final String message) {

   340     }

   341 

   342     public void onNotice(int number) {

   343     }

   344 

   345     public void onBanListEntry(BanType type, String target, String duration, String reason) {

   346         // TODO

   347     }

   348     public void onBanListEnd() {

   349         // TODO

   350     }

   351 

   352     public String onNickCollision(final String nick) {

   353         return nick + "_";

   354     }

   355 

   356     public void onNickSet(final String nick) {

   357         final String newNick = hwToIrcNick(nick);

   358         // tell irc client

   359         send(":" + ownIrcNick + "!~" + username + "@"

   360                             + hostname + " NICK :" + nick);

   361         ownIrcNick = newNick;

   362         updateLogPrefix();

   363         logInfo("Nickname set to " + nick);

   364     }

   365 

   366     private void flagAsInLobby(final Player player) {

   367         if (!ircJoined)

   368             return;

   369         final String ircNick = player.ircNick;

   370         if (player.isServerAdmin())

   371             send(":room-part!~@~ MODE " + LOBBY_CHANNEL_NAME + " -h+o " + ircNick + " " + ircNick);

   372         //else

   373             //send(":room-part!~@~ MODE " + LOBBY_CHANNEL_NAME + " +v " + ircNick);

   374     }

   375 

   376     private void flagAsInRoom(final Player player) {

   377         if (!ircJoined)

   378             return;

   379         final String ircNick = player.ircNick;

   380         if (player.isServerAdmin())

   381             send(":room-join!~@~ MODE " + LOBBY_CHANNEL_NAME + " -o+h " + ircNick + " " + ircNick);

   382         //else

   383             //send(":room-join!~@~ MODE " + LOBBY_CHANNEL_NAME + " -v " + ircNick);

   384     }

   385 

   386 // TODO somewhere: escape char for magic chars!

   387 

   388 // TODO /join with playername => FOLLOW :D

   389 

   390     public void sendPlayerMode(final Player player) {

   391         char c;

   392         if (player.isServerAdmin())

   393             c = player.inRoom?'h':'o';

   394         else if (player.isRegistered())

   395             c = 'v';

   396         else

   397             // no mode

   398             return;

   399 

   400         send(":server-join!~@~ MODE " + LOBBY_CHANNEL_NAME + " +" + c + " " + player.ircNick);

   401     }

   402 

   403     private Player ownPlayer = null;

   404 

   405     public void onLobbyJoin(final String[] users) {

   406 

   407         final List<Player> newPlayers = new ArrayList<Player>(users.length);

   408 

   409         // process joins

   410         for (final String user : users) {

   411             final Player player = new Player(user);

   412             if (ownPlayer == null)

   413                 ownPlayer = player;

   414             newPlayers.add(player);

   415             allPlayers.put(user, player);

   416         }

   417 

   418         // make sure we get the client flags before we announce anything

   419         collectFurtherInfo();

   420 

   421         // get player info

   422         // NOTE: if player is in room, then info was already retrieved

   423         for (final Player player : newPlayers) {

   424             if (!player.inRoom)

   425                 hwcon.requestInfo(player.nick);

   426         }

   427 

   428         /* DISABLED - we'll announce later - when receiving info

   429         // announce joins

   430         if (ircJoined) {

   431             for (final Player player : newPlayers) {

   432                 final String ircId = player.getIrcId();

   433                 send(":" + ircId

   434                          + " JOIN "+ lobbyChannel.name);

   435                 sendPlayerMode(player);

   436             }

   437         }

   438         */

   439         if (!ircJoined) {

   440             // don't announced players that were there before join already

   441             for (final Player player : newPlayers) {

   442                 player.setAnnounced();

   443             }

   444         }

   445 

   446         if (!joined) {

   447             joined = true;

   448             // forget password hash, we don't need it anymore.

   449             passwordHash = "";

   450             logInfo("Hedgewars server/lobby joined.");

   451             sendSelfNotice("Hedgewars server was joined successfully");

   452             // do this after join so that rooms can be assigned to their owners

   453             hwcon.requestRoomsList();

   454         }

   455     }

   456 

   457     private void makeIrcJoinLobby() {

   458             sendGlobal("INVITE " + ownIrcNick + " " + LOBBY_CHANNEL_NAME);

   459             try{Thread.sleep(3000);}catch(Exception e){}

   460             join(lobbyChannel.name);

   461             sendSelfNotice("Joining lobby-channel: " + lobbyChannel.name);

   462     }

   463 

   464     private void announcePlayerJoinLobby(final Player player) {

   465             player.setAnnounced();

   466             send(":" + player.getIrcId()

   467                      + " JOIN "+ lobbyChannel.name);

   468             sendPlayerMode(player);

   469     }

   470 

   471     public void onLobbyLeave(final String user, final String reason) {

   472         final Player player = allPlayers.get(user);

   473         if (player == null) {

   474             logWarning("onLobbyLeave(): Couldn't find player with specified nick! nick: " + user);

   475             sendIfJoined(":" + hw404NickToIrcId(user)

   476                  + " PART " + lobbyChannel.name + " " + reason);

   477         }

   478         else {

   479             if (ircJoined && player.needsAnnounce())

   480                 announcePlayerJoinLobby(player);

   481             sendIfJoined(":" + player.getIrcId()

   482                  + " PART " + lobbyChannel.name + " " + reason);

   483             allPlayers.remove(user);

   484         }

   485     }

   486 

   487     private int lastRoomId = 0;

   488 

   489     public void onRoomInfo(final String name, final String flags,

   490                            final String newName, final int nUsers,

   491                            final int nTeams, final String owner,

   492                            final String map, final String style,

   493                            final String scheme, final String weapons) {

   494 

   495         Room room = roomsByName.get(name);

   496 

   497         if (room == null) {

   498             // try to reuse old ids

   499             if (lastRoomId >= 90)

   500                 lastRoomId = 9;

   501 

   502             // search for first free

   503             while(roomsById.containsKey(++lastRoomId)) { }

   504 

   505             room = new Room(lastRoomId, newName, owner);

   506             roomsById.put(lastRoomId, room);

   507             roomsByName.put(newName, room);

   508             roomsSorted.add(room);

   509         }

   510         else if (!room.name.equals(newName)) {

   511             room.name = newName;

   512             roomsByName.put(newName, roomsByName.remove(name));

   513         }

   514 

   515         // update data

   516         room.setOwner(owner);

   517         room.nPlayers = nUsers;

   518         room.nTeams = nTeams;

   519     }

   520 

   521     public void onRoomDel(final String name) {

   522         final Room room = roomsByName.remove(name);

   523 

   524         if (room != null) {

   525             roomsById.remove(room.id);

   526             roomsSorted.remove(room);

   527         }

   528     }

   529 

   530     public void onRoomJoin(final String[] users) {

   531     }

   532 

   533     public void onRoomLeave(final String[] users) {

   534     }

   535 

   536     // TODO vector that remembers who's info was requested for manually

   537     List<String> requestedInfos =  new Vector<String>();

   538 

   539     public void onUserInfo(final String user, final String ip, final String version, final String room) {

   540         Player player = allPlayers.get(user);

   541         if (player != null) {

   542             player.setInfo(ip, version, room);

   543             if (ircJoined) {

   544                 if (player.needsAnnounce())

   545                     announcePlayerJoinLobby(player);

   546             }

   547             else {

   548                 if (player == ownPlayer) {

   549                     

   550                     makeIrcJoinLobby();

   551                 }

   552             }

   553         }

   554 

   555         // if MANUAL send notice

   556         if (requestedInfos.remove(user)) {

   557             final String nick = hwToIrcNick(user);

   558             sendServerNotice(nick + " - " + buildInfoString(ip, version, room));

   559         }

   560     }

   561 

   562     public void onUserFlagChange(final String user, final UserFlagType flag, final boolean newValue) {

   563         final Player player = allPlayers.get(user);

   564         if (player == null) {

   565             logError("onUserFlagChange(): Couldn't find player with specified nick! nick: " + user);

   566             return;

   567         }

   568         switch (flag) {

   569             case ADMIN:

   570                 player.setServerAdmin(newValue);

   571                 if (newValue) {

   572                     logDebug(user + " is server admin");

   573                     //sendIfJoined(":server!~@~ MODE " + LOBBY_CHANNEL_NAME + " -v+o " + player.ircNick + " " + player.ircNick);

   574                 }

   575                 break;

   576             case INROOM:

   577                 player.inRoom = newValue;

   578                 if (newValue) {

   579                     flagAsInRoom(player);

   580                     logDebug(user + " entered a room");

   581                     // get new room info

   582                     hwcon.requestInfo(player.nick);

   583                 }

   584                 else {

   585                     flagAsInLobby(player);

   586                     logDebug(user + " returned to lobby");

   587                     player.inRoom = false;

   588                 }

   589                 break;

   590             case REGISTERED:

   591                 player.setRegistered(newValue);

   592                 break;

   593             default: break;

   594         }

   595     }

   596 

   597     public class Channel

   598     {

   599         private String topic;

   600         private final String name;

   601         private final Map<String, Player> players;

   602 

   603         public Channel(final String name, final String topic, final Map<String, Player> players) {

   604             this.name = name;

   605             this.topic = topic;

   606             this.players = players;

   607         }

   608     }

   609 

   610     public void logInfo(final String message) {

   611         System.out.println(this.logPrefix + ": " + message);

   612     }

   613 

   614     public void logDebug(final String message) {

   615         System.out.println(this.logPrefix + "| " + message);

   616     }

   617 

   618     public void logWarning(final String message) {

   619         System.err.println(this.logPrefix + "? " + message);

   620     }

   621 

   622     public void logError(final String message) {

   623         System.err.println(this.logPrefix + "! " + message);

   624     }

   625 

   626 

   627     //private static final Object mutex = new Object();

   628     private boolean joinSent = false;

   629     private Socket socket;

   630     private String username;

   631     private String ownIrcNick;

   632     private String description;

   633     private static Map<String, Connection> connectionMap = new HashMap<String, Connection>();

   634     // TODO those MUST NOT be static!

   635     //private Map<String, Channel> channelMap = new HashMap<String, Channel>();

   636     private final Channel lobbyChannel;

   637     private static String globalServerName;

   638     private String logPrefix;

   639     private final String clientId;

   640     private String passwordHash = "";

   641 

   642     private final Connection thisConnection;

   643 

   644     public Connection(Socket socket, final String clientId) throws Exception

   645     {

   646         this.ownIrcNick = "NONAME";

   647         this.socket = socket;

   648         this.hostname = ((InetSocketAddress)socket.getRemoteSocketAddress())

   649                  .getAddress().getHostAddress();

   650         this.clientId = clientId;

   651         updateLogPrefix();

   652         thisConnection = this;

   653         logInfo("New Connection");

   654 

   655         this.hwcon = null;

   656 

   657         try {

   658             this.hwcon = new ProtocolConnection(this, SERVER_HOST);

   659             logInfo("Connection to " + SERVER_HOST + " established.");

   660         }

   661         catch(Exception ex) {

   662             final String errmsg = "Could not connect to " + SERVER_HOST + ": "

   663                 + ex.getMessage();

   664             logError(errmsg);

   665             sendQuit(errmsg);

   666         }

   667 

   668         final String lobbyTopic = " # " + SERVER_HOST + " - HEDGEWARS SERVER LOBBY # ";

   669         this.lobbyChannel = new Channel(LOBBY_CHANNEL_NAME, lobbyTopic, allPlayers);

   670 

   671         // start in new thread

   672         if (hwcon != null) {

   673             (this.hwcon.processMessages(true)).start();

   674         }

   675     }

   676     

   677     private void updateLogPrefix() {

   678         if (ownIrcNick == null)

   679             this.logPrefix = clientId + " ";

   680         else

   681             this.logPrefix = clientId + " [" + ownIrcNick + "] ";

   682     }

   683 

   684     private void setNick(final String nick) {

   685         if (passwordHash.isEmpty()) {

   686             try {

   687               final Properties authProps = new Properties();

   688               final String authFile = this.hostname + ".auth";

   689               logInfo("Attempting to load auth info from " + authFile);

   690               authProps.load(new FileInputStream(authFile));

   691               passwordHash = authProps.getProperty(nick, "");

   692               if (passwordHash.isEmpty())

   693                 logInfo("Auth info file didn't contain any password hash for: " + nick);

   694             } catch (IOException e) {

   695                 logInfo("Auth info file couldn't be loaded.");

   696             }

   697         }

   698 

   699         // append _ just in case

   700         if (!passwordHash.isEmpty() || nick.endsWith("_")) {

   701             ownIrcNick = nick;

   702             hwcon.setNick(ircToHwNick(nick));

   703         }

   704         else {

   705             final String nick_ = nick + "_";

   706             ownIrcNick = nick_;

   707             hwcon.setNick(ircToHwNick(nick_));

   708         }

   709     }

   710 

   711     public String getRepresentation()

   712     {

   713         return ownIrcNick + "!~" + username + "@" + hostname;

   714     }

   715 

   716     private static int lastClientId = 0;

   717 

   718     /**

   719      * @param args

   720      */

   721     public static void main(String[] args) throws Throwable

   722     {

   723         if (args.length > 0)

   724         {

   725             SERVER_HOST = args[0];

   726         }

   727         if (args.length > 1)

   728         {

   729             IRC_PORT = Integer.parseInt(args[1]);

   730         }

   731 

   732         globalServerName = "hw2irc";

   733 

   734         if (!SERVER_HOST.equals(DEFAULT_SERVER_HOST))

   735             globalServerName += "~" + SERVER_HOST;

   736 

   737         final int port = IRC_PORT;

   738         ServerSocket ss = new ServerSocket(port);

   739         System.out.println("Listening on port " + port);

   740         while (true)

   741         {

   742             Socket s = ss.accept();

   743             final String clientId = "client" + (++lastClientId) + '-'

   744                  + ((InetSocketAddress)s.getRemoteSocketAddress())

   745                  .getAddress().getHostAddress();

   746             try {

   747                 Connection clientCon = new Connection(s, clientId);

   748                 //clientCon.run();

   749                 Thread clientThread = new Thread(clientCon, clientId);

   750                 clientThread.start();

   751             }

   752             catch (Exception ex) {

   753                 System.err.println("FATAL: Server connection thread " + clientId + " crashed on startup! " + ex.getMessage());

   754                 ex.printStackTrace();

   755             }

   756 

   757             System.out.println("Note: Not accepting new clients for the next " + SLEEP_BETWEEN_LOGIN_DURATION + "s, trying to avoid reconnecting too quickly.");

   758             Thread.sleep(SLEEP_BETWEEN_LOGIN_DURATION * 1000);

   759             System.out.println("Note: Accepting clients again!");

   760         }

   761     }

   762 

   763     private static final int SLEEP_BETWEEN_LOGIN_DURATION = 122;

   764 

   765     private boolean hasQuit = false;

   766 

   767     public synchronized void quit(final String reason) {

   768         if (hasQuit)

   769             return;

   770 

   771         hasQuit = true;

   772         // disconnect from hedgewars server

   773         if (hwcon != null)

   774             hwcon.disconnect(reason);

   775         // disconnect irc client

   776         sendQuit("Quit: " + reason);

   777         // wait some time so that last data can be pushed

   778         try {

   779             Thread.sleep(200);

   780         }

   781         catch (Exception e) { }

   782         // terminate

   783         terminateConnection = true;

   784     }

   785 

   786 

   787     private static String hwActionToIrc(final String chatMsg) {

   788         if (!chatMsg.startsWith("/me ") || (chatMsg.length() <= 4))

   789             return chatMsg;

   790 

   791         return MAGIC_BYTE_ACTION + "ACTION " + chatMsg.substring(4) + MAGIC_BYTE_ACTION;

   792     }

   793 

   794     private static String ircActionToHw(final String chatMsg) {

   795         if (!chatMsg.startsWith(MAGIC_BYTE_ACTION + "ACTION ") || (chatMsg.length() <= 9))

   796             return chatMsg;

   797 

   798         return "/me " + chatMsg.substring(8, chatMsg.length() - 1);

   799     }

   800 

   801 // TODO: why is still still being called when joining bogus channel name?

   802     public void join(String channelName)

   803     {

   804         if (ownPlayer == null) {

   805             sendSelfNotice("Trying to join while ownPlayer == null. Aborting!");

   806             quit("Something went horribly wrong.");

   807             return;

   808         }

   809 

   810 

   811         final Channel channel = getChannel(channelName);

   812 

   813         // TODO reserve special char for creating a new ROOM

   814         // it will be named after the player name by default

   815         // can be changed with /topic after

   816 

   817         // not a valid channel

   818         if (channel == null) {

   819             sendSelfNotice("You cannot manually create channels here.");

   820             sendGlobal(ERR_NOSUCHCHANNEL + ownIrcNick + " " + channel.name

   821                     + " :No such channel");

   822             return;

   823         }

   824 

   825         // TODO if inRoom "Can't join rooms while still in room"

   826 

   827         // TODO set this based on room host/admin mode maybe

   828 

   829 /* :testuser2131!~r@asdasdasdasd.at JOIN #asdkjasda

   830 :weber.freenode.net MODE #asdkjasda +ns

   831 :weber.freenode.net 353 testuser2131 @ #asdkjasda :@testuser2131

   832 :weber.freenode.net 366 testuser2131 #asdkjasda :End of /NAMES list.

   833 :weber.freenode.net NOTICE #asdkjasda :[freenode-info] why register and identify? your IRC nick is how people know you. http://freenode.net/faq.shtml#nicksetup

   834 

   835 */ 

   836         send(":" + ownPlayer.getIrcId() + " JOIN "

   837          + channelName);

   838 

   839         //send(":sheeppidgin!~r@localhost JOIN " + channelName);

   840 

   841         ircJoined = true;

   842 

   843         sendGlobal(":hw2irc MODE #lobby +nt");

   844 

   845         sendTopic(channel);

   846 

   847         sendNames(channel);

   848 

   849     }

   850 

   851     private void sendTopic(final Channel channel) {

   852         if (channel.topic != null)

   853             sendGlobal(RPL_TOPIC + ownIrcNick + " " + channel.name

   854                     + " :" + channel.topic);

   855         else

   856             sendGlobal(RPL_NOTOPIC + ownIrcNick + " " + channel.name

   857                     + " :No topic is set");

   858     }

   859 

   860     private void sendNames(final Channel channel) {

   861         // There is no error reply for bad channel names.

   862 

   863         if (channel != null) {

   864             // send player list

   865             for (final Player player : channel.players.values()) {

   866 

   867                 final String prefix;

   868 

   869                 if (player.isServerAdmin())

   870                     prefix = (player.isServerAdmin())?"@":"%";

   871                 else

   872                     prefix = (player.isRegistered())?"+":"";

   873 

   874                 sendGlobal(RPL_NAMREPLY + ownIrcNick + " = " + channel.name

   875                         + " :" + prefix + player.ircNick);

   876             }

   877         }

   878 

   879         sendGlobal(RPL_ENDOFNAMES + ownIrcNick + " " + channel.name

   880                 + " :End of /NAMES list");

   881     }

   882 

   883     private void sendList(final String filter) {

   884         // id column size

   885         //int idl = 1 + String.valueOf(lastRoomId).length();

   886 

   887         //if (idl < 3)

   888             //idl = 3;

   889 

   890         // send rooms list

   891         sendGlobal(RPL_LISTSTART + ownIrcNick 

   892             //+ String.format(" %1$" + idl + "s  #P  #T  Name", "ID"));

   893             + String.format(" %1$s #P #T Name", "ID"));

   894 

   895         if (filter.isEmpty() || filter.equals(".")) {

   896             // lobby

   897             if (filter.isEmpty())

   898                 sendGlobal(RPL_LIST + ownIrcNick + " " + LOBBY_CHANNEL_NAME

   899                     + " " + allPlayers.size() + " :" + lobbyChannel.topic);

   900 

   901             // room list could be changed by server while we reply client

   902             synchronized (roomsSorted) {

   903                 for (final Room room : roomsSorted) {

   904                     sendGlobal(RPL_LIST + ownIrcNick

   905                         //+ String.format(" %1$" + idl + "s  %2$2d  :%3$2d  %4$s",

   906                         + String.format(" %1$s %2$d :%3$d  %4$s",

   907                             room.chan, room.nPlayers, room.nTeams, room.name));

   908                 }

   909             }

   910         }

   911         // TODO filter

   912 

   913         sendGlobal(RPL_LISTEND + ownIrcNick + " " + " :End of /LIST");

   914     }

   915 

   916     private List<Player> findPlayers(final String expr) {

   917         List<Player> matches = new ArrayList<Player>(allPlayers.size());

   918 

   919         try {

   920             final int flags = Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE;

   921             final Pattern regx = Pattern.compile(expr, flags);

   922 

   923             for (final Player p : allPlayers.values()) {

   924                 if ((regx.matcher(p.nick).find())

   925                     || (regx.matcher(p.ircId).find())

   926                     //|| (regx.matcher(p.version).find())

   927                     //|| ((p.ip.length() > 2) && regx.matcher(p.ip).find())

   928                     || (!p.getRoom().isEmpty() && regx.matcher(p.getRoom()).find())

   929                 ) matches.add(p);

   930             }

   931         }

   932         catch(PatternSyntaxException ex) {

   933             sendSelfNotice("Pattern not understood: " + ex.getMessage());

   934         }

   935 

   936         return matches;

   937     }

   938 

   939     private String buildInfoString(final String ip, final String version, final String room) {

   940         return (ip.equals("[]")?"":ip + " ") + version + (room.isEmpty()?"":" " + room);

   941     }

   942 

   943     private void sendWhoForPlayer(final Player player) {

   944         sendWhoForPlayer(LOBBY_CHANNEL_NAME, player.ircNick, (player.inRoom?player.getRoom():""), player.getIrcHostname());

   945     }

   946 

   947     private void sendWhoForPlayer(final Player player, final String info) {

   948         sendWhoForPlayer(LOBBY_CHANNEL_NAME, player.ircNick, info, player.getIrcHostname());

   949     }

   950 

   951     private void sendWhoForPlayer(final String nick, final String info) {

   952         sendWhoForPlayer(LOBBY_CHANNEL_NAME, nick, info);

   953     }

   954 

   955     private void sendWhoForPlayer(final String channel, final String nick, final String info) {

   956         final Player player = allPlayers.get(nick);

   957 

   958         if (player == null)

   959             sendWhoForPlayer("OFFLINE", hwToIrcNick(nick), info, "hw/offline");

   960         else

   961             sendWhoForPlayer(channel,   player.ircNick,    info, player.getIrcHostname());

   962     }

   963 

   964     private void sendWhoForPlayer(final String channel, final String ircNick, final String info, final String hostname) {

   965         sendGlobal(RPL_WHOREPLY + channel + " " + channel

   966                             + " ~" + ircNick + " " + hostname

   967                             + " " + globalServerName + " " + ircNick

   968                             + " H :0 " + info);

   969     }

   970 

   971     private void sendWhoEnd(final String ofWho) {

   972         send(RPL_ENDOFWHO + ownIrcNick + " " + ofWho

   973                         + " :End of /WHO list.");

   974     }

   975 

   976     private void sendMotd() {

   977         sendGlobal(RPL_MOTDSTART + ownIrcNick + " :- Message of the Day -");

   978         final String mline = RPL_MOTD + ownIrcNick + " :";

   979         for(final String line : DEFAULT_MOTD) {

   980             sendGlobal(mline + line);

   981         }

   982         sendGlobal(RPL_ENDOFMOTD + ownIrcNick + " :End of /MOTD command.");

   983     }

   984 

   985     private Channel getChannel(final String name) {

   986         if (name.equals(LOBBY_CHANNEL_NAME)) {

   987             return lobbyChannel;

   988         }

   989 

   990         return null;

   991     }

   992 

   993     private enum Command

   994     {

   995         PASS(1, 1)

   996         {

   997             @Override

   998             public void run(final Connection con, final String prefix, final String[] args)

   999                     throws Exception

  1000             {

  1001                 con.passwordHash = args[0];

  1002             }

  1003         },

  1004         NICK(1, 1)

  1005         {

  1006             @Override

  1007             public void run(final Connection con, final String prefix, final String[] args)

  1008                     throws Exception

  1009             {

  1010                 con.setNick(args[0]);

  1011             }

  1012         },

  1013         USER(1, 4)

  1014         {

  1015             @Override

  1016             public void run(final Connection con, final String prefix, final String[] args)

  1017                     throws Exception

  1018             {

  1019                 if (con.username != null)

  1020                 {

  1021                     con.send("NOTICE AUTH :You can't change your user "

  1022                             + "information after you've logged in right now.");

  1023                     return;

  1024                 }

  1025                 con.username = args[0];

  1026                 String forDescription = args.length > 3 ? args[3]

  1027                         : "(no description)";

  1028                 con.description = forDescription;

  1029                 /*

  1030                  * Now we'll send the user their initial information.

  1031                  */

  1032                 con.sendGlobal(RPL_WELCOME + con.ownIrcNick + " :Welcome to "

  1033                         + globalServerName + " - " + DESCRIPTION_SHORT);

  1034                 con.sendGlobal("004 " + con.ownIrcNick + " " + globalServerName

  1035                         + " " + VERSION);

  1036 

  1037                 con.sendMotd();

  1038 

  1039             }

  1040         },

  1041         MOTD(0, 0)

  1042         {

  1043             @Override

  1044             public void run(final Connection con, final String prefix, final String[] args)

  1045                     throws Exception

  1046             {

  1047                 con.sendMotd();

  1048             }

  1049         },

  1050         PING(1, 1)

  1051         {

  1052             @Override

  1053             public void run(final Connection con, final String prefix, final String[] args)

  1054                     throws Exception

  1055             {

  1056                 con.ircPingQueue.add(args[0]);

  1057                 con.hwcon.sendPing();

  1058             }

  1059         },

  1060         PONG(1, 2)

  1061         {

  1062             @Override

  1063             public void run(final Connection con, final String prefix, final String[] args)

  1064                     throws Exception

  1065             {

  1066                 con.hwcon.sendPong();

  1067             }

  1068         },

  1069         NAMES(1, 1)

  1070         {

  1071             @Override

  1072             public void run(final Connection con, final String prefix, final String[] args)

  1073                     throws Exception

  1074             {

  1075                 final Channel channel = con.getChannel(args[0]);

  1076                 con.sendNames(channel);

  1077             }

  1078         },

  1079         LIST(0, 2)

  1080         {

  1081             @Override

  1082             public void run(final Connection con, final String prefix, final String[] args)

  1083                     throws Exception

  1084             {

  1085                 // TODO filter by args[1] (comma sep list of chans), make # optional

  1086                 // ignore args[1] (server), TODO: maybe check and send RPL_NOSUCHSERVER if wrong

  1087                 con.sendList(args.length > 0?args[0]:"");

  1088             }

  1089         },

  1090         JOIN(1, 2)

  1091         {

  1092             @Override

  1093             public void run(final Connection con, final String prefix, final String[] args)

  1094                     throws Exception

  1095             {

  1096                 if (args.length < 1)  {

  1097                     con.sendSelfNotice("You didn't specify what you want to join!");

  1098                     return;

  1099                 }

  1100 

  1101                 if (con.ownPlayer == null) {

  1102                     con.sendSelfNotice("Lobby is not ready to be joined yet - hold on a second!");

  1103                     return;

  1104                 }

  1105 

  1106                 if (args[0].equals(LOBBY_CHANNEL_NAME)) {

  1107                     //con.sendSelfNotice("Lobby can't be joined manually!");

  1108                     con.join(LOBBY_CHANNEL_NAME);

  1109                     return;

  1110                 }

  1111                 con.sendSelfNotice("Joining rooms is not supported yet, sorry!");

  1112             }

  1113         },

  1114         WHO(0, 2)

  1115         {

  1116             @Override

  1117             public void run(final Connection con, final String prefix, final String[] args)

  1118                     throws Exception

  1119             {

  1120                 if (args.length < 1)

  1121                     return;

  1122 

  1123                 final String target = args[0];

  1124 

  1125                 Map<String, Player> players = null;

  1126 

  1127                 if (target.equals(LOBBY_CHANNEL_NAME)) {

  1128                     players = con.allPlayers;

  1129                 }

  1130                 // on channel join WHO is called on channel

  1131                 else if (target.equals(ROOM_CHANNEL_NAME)) {

  1132                     players = con.roomPlayers;

  1133                 }

  1134 

  1135                 if (players != null) {

  1136                     for (final Player player : players.values()) {