mirror of
https://github.com/EssentialsX/Essentials.git
synced 2024-08-26 23:40:17 +02:00
Replacing martyr with Pircbot 1.5
This commit is contained in:
parent
860d446d28
commit
9312871250
|
@ -1,29 +1,11 @@
|
|||
package com.earth2me.essentials.update;
|
||||
|
||||
import f00f.net.irc.martyr.GenericAutoService;
|
||||
import f00f.net.irc.martyr.IRCConnection;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.Member;
|
||||
import f00f.net.irc.martyr.commands.InviteCommand;
|
||||
import f00f.net.irc.martyr.commands.KickCommand;
|
||||
import f00f.net.irc.martyr.commands.MessageCommand;
|
||||
import f00f.net.irc.martyr.commands.NoticeCommand;
|
||||
import f00f.net.irc.martyr.commands.QuitCommand;
|
||||
import f00f.net.irc.martyr.commands.TopicCommand;
|
||||
import f00f.net.irc.martyr.errors.GenericJoinError;
|
||||
import f00f.net.irc.martyr.services.AutoJoin;
|
||||
import f00f.net.irc.martyr.services.AutoReconnect;
|
||||
import f00f.net.irc.martyr.services.AutoRegister;
|
||||
import f00f.net.irc.martyr.services.AutoResponder;
|
||||
import java.io.BufferedReader;
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.nio.charset.Charset;
|
||||
import java.util.Enumeration;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.regex.Matcher;
|
||||
|
@ -39,17 +21,16 @@ import org.bukkit.event.player.PlayerListener;
|
|||
import org.bukkit.event.player.PlayerQuitEvent;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
import org.bukkit.plugin.PluginManager;
|
||||
import org.jibble.pircbot.User;
|
||||
|
||||
|
||||
public class EssentialsHelp extends PlayerListener
|
||||
{
|
||||
private transient Player chatUser;
|
||||
private transient IRCConnection connection;
|
||||
private transient AutoReconnect autoReconnect;
|
||||
private transient boolean shouldQuit = false;
|
||||
private final transient Server server;
|
||||
private final transient Plugin plugin;
|
||||
private final static Charset UTF8 = Charset.forName("utf-8");
|
||||
private transient IrcBot ircBot;
|
||||
|
||||
public EssentialsHelp(Plugin plugin)
|
||||
{
|
||||
|
@ -71,7 +52,7 @@ public class EssentialsHelp extends PlayerListener
|
|||
if (chatUser == null)
|
||||
{
|
||||
chatUser = (Player)sender;
|
||||
connection = null;
|
||||
ircBot = null;
|
||||
sender.sendMessage("You will be connected to the Essentials Help Chat.");
|
||||
sender.sendMessage("All your chat messages will be forwarded to the channel. You can't chat with other players on your server while in help chat, but you can use commands.");
|
||||
sender.sendMessage("Please be patient, if noone is available, check back later.");
|
||||
|
@ -92,62 +73,69 @@ public class EssentialsHelp extends PlayerListener
|
|||
|
||||
public void onDisable()
|
||||
{
|
||||
if (autoReconnect != null && connection != null)
|
||||
if ( ircBot != null)
|
||||
{
|
||||
autoReconnect.disable();
|
||||
shouldQuit = true;
|
||||
connection.disconnect();
|
||||
ircBot.quit();
|
||||
ircBot = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void sendChatMessage(final Player player, final String message)
|
||||
private boolean sendChatMessage(final Player player, final String message)
|
||||
{
|
||||
final String messageCleaned = message.trim();
|
||||
if (messageCleaned.isEmpty())
|
||||
{
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
if (connection == null)
|
||||
if (ircBot == null)
|
||||
{
|
||||
if (messageCleaned.equalsIgnoreCase("yes"))
|
||||
{
|
||||
player.sendMessage("Connecting...");
|
||||
connectToIRC(player);
|
||||
return true;
|
||||
}
|
||||
if (messageCleaned.equalsIgnoreCase("no") || message.equalsIgnoreCase("!quit"))
|
||||
{
|
||||
chatUser = null;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ircBot.isKicked()) {
|
||||
chatUser = null;
|
||||
ircBot.quit();
|
||||
ircBot = null;
|
||||
return false;
|
||||
}
|
||||
final String lowMessage = messageCleaned.toLowerCase();
|
||||
if (lowMessage.startsWith("!quit"))
|
||||
{
|
||||
chatUser = null;
|
||||
autoReconnect.disable();
|
||||
shouldQuit = true;
|
||||
connection.sendCommand(new QuitCommand("Connection closed by user."));
|
||||
if (ircBot != null) {
|
||||
ircBot.quit();
|
||||
ircBot = null;
|
||||
}
|
||||
player.sendMessage("Connection closed.");
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (!connection.getClientState().getChannels().hasMoreElements())
|
||||
if (!ircBot.isConnected() || ircBot.getChannels().length == 0)
|
||||
{
|
||||
player.sendMessage("Not connected yet!");
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
if (lowMessage.startsWith("!list"))
|
||||
{
|
||||
final Enumeration members = ((Channel)connection.getClientState().getChannels().nextElement()).getMembers();
|
||||
final User[] members = ircBot.getUsers();
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
while (members.hasMoreElements())
|
||||
for (User user : members)
|
||||
{
|
||||
if (sb.length() > 0)
|
||||
{
|
||||
sb.append("§f, ");
|
||||
}
|
||||
final Member member = (Member)members.nextElement();
|
||||
if (member.hasOps() || member.hasVoice())
|
||||
if (user.isOp() || user.hasVoice())
|
||||
{
|
||||
sb.append("§6");
|
||||
}
|
||||
|
@ -155,10 +143,10 @@ public class EssentialsHelp extends PlayerListener
|
|||
{
|
||||
sb.append("§7");
|
||||
}
|
||||
sb.append(member.getNick());
|
||||
sb.append(user.getPrefix()).append(user.getNick());
|
||||
}
|
||||
player.sendMessage(sb.toString());
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (lowMessage.startsWith("!help"))
|
||||
{
|
||||
|
@ -168,37 +156,33 @@ public class EssentialsHelp extends PlayerListener
|
|||
player.sendMessage("!config - Sends your Essentials config to the chat.");
|
||||
player.sendMessage("!list - List all players in chat.");
|
||||
player.sendMessage("!quit - Leave chat.");
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (lowMessage.startsWith("!errors"))
|
||||
{
|
||||
sendErrors();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (lowMessage.startsWith("!startup"))
|
||||
{
|
||||
sendStartup();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
if (lowMessage.startsWith("!config"))
|
||||
{
|
||||
sendConfig();
|
||||
return;
|
||||
return true;
|
||||
}
|
||||
final Channel channel = (Channel)connection.getClientState().getChannels().nextElement();
|
||||
connection.sendCommand(new MessageCommand(channel.getName(), messageCleaned));
|
||||
chatUser.sendMessage("§6" + connection.getClientState().getNick().getNick() + ": §7" + messageCleaned);
|
||||
ircBot.sendMessage(messageCleaned);
|
||||
chatUser.sendMessage("§6" + ircBot.getNick() + ": §7" + messageCleaned);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private void connectToIRC(final Player player)
|
||||
private String buildIrcName()
|
||||
{
|
||||
connection = new IRCConnection();
|
||||
// Required services
|
||||
new AutoResponder(connection);
|
||||
int versionNumber = 0;
|
||||
final StringBuilder nameBuilder = new StringBuilder();
|
||||
nameBuilder.append(player.getName());
|
||||
nameBuilder.append(chatUser.getName());
|
||||
|
||||
final Matcher versionMatch = Pattern.compile("git-Bukkit-([0-9]+).([0-9]+).([0-9]+)-[0-9]+-[0-9a-z]+-b([0-9]+)jnks.*").matcher(server.getVersion());
|
||||
if (versionMatch.matches())
|
||||
|
@ -268,28 +252,12 @@ public class EssentialsHelp extends PlayerListener
|
|||
nameBuilder.append(perm.getDescription().getVersion());
|
||||
}
|
||||
|
||||
new AutoRegister(connection, "Ess_" + player.getName(), "esshelp", nameBuilder.toString());
|
||||
|
||||
autoReconnect = new AutoReconnect(connection);
|
||||
new KickAutoJoin(connection, "#essentials");
|
||||
|
||||
new IRCListener(connection);
|
||||
autoReconnect.go("irc.esper.net", 6667);
|
||||
return nameBuilder.toString();
|
||||
}
|
||||
|
||||
private void handleIRCmessage(final String nick, final String message)
|
||||
private void connectToIRC(final Player player)
|
||||
{
|
||||
|
||||
if (chatUser != null)
|
||||
{
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
sb.append("§6");
|
||||
sb.append(nick);
|
||||
sb.append(": §7");
|
||||
final String coloredmessage = message.replace("\u000300", "§f").replace("\u000301", "§0").replace("\u000302", "§1").replace("\u000303", "§2").replace("\u000304", "§c").replace("\u000305", "§4").replace("\u000306", "§5").replace("\u000307", "§6").replace("\u000308", "§e").replace("\u000309", "§a").replace("\u00030", "§f").replace("\u000310", "§b").replace("\u000311", "§f").replace("\u000312", "§9").replace("\u000313", "§d").replace("\u000314", "§8").replace("\u000315", "§7").replace("\u00031", "§0").replace("\u00032", "§1").replace("\u00033", "§2").replace("\u00034", "§c").replace("\u00035", "§4").replace("\u00036", "§5").replace("\u00037", "§6").replace("\u00038", "§e").replace("\u00039", "§a").replace("\u0003", "§7");
|
||||
sb.append(coloredmessage);
|
||||
chatUser.sendMessage(sb.toString());
|
||||
}
|
||||
ircBot = new IrcBot(player, "Ess_" + player.getName(), buildIrcName());
|
||||
}
|
||||
|
||||
private void sendErrors()
|
||||
|
@ -312,7 +280,7 @@ public class EssentialsHelp extends PlayerListener
|
|||
FileInputStream fis = new FileInputStream(logFile);
|
||||
if (logFile.length() > 1000000)
|
||||
{
|
||||
fis.skip(logFile.length()-1000000);
|
||||
fis.skip(logFile.length() - 1000000);
|
||||
}
|
||||
page = new BufferedReader(new InputStreamReader(fis));
|
||||
final StringBuilder input = new StringBuilder();
|
||||
|
@ -320,19 +288,20 @@ public class EssentialsHelp extends PlayerListener
|
|||
Pattern pattern = Pattern.compile("^[0-9 :-]+\\[INFO\\].*");
|
||||
while ((line = page.readLine()) != null)
|
||||
{
|
||||
if (!pattern.matcher(line).matches()) {
|
||||
if (!pattern.matcher(line).matches())
|
||||
{
|
||||
input.append(line).append("\n");
|
||||
}
|
||||
}
|
||||
if (input.length()>10000) {
|
||||
input.delete(0, input.length()-10000);
|
||||
if (input.length() > 10000)
|
||||
{
|
||||
input.delete(0, input.length() - 10000);
|
||||
}
|
||||
final PastieUpload pastie = new PastieUpload();
|
||||
final String url = pastie.send(input.toString());
|
||||
final Channel channel = (Channel)connection.getClientState().getChannels().nextElement();
|
||||
String message = "Errors: " + url;
|
||||
chatUser.sendMessage("§6" + connection.getClientState().getNick().getNick() + ": §7" + message);
|
||||
connection.sendCommand(new MessageCommand(channel.getName(), message));
|
||||
chatUser.sendMessage("§6" + ircBot.getNick() + ": §7" + message);
|
||||
ircBot.sendMessage(message);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
|
@ -354,7 +323,7 @@ public class EssentialsHelp extends PlayerListener
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private void sendStartup()
|
||||
{
|
||||
BufferedReader page = null;
|
||||
|
@ -375,7 +344,7 @@ public class EssentialsHelp extends PlayerListener
|
|||
FileInputStream fis = new FileInputStream(logFile);
|
||||
if (logFile.length() > 1000000)
|
||||
{
|
||||
fis.skip(logFile.length()-1000000);
|
||||
fis.skip(logFile.length() - 1000000);
|
||||
}
|
||||
page = new BufferedReader(new InputStreamReader(fis));
|
||||
final StringBuilder input = new StringBuilder();
|
||||
|
@ -385,28 +354,32 @@ public class EssentialsHelp extends PlayerListener
|
|||
boolean log = false;
|
||||
while ((line = page.readLine()) != null)
|
||||
{
|
||||
if (patternStart.matcher(line).matches()) {
|
||||
if (input.length() > 0) {
|
||||
if (patternStart.matcher(line).matches())
|
||||
{
|
||||
if (input.length() > 0)
|
||||
{
|
||||
input.delete(0, input.length());
|
||||
}
|
||||
log = true;
|
||||
}
|
||||
if (log) {
|
||||
if (log)
|
||||
{
|
||||
input.append(line).append("\n");
|
||||
}
|
||||
if (patternEnd.matcher(line).matches()) {
|
||||
if (patternEnd.matcher(line).matches())
|
||||
{
|
||||
log = false;
|
||||
}
|
||||
}
|
||||
if (input.length()>10000) {
|
||||
input.delete(0, input.length()-10000);
|
||||
if (input.length() > 10000)
|
||||
{
|
||||
input.delete(0, input.length() - 10000);
|
||||
}
|
||||
final PastieUpload pastie = new PastieUpload();
|
||||
final String url = pastie.send(input.toString());
|
||||
final Channel channel = (Channel)connection.getClientState().getChannels().nextElement();
|
||||
String message = "Startup: " + url;
|
||||
chatUser.sendMessage("§6" + connection.getClientState().getNick().getNick() + ": §7" + message);
|
||||
connection.sendCommand(new MessageCommand(channel.getName(), message));
|
||||
chatUser.sendMessage("§6" + ircBot.getNick() + ": §7" + message);
|
||||
ircBot.sendMessage(message);
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
|
@ -455,10 +428,9 @@ public class EssentialsHelp extends PlayerListener
|
|||
}
|
||||
final PastieUpload pastie = new PastieUpload();
|
||||
final String url = pastie.send(input.toString());
|
||||
final Channel channel = (Channel)connection.getClientState().getChannels().nextElement();
|
||||
String message = "Essentials config.yml: " + url;
|
||||
chatUser.sendMessage("§6" + connection.getClientState().getNick().getNick() + ": §7" + message);
|
||||
connection.sendCommand(new MessageCommand(channel.getName(), message));
|
||||
chatUser.sendMessage("§6" + ircBot.getNick() + ": §7" + message);
|
||||
ircBot.sendMessage(message);
|
||||
|
||||
}
|
||||
catch (IOException ex)
|
||||
|
@ -487,8 +459,8 @@ public class EssentialsHelp extends PlayerListener
|
|||
{
|
||||
if (event.getPlayer() == chatUser)
|
||||
{
|
||||
sendChatMessage(event.getPlayer(), event.getMessage());
|
||||
event.setCancelled(true);
|
||||
boolean success = sendChatMessage(event.getPlayer(), event.getMessage());
|
||||
event.setCancelled(success);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -497,105 +469,10 @@ public class EssentialsHelp extends PlayerListener
|
|||
public void onPlayerQuit(PlayerQuitEvent event)
|
||||
{
|
||||
chatUser = null;
|
||||
if (autoReconnect != null)
|
||||
{
|
||||
autoReconnect.disable();
|
||||
}
|
||||
shouldQuit = true;
|
||||
if (connection != null)
|
||||
{
|
||||
connection.sendCommand(new QuitCommand("Connection closed by user."));
|
||||
if (ircBot != null) {
|
||||
ircBot.quit();
|
||||
ircBot = null;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
class KickAutoJoin extends AutoJoin
|
||||
{
|
||||
private String channel;
|
||||
|
||||
public KickAutoJoin(IRCConnection connection, String channel)
|
||||
{
|
||||
super(connection, channel);
|
||||
this.channel = channel;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void updateCommand(InCommand command_o)
|
||||
{
|
||||
if (command_o instanceof KickCommand)
|
||||
{
|
||||
final KickCommand kickCommand = (KickCommand)command_o;
|
||||
|
||||
if (kickCommand.kickedUs(getConnection().getClientState()))
|
||||
{
|
||||
if (Channel.areEqual(kickCommand.getChannel(), channel))
|
||||
{
|
||||
chatUser.sendMessage("You have been kicked from the channel: " + kickCommand.getComment());
|
||||
chatUser = null;
|
||||
autoReconnect.disable();
|
||||
shouldQuit = true;
|
||||
connection.sendCommand(new QuitCommand("Connection closed by user."));
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (command_o instanceof GenericJoinError)
|
||||
{
|
||||
GenericJoinError joinErr = (GenericJoinError)command_o;
|
||||
|
||||
if (Channel.areEqual(joinErr.getChannel(), channel))
|
||||
{
|
||||
scheduleJoin();
|
||||
}
|
||||
}
|
||||
else if (command_o instanceof InviteCommand)
|
||||
{
|
||||
InviteCommand invite = (InviteCommand)command_o;
|
||||
if (!getConnection().getClientState().isOnChannel(invite.getChannel()))
|
||||
{
|
||||
performJoin();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class IRCListener extends GenericAutoService
|
||||
{
|
||||
public IRCListener(final IRCConnection connection)
|
||||
{
|
||||
super(connection);
|
||||
enable();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void updateState(final State state)
|
||||
{
|
||||
if (state == State.UNCONNECTED && shouldQuit)
|
||||
{
|
||||
connection = null;
|
||||
shouldQuit = false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void updateCommand(final InCommand command)
|
||||
{
|
||||
if (command instanceof MessageCommand)
|
||||
{
|
||||
final MessageCommand msg = (MessageCommand)command;
|
||||
EssentialsHelp.this.handleIRCmessage(msg.getSource().getNick(), msg.getMessage());
|
||||
}
|
||||
if (command instanceof TopicCommand)
|
||||
{
|
||||
final TopicCommand msg = (TopicCommand)command;
|
||||
EssentialsHelp.this.handleIRCmessage(msg.getChannel(), msg.getTopic());
|
||||
}
|
||||
if (command instanceof NoticeCommand)
|
||||
{
|
||||
final NoticeCommand msg = (NoticeCommand)command;
|
||||
EssentialsHelp.this.handleIRCmessage(msg.getFrom().getNick(), msg.getNotice());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
163
EssentialsUpdate/src/com/earth2me/essentials/update/IrcBot.java
Normal file
163
EssentialsUpdate/src/com/earth2me/essentials/update/IrcBot.java
Normal file
|
@ -0,0 +1,163 @@
|
|||
package com.earth2me.essentials.update;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Enumeration;
|
||||
import java.util.logging.Level;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.jibble.pircbot.Colors;
|
||||
import org.jibble.pircbot.IrcException;
|
||||
import org.jibble.pircbot.PircBot;
|
||||
import org.jibble.pircbot.User;
|
||||
|
||||
|
||||
public class IrcBot extends PircBot
|
||||
{
|
||||
private static final String channel = "#essentials";
|
||||
private static final int port = 6667;
|
||||
private static final String server = "irc.esper.net";
|
||||
private transient boolean reconnect = true;
|
||||
private transient Player player;
|
||||
private transient boolean kicked = false;
|
||||
|
||||
public IrcBot(Player player, final String nickName, final String versionString)
|
||||
{
|
||||
this.player = player;
|
||||
setName(nickName);
|
||||
setLogin("esshelp");
|
||||
setVersion(versionString);
|
||||
connect();
|
||||
joinChannel(channel);
|
||||
}
|
||||
|
||||
private void connect()
|
||||
{
|
||||
try
|
||||
{
|
||||
connect(server, port);
|
||||
return;
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
|
||||
}
|
||||
catch (IrcException ex)
|
||||
{
|
||||
Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void quit()
|
||||
{
|
||||
reconnect = false;
|
||||
disconnect();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onConnect()
|
||||
{
|
||||
reconnect = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onDisconnect()
|
||||
{
|
||||
super.onDisconnect();
|
||||
if (reconnect)
|
||||
{
|
||||
connect();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onKick(String channel, String kickerNick, String kickerLogin, String kickerHostname, String recipientNick, String reason)
|
||||
{
|
||||
if (recipientNick.equals(getNick()))
|
||||
{
|
||||
player.sendMessage("You have been kicked from the channel: " + reason);
|
||||
quit();
|
||||
kicked = true;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isKicked()
|
||||
{
|
||||
return kicked;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onMessage(String channel, String sender, String login, String hostname, String message)
|
||||
{
|
||||
player.sendMessage(formatChatMessage(sender, message, false));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onAction(String sender, String login, String hostname, String target, String action)
|
||||
{
|
||||
player.sendMessage(formatChatMessage(sender, action, true));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onNotice(String sourceNick, String sourceLogin, String sourceHostname, String target, String notice)
|
||||
{
|
||||
player.sendMessage(formatChatMessage(sourceNick, notice, false));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onTopic(String channel, String topic, String setBy, long date, boolean changed)
|
||||
{
|
||||
player.sendMessage(formatChatMessage(channel, topic, false));
|
||||
}
|
||||
|
||||
public String formatChatMessage(String nick, String message, boolean action)
|
||||
{
|
||||
final StringBuilder sb = new StringBuilder();
|
||||
sb.append("§6");
|
||||
if (action)
|
||||
{
|
||||
sb.append('*');
|
||||
}
|
||||
sb.append(nick);
|
||||
if (!action)
|
||||
{
|
||||
sb.append(':');
|
||||
}
|
||||
sb.append(" §7");
|
||||
sb.append(replaceColors(message));
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private String replaceColors(String message)
|
||||
{
|
||||
String m = Colors.removeFormatting(message);
|
||||
m = m.replaceAll("\u000310(,(0?[0-9]|1[0-5]))?", "§b");
|
||||
m = m.replaceAll("\u000311(,(0?[0-9]|1[0-5]))?", "§f");
|
||||
m = m.replaceAll("\u000312(,(0?[0-9]|1[0-5]))?", "§9");
|
||||
m = m.replaceAll("\u000313(,(0?[0-9]|1[0-5]))?", "§d");
|
||||
m = m.replaceAll("\u000314(,(0?[0-9]|1[0-5]))?", "§8");
|
||||
m = m.replaceAll("\u000315(,(0?[0-9]|1[0-5]))?", "§7");
|
||||
m = m.replaceAll("\u00030?1(,(0?[0-9]|1[0-5]))?", "§0");
|
||||
m = m.replaceAll("\u00030?2(,(0?[0-9]|1[0-5]))?", "§1");
|
||||
m = m.replaceAll("\u00030?3(,(0?[0-9]|1[0-5]))?", "§2");
|
||||
m = m.replaceAll("\u00030?4(,(0?[0-9]|1[0-5]))?", "§c");
|
||||
m = m.replaceAll("\u00030?5(,(0?[0-9]|1[0-5]))?", "§4");
|
||||
m = m.replaceAll("\u00030?6(,(0?[0-9]|1[0-5]))?", "§5");
|
||||
m = m.replaceAll("\u00030?7(,(0?[0-9]|1[0-5]))?", "§6");
|
||||
m = m.replaceAll("\u00030?8(,(0?[0-9]|1[0-5]))?", "§e");
|
||||
m = m.replaceAll("\u00030?9(,(0?[0-9]|1[0-5]))?", "§a");
|
||||
m = m.replaceAll("\u00030?0(,(0?[0-9]|1[0-5]))?", "§f");
|
||||
m = Colors.removeColors(m);
|
||||
return m;
|
||||
}
|
||||
|
||||
public void sendMessage(String message)
|
||||
{
|
||||
sendMessage(channel, message);
|
||||
}
|
||||
|
||||
public User[] getUsers()
|
||||
{
|
||||
return getUsers(channel);
|
||||
}
|
||||
}
|
|
@ -1,67 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* ClientStateMonitor asks commands to update the client state.
|
||||
*/
|
||||
public class ClientStateMonitor implements Observer
|
||||
{
|
||||
|
||||
static Logger log = Logger.getLogger(ClientStateMonitor.class.getName());
|
||||
|
||||
private IRCConnection connection;
|
||||
|
||||
private boolean enabled = false;
|
||||
|
||||
/**
|
||||
* This should only be called by the IRCConnection itself.
|
||||
*
|
||||
* @param connection Connection we are associated with
|
||||
*/
|
||||
ClientStateMonitor( IRCConnection connection )
|
||||
{
|
||||
this.connection = connection;
|
||||
|
||||
enable();
|
||||
}
|
||||
|
||||
public void enable()
|
||||
{
|
||||
if( enabled )
|
||||
return;
|
||||
enabled = true;
|
||||
|
||||
connection.addCommandObserver( this );
|
||||
}
|
||||
|
||||
public void disable()
|
||||
{
|
||||
if( !enabled )
|
||||
return;
|
||||
connection.removeCommandObserver( this );
|
||||
enabled = false;
|
||||
}
|
||||
|
||||
public void update( Observable observable, Object command_o )
|
||||
{
|
||||
InCommand command = (InCommand)command_o;
|
||||
|
||||
try
|
||||
{
|
||||
/*if( */command.updateClientState( connection.getClientState() );// )
|
||||
//log.debug("ClientStateMonnitor: Client state updated");
|
||||
}
|
||||
catch( Throwable e )
|
||||
{
|
||||
log.log(Level.SEVERE,"ClientStateMonitor: Client state update failed.", e);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// ===== END ClientStateMonitor
|
||||
}
|
||||
|
|
@ -1,18 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* Defines an object which is a command, either incoming or outgoing.
|
||||
*/
|
||||
public interface Command
|
||||
{
|
||||
/**
|
||||
* Returns the string IRC uses to identify this command. Examples:
|
||||
* NICK, PING, KILL, 332. Not strictly required for OutCommands
|
||||
* as the irc identifier is expected to be part of the reder()
|
||||
* result.
|
||||
*
|
||||
* @return The IRC identifier string
|
||||
*/
|
||||
String getIrcIdentifier();
|
||||
}
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
public class CommandObserver extends StateObserver
|
||||
{
|
||||
}
|
|
@ -1,118 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Hashtable;
|
||||
|
||||
import f00f.net.irc.martyr.commands.*;
|
||||
import f00f.net.irc.martyr.errors.*;
|
||||
import f00f.net.irc.martyr.replies.*;
|
||||
|
||||
/**
|
||||
* CommandRegister is basically a big hashtable that maps IRC
|
||||
* identifiers to command objects that can be used as factories to
|
||||
* do self-parsing. CommandRegister is also the central list of
|
||||
* commands.
|
||||
*/
|
||||
public class CommandRegister
|
||||
{
|
||||
|
||||
private Hashtable<String,InCommand> commands;
|
||||
public CommandRegister()
|
||||
{
|
||||
commands = new Hashtable<String,InCommand>();
|
||||
|
||||
// Note that currently, we only have to register commands that
|
||||
// can be received from the server.
|
||||
new InviteCommand().selfRegister( this );
|
||||
new JoinCommand().selfRegister( this );
|
||||
new KickCommand().selfRegister( this );
|
||||
new MessageCommand().selfRegister( this );
|
||||
new ModeCommand().selfRegister( this );
|
||||
new IsonCommand().selfRegister( this );
|
||||
new NickCommand().selfRegister( this );
|
||||
new NoticeCommand().selfRegister( this );
|
||||
new PartCommand().selfRegister( this );
|
||||
new PingCommand().selfRegister( this );
|
||||
new QuitCommand().selfRegister( this );
|
||||
new TopicCommand().selfRegister( this );
|
||||
new WelcomeCommand().selfRegister( this );
|
||||
|
||||
// Register errors
|
||||
new AlreadyRegisteredError().selfRegister( this );
|
||||
new CannotSendToChanError().selfRegister( this );
|
||||
new CantKillServerError().selfRegister( this );
|
||||
new ChannelBannedError().selfRegister( this );
|
||||
new ChannelInviteOnlyError().selfRegister( this );
|
||||
new ChannelLimitError().selfRegister( this );
|
||||
new ChannelWrongKeyError().selfRegister( this );
|
||||
new ChanOPrivsNeededError().selfRegister( this );
|
||||
new ErroneusNicknameError().selfRegister( this );
|
||||
new FileErrorError().selfRegister( this );
|
||||
new KeySetError().selfRegister( this );
|
||||
new LoadTooHighError().selfRegister( this );
|
||||
new NeedMoreParamsError().selfRegister( this );
|
||||
new NickCollisionError().selfRegister( this );
|
||||
new NickInUseError().selfRegister( this );
|
||||
new NoAdminInfoError().selfRegister( this );
|
||||
new NoLoginError().selfRegister( this );
|
||||
new NoMotdError().selfRegister( this );
|
||||
new NoNicknameGivenError().selfRegister( this );
|
||||
new NoOperHostError().selfRegister( this );
|
||||
new NoOriginError().selfRegister( this );
|
||||
new NoPermForHostError().selfRegister( this );
|
||||
new NoPrivilegesError().selfRegister( this );
|
||||
new NoRecipientError().selfRegister( this );
|
||||
new NoSuchChannelError().selfRegister( this );
|
||||
new NoSuchNickError().selfRegister( this );
|
||||
new NoSuchServerError().selfRegister( this );
|
||||
new NoTextToSendError().selfRegister( this );
|
||||
new NotOnChannelError().selfRegister( this );
|
||||
new NotRegisteredError().selfRegister( this );
|
||||
new PasswdMismatchError().selfRegister( this );
|
||||
new SummonDisabledError().selfRegister( this );
|
||||
new TooManyChannelsError().selfRegister( this );
|
||||
new TooManyTargetsError().selfRegister( this );
|
||||
new UModeUnknownFlagError().selfRegister( this );
|
||||
new UnknownCommandError().selfRegister( this );
|
||||
new UnknownModeError().selfRegister( this );
|
||||
new UserNotInChannelError().selfRegister( this );
|
||||
new UserOnChannelError().selfRegister( this );
|
||||
new UsersDisabledError().selfRegister( this );
|
||||
new UsersDontMatchError().selfRegister( this );
|
||||
new WasNoSuchNickError().selfRegister( this );
|
||||
new WildTopLevelError().selfRegister( this );
|
||||
new YoureBannedCreepError().selfRegister( this );
|
||||
|
||||
// Register replies
|
||||
new ChannelCreationReply().selfRegister( this );
|
||||
new AwayReply().selfRegister( this );
|
||||
new ListEndReply().selfRegister( this );
|
||||
new ListReply().selfRegister( this );
|
||||
new ListStartReply().selfRegister( this );
|
||||
new LUserClientReply().selfRegister( this );
|
||||
new LUserMeReply().selfRegister( this );
|
||||
new LUserOpReply().selfRegister( this );
|
||||
new ModeReply().selfRegister( this );
|
||||
new NamesEndReply().selfRegister( this );
|
||||
new NamesReply().selfRegister( this );
|
||||
new NowAwayReply().selfRegister( this );
|
||||
new TopicInfoReply().selfRegister( this );
|
||||
new UnAwayReply().selfRegister( this );
|
||||
new WhoisChannelsReply().selfRegister( this );
|
||||
new WhoisEndReply().selfRegister( this );
|
||||
new WhoisIdleReply().selfRegister( this );
|
||||
new WhoisServerReply().selfRegister( this );
|
||||
new WhoisUserReply().selfRegister( this );
|
||||
}
|
||||
|
||||
public void addCommand( String ident, InCommand command )
|
||||
{
|
||||
commands.put( ident, command );
|
||||
}
|
||||
|
||||
public InCommand getCommand( String ident )
|
||||
{
|
||||
return commands.get( ident );
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* A CommandSender can accept an OutCommand and do something with it
|
||||
* (such as send it to the server, or send it on to another
|
||||
* CommandSender). The idea is to create a chain of CommandSenders,
|
||||
* with the last object in the chain the default CommandSender,
|
||||
* created by IRCConnection.
|
||||
* */
|
||||
public interface CommandSender
|
||||
{
|
||||
CommandSender getNextCommandSender();
|
||||
void sendCommand( OutCommand command );
|
||||
}
|
|
@ -1,80 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.Timer;
|
||||
import java.util.TimerTask;
|
||||
|
||||
/**
|
||||
* @since 0.3.2
|
||||
* */
|
||||
public class CronManager
|
||||
{
|
||||
private Timer timer;
|
||||
|
||||
public CronManager()
|
||||
{
|
||||
timer = new Timer();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param time When to schedule task
|
||||
*/
|
||||
public void schedule(TimerTask task, Date time)
|
||||
{
|
||||
timer.schedule(task, time);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param firstTime When to run first
|
||||
* @param period How often to run
|
||||
*/
|
||||
public void schedule(TimerTask task, Date firstTime, long period)
|
||||
{
|
||||
timer.schedule(task, firstTime, period);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param delay How long to wait before running
|
||||
*/
|
||||
public void schedule(TimerTask task, long delay)
|
||||
{
|
||||
timer.schedule(task, delay);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param delay How long to wait before running
|
||||
* @param period How often to run
|
||||
*/
|
||||
public void schedule(TimerTask task, long delay, long period)
|
||||
{
|
||||
timer.schedule(task, delay, period);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param firstTime When first to run
|
||||
* @param period How often to run
|
||||
*/
|
||||
public void scheduleAtFixedRate(
|
||||
TimerTask task,
|
||||
Date firstTime,
|
||||
long period)
|
||||
{
|
||||
timer.scheduleAtFixedRate(task, firstTime, period);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param task TimerTask to schedule
|
||||
* @param delay When first to run
|
||||
* @param period How often to run
|
||||
*/
|
||||
public void scheduleAtFixedRate(TimerTask task, long delay, long period)
|
||||
{
|
||||
timer.scheduleAtFixedRate(task, delay, period);
|
||||
}
|
||||
|
||||
}
|
|
@ -1,66 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Observer;
|
||||
import java.util.Observable;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Does notifications in the order they are added.
|
||||
* */
|
||||
public class ForwardObservable extends Observable
|
||||
{
|
||||
private boolean changed = true;
|
||||
private List<Observer> obs = new LinkedList<Observer>();
|
||||
private final Object localMonitor = new Object();
|
||||
|
||||
|
||||
public void setChanged()
|
||||
{
|
||||
synchronized(localMonitor)
|
||||
{
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
|
||||
protected void clearChanged()
|
||||
{
|
||||
synchronized(localMonitor)
|
||||
{
|
||||
changed = false;
|
||||
}
|
||||
}
|
||||
|
||||
public void addObserver( Observer o )
|
||||
{
|
||||
synchronized(localMonitor)
|
||||
{
|
||||
obs.add( o );
|
||||
}
|
||||
}
|
||||
|
||||
public void deleteObserver( Observer o )
|
||||
{
|
||||
synchronized(localMonitor)
|
||||
{
|
||||
obs.remove( o );
|
||||
}
|
||||
}
|
||||
|
||||
public void notifyObservers(Object arg)
|
||||
{
|
||||
synchronized(localMonitor)
|
||||
{
|
||||
if (!changed)
|
||||
return;
|
||||
clearChanged();
|
||||
|
||||
for (Observer ob : obs) {
|
||||
ob.update(this, arg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Observable;
|
||||
|
||||
/**
|
||||
* Provides a framework for an auto service. Does enable by default.
|
||||
* Splits the 'update' method into two, 'updateState' and 'updateCommand'.
|
||||
* Also provides thread safety on all methods.
|
||||
*/
|
||||
public abstract class GenericAutoService extends GenericCommandAutoService
|
||||
{
|
||||
|
||||
protected GenericAutoService( IRCConnection connection )
|
||||
{
|
||||
super( connection );
|
||||
}
|
||||
|
||||
public synchronized void enable()
|
||||
{
|
||||
if( enabled )
|
||||
return;
|
||||
|
||||
connection.addStateObserver( this );
|
||||
|
||||
super.enable();
|
||||
}
|
||||
|
||||
public synchronized void disable()
|
||||
{
|
||||
if( !enabled )
|
||||
return;
|
||||
|
||||
connection.removeStateObserver( this );
|
||||
|
||||
super.disable();
|
||||
}
|
||||
|
||||
public synchronized void update( Observable observer, Object updated )
|
||||
{
|
||||
if( !enabled )
|
||||
throw new IllegalStateException("This observer is not enabled." );
|
||||
if( updated instanceof State )
|
||||
updateState( (State)updated );
|
||||
else
|
||||
super.update( observer, updated );
|
||||
}
|
||||
|
||||
protected abstract void updateState( State state );
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
|
||||
/**
|
||||
* Provides a framework for an auto service that operates with
|
||||
* InCommands. Does enable by default. Splits the 'update' method
|
||||
* into two, 'updateState' and 'updateCommand'. Also provides thread
|
||||
* safety on all methods.
|
||||
*/
|
||||
public abstract class GenericCommandAutoService implements Observer
|
||||
{
|
||||
|
||||
protected boolean enabled = false;
|
||||
protected IRCConnection connection;
|
||||
|
||||
protected GenericCommandAutoService( IRCConnection connection )
|
||||
{
|
||||
this.connection = connection;
|
||||
|
||||
enable();
|
||||
}
|
||||
|
||||
public synchronized void enable()
|
||||
{
|
||||
if( enabled )
|
||||
return;
|
||||
|
||||
connection.addCommandObserver( this );
|
||||
enabled = true;
|
||||
}
|
||||
|
||||
public synchronized void disable()
|
||||
{
|
||||
if( !enabled )
|
||||
return;
|
||||
|
||||
connection.removeCommandObserver( this );
|
||||
enabled = false;
|
||||
}
|
||||
|
||||
public synchronized void update( Observable observer, Object updated )
|
||||
{
|
||||
if( !enabled )
|
||||
throw new IllegalStateException("This observer is not enabled." );
|
||||
if( updated instanceof State )
|
||||
{
|
||||
throw new IllegalArgumentException("This is not a state observer." );
|
||||
}
|
||||
else if( updated instanceof InCommand )
|
||||
{
|
||||
updateCommand( (InCommand)updated );
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new IllegalArgumentException("Unknown object given to update.");
|
||||
}
|
||||
}
|
||||
|
||||
protected IRCConnection getConnection()
|
||||
{
|
||||
return connection;
|
||||
}
|
||||
|
||||
protected synchronized boolean isEnabled()
|
||||
{
|
||||
return enabled;
|
||||
}
|
||||
|
||||
protected abstract void updateCommand( InCommand command );
|
||||
|
||||
|
||||
// END AutoRegister
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -1,99 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.Iterator;
|
||||
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
|
||||
/**
|
||||
* Defines commands that come from the server. Errors and replies are
|
||||
* incoming commands.
|
||||
*
|
||||
* @see f00f.net.irc.martyr.errors.GenericError
|
||||
* @see f00f.net.irc.martyr.replies.GenericReply
|
||||
*/
|
||||
public interface InCommand extends Command
|
||||
{
|
||||
|
||||
/**
|
||||
* Some commands, when received by the server, can only occur in one
|
||||
* state. Thus, when this command is received, the protocol should
|
||||
* assume that it is in that state, and a state change may be
|
||||
* triggered. A command can use the 'unknown' state to indicate it
|
||||
* can be received in any state (for example, ping).
|
||||
*
|
||||
* @return State associated with command
|
||||
*/
|
||||
State getState();
|
||||
|
||||
/**
|
||||
* Every incoming command should know how to register itself with the
|
||||
* command register.
|
||||
*
|
||||
* @param commandRegister Command register we want to register with
|
||||
*/
|
||||
void selfRegister( CommandRegister commandRegister );
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object. The
|
||||
* identifier is usually ignored, except in the special case where
|
||||
* commands can be identified by multiple identifiers. In that case,
|
||||
* the behaviour of the command may change in sublte ways.
|
||||
*
|
||||
* @param prefix Prefix of the command
|
||||
* @param identifier ID of the command
|
||||
* @param params Parameters of the command
|
||||
* @return InCommand instance for parsed command
|
||||
*/
|
||||
InCommand parse( String prefix, String identifier, String params );
|
||||
|
||||
/**
|
||||
* Gives the command a copy of the raw string from the server. Called
|
||||
* by IRCConnection after the command is parsed.
|
||||
*
|
||||
* @param str Sets the source string to be parsed
|
||||
*/
|
||||
void setSourceString( String str );
|
||||
|
||||
/**
|
||||
* Allows a third party to receive a copy of the raw string.
|
||||
*
|
||||
* @return The original source string from the server
|
||||
*/
|
||||
String getSourceString();
|
||||
|
||||
/**
|
||||
* Asks the command to ensure that information it knows about the
|
||||
* state the server thinks the client is in matches what we have.
|
||||
* Returns true if state changes were made.
|
||||
*
|
||||
* @param state Client state to be updated
|
||||
* @return True or false if changes were made
|
||||
*/
|
||||
boolean updateClientState( ClientState state );
|
||||
|
||||
|
||||
/**
|
||||
* Returns an iterator of String objects over the attribute names
|
||||
* for this command. Warning: Still new, support for this is not
|
||||
* yet widespread. Should return all possible attribute keys, not just
|
||||
* those that have a value in the current context.
|
||||
*
|
||||
* @return Iterator of attribute keys
|
||||
*/
|
||||
Iterator getAttributeKeys();
|
||||
|
||||
/**
|
||||
* Returns the attribute, or null if the attribute does not exist,
|
||||
* or is not defined.
|
||||
*
|
||||
* @param key Attribute to get value of
|
||||
* @return Attribute value or null if attribute doesn't exist
|
||||
*/
|
||||
String getAttribute( String key );
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.LinkedList;
|
||||
import java.io.BufferedReader;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* A simple class to help manage input from the stream.
|
||||
*/
|
||||
public class InputHandler extends Thread
|
||||
{
|
||||
//static Logger log = Logger.getLogger(InputHandler.class);
|
||||
|
||||
private BufferedReader reader;
|
||||
private IRCConnection connection;
|
||||
private final LinkedList<String> messages;
|
||||
|
||||
private final Object eventMonitor;
|
||||
|
||||
private static int serialGen = 0;
|
||||
private int serialNumber = serialGen++;
|
||||
private boolean doShutdown = false;
|
||||
|
||||
public InputHandler( BufferedReader reader,
|
||||
IRCConnection connection,
|
||||
Object eventMonitor )
|
||||
{
|
||||
|
||||
super("InputHandler");
|
||||
this.reader = reader;
|
||||
this.connection = connection;
|
||||
messages = new LinkedList<String>();
|
||||
this.eventMonitor = eventMonitor;
|
||||
|
||||
//log.debug("IRCConnection: New");
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the shutdown flag, so that after next read, or on any error, the thread will just exit.
|
||||
*/
|
||||
public void signalShutdown()
|
||||
{
|
||||
synchronized(this)
|
||||
{
|
||||
doShutdown = true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if there are messages waiting to be processed.
|
||||
*/
|
||||
public boolean pendingMessages()
|
||||
{
|
||||
synchronized( messages )
|
||||
{
|
||||
return ! messages.isEmpty();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the message at the top of the message queue and removes it from the
|
||||
* message queue.
|
||||
*
|
||||
* @return Message from top of list.
|
||||
*/
|
||||
public String getMessage()
|
||||
{
|
||||
synchronized( messages )
|
||||
{
|
||||
return messages.removeFirst();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Waits for input from the server. When input arrives, it is added to a
|
||||
* queue and eventMonitor.notifyAll() is called.
|
||||
*/
|
||||
public void run()
|
||||
{
|
||||
//log.debug("IRCConnection: Running");
|
||||
try{
|
||||
|
||||
String str;
|
||||
while( true )
|
||||
{
|
||||
synchronized(this)
|
||||
{
|
||||
if( doShutdown )
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
str = reader.readLine();
|
||||
if( str == null )
|
||||
{
|
||||
connection.socketError( new IOException( "Socket disconnected" ) );
|
||||
return;
|
||||
}
|
||||
synchronized( messages )
|
||||
{
|
||||
messages.addLast( str );
|
||||
}
|
||||
synchronized( eventMonitor )
|
||||
{
|
||||
eventMonitor.notifyAll();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch( IOException ioe )
|
||||
{
|
||||
if( doShutdown )
|
||||
{
|
||||
return;
|
||||
}
|
||||
connection.socketError( ioe );
|
||||
}
|
||||
finally
|
||||
{
|
||||
//log.debug("IRCConnection: Input handler has DIED!");
|
||||
}
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return "InputHandler[" + serialNumber + "]";
|
||||
}
|
||||
|
||||
// ----- END InputHandler --------------------------------------------
|
||||
}
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* Any class which is to represent a mode must implement this
|
||||
* interface. They must also implement equals(...) so that if the
|
||||
* parameter for either mode is null they are equal based on the
|
||||
* character, and if both parameters are not null, base the equal
|
||||
* on the character and the parameters being equal.
|
||||
*/
|
||||
public interface Mode
|
||||
{
|
||||
/**
|
||||
* A Mode can be constructed and asked to make copies of itself.
|
||||
*
|
||||
* @return New Mode instance
|
||||
*/
|
||||
Mode newInstance();
|
||||
|
||||
/**
|
||||
* The character that represents this mode (ie o for operator)
|
||||
*
|
||||
* @return Character representation of mode
|
||||
*/
|
||||
char getChar();
|
||||
|
||||
/**
|
||||
* Should return true if this mode requires a parameter.
|
||||
*
|
||||
* @return True or false if a param is required for mode
|
||||
*/
|
||||
boolean requiresParam();
|
||||
|
||||
/**
|
||||
* This mode should be recorded in the list of channel modes. This
|
||||
* would NOT include such things as operator status, as it is recored
|
||||
* with the Member object.
|
||||
*
|
||||
* @return True or false of the mode should be recorded in the list of channels
|
||||
*/
|
||||
boolean recordInChannel();
|
||||
|
||||
/**
|
||||
* Determines if there can be multiple versions of this mode in
|
||||
* the channel.
|
||||
*
|
||||
* @return True or false if only one instance of mode can exist per channel
|
||||
*/
|
||||
boolean onePerChannel();
|
||||
|
||||
/**
|
||||
* Returns the parameter that was set with setParam(...)
|
||||
*
|
||||
* @return Parameter that was set previously
|
||||
*/
|
||||
String getParam();
|
||||
|
||||
/**
|
||||
* Sets the parameter that can be retrieved with getParam()
|
||||
*
|
||||
* @param str Parameter to set on mode
|
||||
*/
|
||||
void setParam( String str );
|
||||
|
||||
/**
|
||||
* Sets the sign of the operation. Must be positive (granting),
|
||||
* negative (revoking) or nosign (neutral operation).
|
||||
*
|
||||
* @param sign Sign (+/-) of the mode
|
||||
*/
|
||||
void setSign( Sign sign );
|
||||
|
||||
/**
|
||||
* @return the sign of this mode.
|
||||
*/
|
||||
Sign getSign();
|
||||
|
||||
/**
|
||||
* Finally, the Sign enumeration.
|
||||
*/
|
||||
public class Sign
|
||||
{
|
||||
public static final Sign POSITIVE = new Sign( "positive" );
|
||||
public static final Sign NEGATIVE = new Sign( "negative" );
|
||||
public static final Sign NOSIGN = new Sign( "nosign" );
|
||||
|
||||
private String name;
|
||||
private Sign( String name )
|
||||
{
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* Defines an outgoing command. Outgoing commands are very simple
|
||||
* because all they need to do is be rendered. Outgoing commands do
|
||||
* not change our state.
|
||||
*/
|
||||
public interface OutCommand extends Command
|
||||
{
|
||||
|
||||
/**
|
||||
* Forms a string appropriate to send to the server, if required.
|
||||
* Some commands will have no such string, as they are received and not
|
||||
* sent. The string returned is sent to the server verbatim.
|
||||
*
|
||||
* @return Rendered string
|
||||
*/
|
||||
String render();
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* A simple container for state constants. The state constants here
|
||||
* are used to specify what state the protocol is in. The State
|
||||
* object is both the state representitive and the state container.
|
||||
* This was done so that state could be typesafe and valuesafe.
|
||||
*
|
||||
*/
|
||||
public class State
|
||||
{
|
||||
|
||||
public static final State UNCONNECTED = new State("unconnected");
|
||||
public static final State UNREGISTERED = new State("unregistered");
|
||||
public static final State REGISTERED = new State("registered");
|
||||
public static final State UNKNOWN = new State("unknown/any");
|
||||
|
||||
private String stateName;
|
||||
|
||||
private State( String str )
|
||||
{
|
||||
stateName = str;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return stateName;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
/**
|
||||
* Should the state and state observer be one?
|
||||
*/
|
||||
public class StateObserver extends ForwardObservable
|
||||
{
|
||||
}
|
|
@ -1,57 +0,0 @@
|
|||
package f00f.net.irc.martyr;
|
||||
|
||||
import java.util.TimerTask;
|
||||
|
||||
// TODO: BD: Unit test
|
||||
// TODO: BD: synchronization semantics?
|
||||
|
||||
/**
|
||||
* This class delays sending a command to the IRC connection.
|
||||
*
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
*/
|
||||
public class TimerTaskCommand extends TimerTask
|
||||
{
|
||||
|
||||
private IRCConnection _conn;
|
||||
private OutCommand _cmd;
|
||||
public TimerTaskCommand(IRCConnection conn, OutCommand cmd)
|
||||
{
|
||||
_conn = conn;
|
||||
_cmd = cmd;
|
||||
}
|
||||
/* (non-Javadoc)
|
||||
* @see java.util.TimerTask#run()
|
||||
*/
|
||||
public synchronized void run()
|
||||
{
|
||||
if( !isScheduled )
|
||||
return;
|
||||
|
||||
_conn.sendCommand(_cmd);
|
||||
isScheduled = false;
|
||||
}
|
||||
|
||||
private boolean isScheduled = true;
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see java.util.TimerTask#cancel()
|
||||
*/
|
||||
public synchronized boolean cancel()
|
||||
{
|
||||
boolean ret = super.cancel();
|
||||
isScheduled = false;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return true if the command has yet to run or is running, false
|
||||
* otherwise.
|
||||
*/
|
||||
public synchronized boolean isScheduled()
|
||||
{
|
||||
return isScheduled;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,373 +0,0 @@
|
|||
package f00f.net.irc.martyr.clientstate;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.Enumeration;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Vector;
|
||||
|
||||
import f00f.net.irc.martyr.Command;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
import f00f.net.irc.martyr.modes.channel.OperMode;
|
||||
import f00f.net.irc.martyr.modes.channel.VoiceMode;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
//import org.apache.log4j.Logger;
|
||||
|
||||
/**
|
||||
* Channel is simply a repository for information about a channel.
|
||||
* Contains channel name, topic, who created the topic, when the topic
|
||||
* was created, who is in the channel, mode, etc.
|
||||
*
|
||||
* <p>If a user of the framework wishes to use their own Member object
|
||||
* (to trap events like setting/removing ops), then subclass
|
||||
* Channel and add a method as follows.</p>
|
||||
*
|
||||
* <pre>
|
||||
* public Member makeMember( String member )
|
||||
* {
|
||||
* return MyMemberSubClass( member ) );
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* <p>Each of the methods in Channel that need to create a Member
|
||||
* object (many are just temporary members, for the enhanced 'equals')
|
||||
* calls makeMember instead of new Member(...). That is why this
|
||||
* version of addMember is protected, so that a part of the framework
|
||||
* won't do something silly like:</p>
|
||||
*
|
||||
* <pre>
|
||||
* ...
|
||||
* channel.addMember( new Member( member ) );
|
||||
* ...
|
||||
* </pre>
|
||||
*/
|
||||
public class Channel
|
||||
{
|
||||
|
||||
//static Logger log = Logger.getLogger(Channel.class);
|
||||
|
||||
private String name = null;
|
||||
private String topic = null;
|
||||
private String topicAuthor = null;
|
||||
private Date topicDate = null;
|
||||
private Date creationDate = null;
|
||||
|
||||
private List<Mode> modes = null;
|
||||
|
||||
/**
|
||||
* Hopefully we can replace this with a more useful data structure.
|
||||
* This is a vector of Member objects.
|
||||
*/
|
||||
private Vector<Member> members;
|
||||
|
||||
public Channel( String chanName )
|
||||
{
|
||||
this.name = chanName;
|
||||
members = new Vector<Member>();
|
||||
modes = new LinkedList<Mode>();
|
||||
}
|
||||
|
||||
public String getName()
|
||||
{
|
||||
return name;
|
||||
}
|
||||
|
||||
protected void addMember( Member member )
|
||||
{
|
||||
members.addElement( member );
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the member to the channel.
|
||||
*
|
||||
* @param member Member to add to the channel
|
||||
* @param why Command that caused the member to be added
|
||||
* @deprecated Use <code>addMember( String, InCommand )</code>
|
||||
* instead.
|
||||
*/
|
||||
public void addMember( String member, Command why )
|
||||
{
|
||||
addMember( makeMember( member ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the member to the channel.
|
||||
*
|
||||
* @param member Nick to add to the channel
|
||||
* @param why Command that caused the member to be added
|
||||
*/
|
||||
public void addMember( String member, InCommand why )
|
||||
{
|
||||
addMember( makeMember( member ) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param nick Nick to add to the channel
|
||||
* @param why Command that caused the member to be added
|
||||
* @deprecated Use <code>addMember( FullNick, InCommand )</code> intead.
|
||||
*/
|
||||
public void addMember( FullNick nick, Command why )
|
||||
{
|
||||
addMember( makeMember( nick.getNick() ));
|
||||
}
|
||||
|
||||
/**
|
||||
* @param nick Nick to add to the channel
|
||||
* @param why Command that caused the member to be added
|
||||
* Adds the member to the channel. Just calls nick.getNick().
|
||||
*/
|
||||
public void addMember( FullNick nick, InCommand why )
|
||||
{
|
||||
addMember( nick.getNick(), why );
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the user from the channel. Ignores leading @ or + symbols.
|
||||
* This is the cononical version of removeMember.
|
||||
* @param member Nick of the person leaving.
|
||||
* @param why Command issed that caused this action.
|
||||
*/
|
||||
public void removeMember( String member, InCommand why )
|
||||
{
|
||||
removeMember( makeMember( member ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* @param member Nick to remove from channel
|
||||
* @param why Command that caused removal
|
||||
* @deprecated Use <code>removeMember( String, InCommand ) instead.</code>
|
||||
* */
|
||||
public void removeMember( String member, Command why )
|
||||
{
|
||||
removeMember( makeMember( member ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* @param member Member to remove from channel
|
||||
* @param why Command that caused removal
|
||||
* @deprecated Use <code>removeMember( FullNick, InCommand ) instead.</code>
|
||||
* */
|
||||
public void removeMember( FullNick member, Command why )
|
||||
{
|
||||
removeMember( member, (InCommand)why );
|
||||
}
|
||||
|
||||
/**
|
||||
* Simply a wrapper to allow FullNicks to be used. Calls the string
|
||||
* version of removeMember with nick.getNick().
|
||||
*
|
||||
* @param nick Nick to remove from channel
|
||||
* @param why Command that caused removal
|
||||
*/
|
||||
public void removeMember( FullNick nick, InCommand why )
|
||||
{
|
||||
removeMember( nick.getNick(), why );
|
||||
}
|
||||
|
||||
protected void removeMember( Member compareTo )
|
||||
{
|
||||
for( int i = 0; i < members.size(); ++i )
|
||||
{
|
||||
if( (members.elementAt( i )).equals( compareTo ) )
|
||||
{
|
||||
members.removeElementAt( i );
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Informs the channel of a mode change. A mode change might be for the
|
||||
* channel (such as l, n, or t) or for a user on this channel (such as
|
||||
* o).
|
||||
*
|
||||
* @param mode Mode to set on the channel
|
||||
*/
|
||||
public void setMode( Mode mode )
|
||||
{
|
||||
// Note that Modes are supposed to be equal if the character is
|
||||
// equal. Thus, we can remove a mode from the set, even though it
|
||||
// is different because its sign or parameters may be different.
|
||||
if( mode.onePerChannel() && modes.contains( mode ) )
|
||||
{
|
||||
modes.remove( mode );
|
||||
}
|
||||
|
||||
if( (mode.getSign() != Mode.Sign.NEGATIVE) && mode.recordInChannel() )
|
||||
{
|
||||
modes.add( mode );
|
||||
}
|
||||
|
||||
if( mode instanceof OperMode )
|
||||
{
|
||||
OperMode oMode = (OperMode)mode;
|
||||
Member member = findMember( oMode.getParam() );
|
||||
|
||||
member.setOps( oMode.getSign() == Mode.Sign.POSITIVE );
|
||||
}
|
||||
else if( mode instanceof VoiceMode )
|
||||
{
|
||||
VoiceMode vMode = (VoiceMode)mode;
|
||||
Member member = findMember( vMode.getParam() );
|
||||
|
||||
member.setVoice( vMode.getSign() == Mode.Sign.POSITIVE );
|
||||
}
|
||||
}
|
||||
|
||||
public Iterator getModes()
|
||||
{
|
||||
return modes.iterator();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an enumeration of Member objects, in no particular order.
|
||||
*
|
||||
* @return List of members in the channel
|
||||
*/
|
||||
public Enumeration getMembers()
|
||||
{
|
||||
return members.elements();
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the nick is in the channel. Nick can be in the form
|
||||
* "@sork" or "+sork" or just "sork", for example.
|
||||
*
|
||||
* @param nick Nick of member to check
|
||||
* @return True or false if the member is in this channel.
|
||||
*/
|
||||
public boolean isMemberInChannel( String nick )
|
||||
{
|
||||
return isMemberInChannel( makeMember( nick ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the member is in this channel.
|
||||
*
|
||||
* @param member Member to check
|
||||
* @return True or false if the member is in this channel.
|
||||
*/
|
||||
protected boolean isMemberInChannel( Member member )
|
||||
{
|
||||
return findMember( member ) != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the Member object associated with a specific nick. Ignores
|
||||
* prefixed + or @.
|
||||
*
|
||||
* @param nick Nick to check whether it's a member of the channel or not
|
||||
* @return Member object for specified nick, if it exists (null if not)
|
||||
*/
|
||||
public Member findMember( String nick )
|
||||
{
|
||||
return findMember( makeMember( nick ) );
|
||||
}
|
||||
|
||||
protected Member findMember( Member member )
|
||||
{
|
||||
Enumeration membersE = getMembers();
|
||||
while( membersE.hasMoreElements() )
|
||||
{
|
||||
Member memberCompare = (Member)membersE.nextElement();
|
||||
|
||||
if( memberCompare.equals( member ) )
|
||||
{
|
||||
return memberCompare;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public void setTopic( String topic )
|
||||
{
|
||||
//log.debug(getName()+": Topic: " + topic);
|
||||
this.topic = topic;
|
||||
}
|
||||
|
||||
public String getTopic()
|
||||
{
|
||||
return topic;
|
||||
}
|
||||
|
||||
public Date getTopicDate()
|
||||
{
|
||||
return topicDate;
|
||||
}
|
||||
|
||||
public void setTopicDate( Date date )
|
||||
{
|
||||
//log.debug(getName()+": Topic date: " + date);
|
||||
this.topicDate = date;
|
||||
}
|
||||
|
||||
public Date getCreationDate()
|
||||
{
|
||||
return creationDate;
|
||||
}
|
||||
|
||||
public void setCreationDate( Date date )
|
||||
{
|
||||
//log.debug(getName()+": Creation date: " + date);
|
||||
this.creationDate = date;
|
||||
}
|
||||
|
||||
public String getTopicAuthor()
|
||||
{
|
||||
return topicAuthor;
|
||||
}
|
||||
|
||||
public void setTopicAuthor( String author )
|
||||
{
|
||||
//log.debug(getName()+": Topic by: " + author);
|
||||
this.topicAuthor = author;
|
||||
}
|
||||
|
||||
/**
|
||||
* To use a customized Member class, override this.
|
||||
*
|
||||
* @param nick Nickname to create a member object for
|
||||
* @return Member object for nick
|
||||
*/
|
||||
protected Member makeMember( String nick )
|
||||
{
|
||||
return new Member( nick );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines if the string represents a channel name or not.
|
||||
*
|
||||
* @param str String to test if it's a channel or not
|
||||
* @return True or false if a string looks like a channel
|
||||
*/
|
||||
public static boolean isChannel( String str )
|
||||
{
|
||||
return str.charAt(0) == '#' || str.charAt(0) == '!' || str.charAt(0) == '&';
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares the two channel names for equality. Returns false if
|
||||
* either are null.
|
||||
*
|
||||
* @param one Left side of comparison
|
||||
* @param two Right side of comparison
|
||||
* @return True or false whether two channels are equal, false of either are null/
|
||||
*/
|
||||
public static boolean areEqual( String one, String two )
|
||||
{
|
||||
if( one == null || two == null )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return one.equalsIgnoreCase( two );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,193 +0,0 @@
|
|||
/*
|
||||
* Original version: Ben Damm <bdamm@dammfine.com>
|
||||
* Changes by: mog
|
||||
* - Added isOnChannel
|
||||
*
|
||||
*/
|
||||
package f00f.net.irc.martyr.clientstate;
|
||||
|
||||
import java.util.Enumeration;
|
||||
import java.util.Hashtable;
|
||||
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
//import org.apache.log4j.Logger;
|
||||
|
||||
/**
|
||||
* <p>Maintains a list of client-related facts such as what channels we
|
||||
* are in, who else is in the channels, what our nick is, etc.</p>
|
||||
*
|
||||
* <p>ClientState is a critical part of martyr. To get access to events
|
||||
* that change the client state, the framework user can subclass
|
||||
* ClientState and then pass the subclass to the IRCConnection's
|
||||
* constructor. Then, when a command detects a change in client
|
||||
* state, it will call the corresponding method in the custom
|
||||
* ClientState.</p>
|
||||
*
|
||||
* <p>If a user of the framework wishes to grab client state information
|
||||
* about a channel (when a user joins, when a user leaves, topic
|
||||
* change, etc), the user can do so in a similar manner. Simply
|
||||
* override the 'addChannel(String)' method to instantiate their own
|
||||
* Channel subclass, and call the protected 'addChannel' method. See
|
||||
* the addChannel method for an example.
|
||||
* </p>
|
||||
*
|
||||
*/
|
||||
public class ClientState
|
||||
{
|
||||
|
||||
//static Logger log = Logger.getLogger(ClientState.class);
|
||||
|
||||
private FullNick nick = null;
|
||||
private String user = "";
|
||||
private String name = "";
|
||||
private String pass = null;
|
||||
private String server = "";
|
||||
private int port = -1;
|
||||
|
||||
// Hashtable is threadsafe so we don't have to be.
|
||||
protected Hashtable<String,Channel> channels = new Hashtable<String,Channel>();
|
||||
|
||||
public void setNick( FullNick nick )
|
||||
{
|
||||
if( nick == null )
|
||||
{
|
||||
//log.debug("ClientState: Set nick to null");
|
||||
}
|
||||
else
|
||||
{
|
||||
//log.debug("ClientState: Set nick to \"" + nick + "\"");
|
||||
}
|
||||
this.nick = nick;
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public void setUser( String user )
|
||||
{
|
||||
this.user = user;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the username that was used to register.
|
||||
* */
|
||||
public String getUser()
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
public void setName( String name )
|
||||
{
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the name (any arbitrary string) that was used to register.
|
||||
* */
|
||||
public String getName()
|
||||
{
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the password that was used to register.
|
||||
*/
|
||||
public String getPass()
|
||||
{
|
||||
return pass;
|
||||
}
|
||||
|
||||
public void setPass(String pass)
|
||||
{
|
||||
this.pass = pass;
|
||||
}
|
||||
|
||||
public void setServer( String server )
|
||||
{
|
||||
this.server = server;
|
||||
}
|
||||
|
||||
public String getServer()
|
||||
{
|
||||
return server;
|
||||
}
|
||||
|
||||
public void setPort( int port )
|
||||
{
|
||||
this.port = port;
|
||||
}
|
||||
|
||||
public int getPort()
|
||||
{
|
||||
return port;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Adds a channel to the list of channels we know about. If you
|
||||
* want to supply your own Channel object, override this method
|
||||
* with:</p>
|
||||
* <pre>
|
||||
* public void addChannel( String channame )
|
||||
* {
|
||||
* addChannel( new MyChannel( channame ) );
|
||||
* }
|
||||
* </pre>
|
||||
*
|
||||
* @param channame Channel to add to list of channels
|
||||
*/
|
||||
public void addChannel( String channame )
|
||||
{
|
||||
addChannel( new Channel( channame ) );
|
||||
}
|
||||
|
||||
protected void addChannel( Channel channel )
|
||||
{
|
||||
//log.debug("ClientState: Channel added: " + channel.getName());
|
||||
channels.put( channel.getName().toLowerCase(), channel );
|
||||
}
|
||||
|
||||
public Channel getChannel( String chanName )
|
||||
{
|
||||
return channels.get( chanName.toLowerCase() );
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a channel from the state, does nothing if the channel name
|
||||
* is invalid.
|
||||
* Should we throw an exception here?
|
||||
*
|
||||
* @param channel Channel to remove from list
|
||||
*/
|
||||
public void removeChannel( String channel )
|
||||
{
|
||||
//log.debug("ClientState: Channel removed: " + channel);
|
||||
channels.remove( channel.toLowerCase() );
|
||||
}
|
||||
|
||||
public boolean isOnChannel( String channel )
|
||||
{
|
||||
for (Enumeration iter = getChannelNames(); iter.hasMoreElements();)
|
||||
{
|
||||
if(channel.equalsIgnoreCase((String) iter.nextElement()))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public Enumeration getChannelNames()
|
||||
{
|
||||
return channels.keys();
|
||||
}
|
||||
|
||||
public Enumeration getChannels()
|
||||
{
|
||||
return channels.elements();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,114 +0,0 @@
|
|||
package f00f.net.irc.martyr.clientstate;
|
||||
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* <p>This class allows channels to keep track of individual users. Each
|
||||
* user in the channel has a nick and has voice, ops, both, or none.
|
||||
* Note that nicks can change, but the information we have about that
|
||||
* person does not.</p>
|
||||
*
|
||||
* <p>Control over events that happen to this class can be obtained in
|
||||
* a similar fashion to how control for the Channel is taken from
|
||||
* ClientState.</p>
|
||||
*/
|
||||
public class Member
|
||||
{
|
||||
|
||||
private FullNick nick;
|
||||
private boolean hasOpsV = false;
|
||||
private boolean hasVoiceV = false;
|
||||
|
||||
/**
|
||||
* <p>Strips off the leading 'at' or 'plus', sets ops or voice, and
|
||||
* keeps the nick. Calls the methods <code>setVoice(...)</code> and
|
||||
* <code>setOps(...)</code> from the constructor, if those conditions
|
||||
* are true. The nick is set before setVoice or setOps are
|
||||
* called.</p>
|
||||
*
|
||||
* @param nickStr Nick of member
|
||||
*/
|
||||
public Member( String nickStr )
|
||||
{
|
||||
char first = nickStr.charAt(0);
|
||||
String shortNick = nickStr.substring(1, nickStr.length() );
|
||||
if( first == '@' )
|
||||
{
|
||||
nick = new FullNick( shortNick );
|
||||
setOps( true );
|
||||
}
|
||||
else if( first == '+' )
|
||||
{
|
||||
nick = new FullNick( shortNick );
|
||||
setVoice( true );
|
||||
}
|
||||
else
|
||||
{
|
||||
nick = new FullNick( nickStr );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Does a nick-wise compare.
|
||||
*
|
||||
* @param member Member to compare against
|
||||
* @return True or false of this member equals the other one
|
||||
*/
|
||||
public boolean equals( Member member )
|
||||
{
|
||||
return equals( member.nick );
|
||||
}
|
||||
|
||||
public boolean equals( FullNick fullNick )
|
||||
{
|
||||
return nick.equals( fullNick );
|
||||
}
|
||||
|
||||
public boolean equals( Object o )
|
||||
{
|
||||
if( o instanceof Member )
|
||||
return equals( (Member)o );
|
||||
else if( o instanceof FullNick )
|
||||
return equals( (FullNick)o );
|
||||
else return false;
|
||||
}
|
||||
|
||||
public int hashCode()
|
||||
{
|
||||
return nick.hashCode();
|
||||
}
|
||||
|
||||
public void setOps( boolean ops )
|
||||
{
|
||||
hasOpsV = ops;
|
||||
}
|
||||
|
||||
public void setVoice( boolean voice )
|
||||
{
|
||||
hasVoiceV = voice;
|
||||
}
|
||||
|
||||
public boolean hasOps()
|
||||
{
|
||||
return hasOpsV;
|
||||
}
|
||||
|
||||
public boolean hasVoice()
|
||||
{
|
||||
return hasVoiceV;
|
||||
}
|
||||
|
||||
public void setNick( FullNick nick )
|
||||
{
|
||||
this.nick = nick;
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
|
||||
/**
|
||||
* Defines a generic command. Most commands will simply have to
|
||||
* override the getIrcIdentifier method and implement the parse and
|
||||
* render methods using convenience methods.
|
||||
*/
|
||||
public abstract class AbstractCommand extends AbstractInCommand implements OutCommand
|
||||
{
|
||||
|
||||
/**
|
||||
* Forms a string appropriate to send to the server. All commands can
|
||||
* be sent by the client.
|
||||
*/
|
||||
public String render()
|
||||
{
|
||||
// no prefix, since we are sending as a client.
|
||||
return getIrcIdentifier() + " " + renderParams();
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the parameters of this command.
|
||||
*
|
||||
* @return String of rendered parameters
|
||||
*/
|
||||
public abstract String renderParams();
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,174 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.CommandRegister;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
|
||||
/**
|
||||
* Defines a generic command. Most commands will simply have to
|
||||
* override the getIrcIdentifier method and implement the parse and
|
||||
* render methods using convenience methods.
|
||||
*/
|
||||
public abstract class AbstractInCommand implements InCommand
|
||||
{
|
||||
|
||||
protected Map<String,String> attributes = new HashMap<String,String>();
|
||||
|
||||
protected AbstractInCommand()
|
||||
{
|
||||
}
|
||||
|
||||
protected AbstractInCommand( String[] attributeNames )
|
||||
{
|
||||
for (String attributeName : attributeNames) {
|
||||
attributes.put(attributeName, null);
|
||||
}
|
||||
}
|
||||
|
||||
public String getAttribute( String key )
|
||||
{
|
||||
return attributes.get( key );
|
||||
}
|
||||
|
||||
public Iterator getAttributeKeys()
|
||||
{
|
||||
return Collections.unmodifiableSet( attributes.keySet() ).iterator();
|
||||
}
|
||||
|
||||
protected void setAttribute( String key, String value )
|
||||
{
|
||||
attributes.put( key, value );
|
||||
}
|
||||
|
||||
private String sourceString;
|
||||
|
||||
/**
|
||||
* Some commands, when received by the server, can only occur in one
|
||||
* state. Thus, when this command is received, the protocol should
|
||||
* assume that it is that state. A command can use the 'unknown'
|
||||
* state to indicate it can be received in any state (for example,
|
||||
* ping). Most commands will occur in the REGISTERED state, so for a
|
||||
* few exeptions, commands can leave this alone.
|
||||
*/
|
||||
public State getState()
|
||||
{
|
||||
return State.REGISTERED;
|
||||
}
|
||||
|
||||
/**
|
||||
* Every command should know how to register itself (or not) with the
|
||||
* command parsing engine. If a command is available under mutiple
|
||||
* identifiers, then this method can be overridden and the addCommand
|
||||
* method can be called multiple times.
|
||||
*/
|
||||
public void selfRegister( CommandRegister commandRegister )
|
||||
{
|
||||
commandRegister.addCommand( getIrcIdentifier(), this );
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object.
|
||||
*/
|
||||
public abstract InCommand parse( String prefix, String identifier, String params );
|
||||
|
||||
/**
|
||||
* By default, commands do not update the client state.
|
||||
*/
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility method to make parsing easy. Provides parameter n, where
|
||||
* n=0 is the first parameter. Parses out the : and considers
|
||||
* anything after a : to be one string, the final parameter.
|
||||
*
|
||||
* If the index doesn't exist, returns null. Should it throw
|
||||
* IndexOutOfBoundsException? No, some commands may have optional
|
||||
* fields.
|
||||
*
|
||||
* @param params String with parameters in it
|
||||
* @param num Position number of parameter to be requested
|
||||
* @return Parameter specified by id in params string
|
||||
*/
|
||||
public String getParameter( String params, int num )
|
||||
{
|
||||
int colonIndex = params.indexOf( " :" );
|
||||
colonIndex++; // Skip the space, we just needed it to be sure it's really a "rest of line" colon
|
||||
String textParam = null;
|
||||
String spaceParams;
|
||||
|
||||
if( colonIndex < 0 )
|
||||
{
|
||||
spaceParams = params;
|
||||
}
|
||||
else if( colonIndex == 0 )
|
||||
{
|
||||
if( num == 0 )
|
||||
return params.substring( 1, params.length() );
|
||||
else
|
||||
return null;
|
||||
// throw exception?
|
||||
}
|
||||
else
|
||||
{
|
||||
// colon index > 0, so we have at least one parameter before
|
||||
// the final parameter.
|
||||
spaceParams = params.substring( 0, colonIndex ).trim();
|
||||
textParam = params.substring( colonIndex + 1, params.length() );
|
||||
}
|
||||
|
||||
StringTokenizer tokens = new StringTokenizer( spaceParams, " " );
|
||||
|
||||
while( tokens.hasMoreTokens() && num > 0 )
|
||||
{
|
||||
// strip off tokensi
|
||||
--num;
|
||||
tokens.nextToken();
|
||||
}
|
||||
|
||||
if( num == 0 && tokens.hasMoreTokens() )
|
||||
return tokens.nextToken();
|
||||
if( num == 0 && !tokens.hasMoreTokens() )
|
||||
return textParam;
|
||||
|
||||
|
||||
return null;
|
||||
// throw exception?
|
||||
}
|
||||
|
||||
public int getIntParameter( String params, int paramnum, int defaultNum )
|
||||
{
|
||||
try
|
||||
{
|
||||
return Integer.parseInt( getParameter( params, paramnum ) );
|
||||
}
|
||||
catch( NumberFormatException nfe )
|
||||
{
|
||||
return defaultNum;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void setSourceString( String source )
|
||||
{
|
||||
this.sourceString = source;
|
||||
}
|
||||
|
||||
public String getSourceString()
|
||||
{
|
||||
return sourceString;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
/**
|
||||
* ActionCtcp allows the application to do a '/me'.
|
||||
*/
|
||||
public class ActionCtcp extends CtcpMessage
|
||||
{
|
||||
public ActionCtcp( String dest, String message )
|
||||
{
|
||||
super( dest, "ACTION " + message );
|
||||
}
|
||||
}
|
|
@ -1,189 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.modes.channel.AnonChannelMode;
|
||||
import f00f.net.irc.martyr.modes.channel.BanMode;
|
||||
import f00f.net.irc.martyr.modes.channel.ExceptionMode;
|
||||
import f00f.net.irc.martyr.modes.channel.InviteMaskMode;
|
||||
import f00f.net.irc.martyr.modes.channel.InviteOnlyMode;
|
||||
import f00f.net.irc.martyr.modes.channel.KeyMode;
|
||||
import f00f.net.irc.martyr.modes.channel.LimitMode;
|
||||
import f00f.net.irc.martyr.modes.channel.ModeratedMode;
|
||||
import f00f.net.irc.martyr.modes.channel.NoExtMsgMode;
|
||||
import f00f.net.irc.martyr.modes.channel.OperMode;
|
||||
import f00f.net.irc.martyr.modes.channel.PrivateMode;
|
||||
import f00f.net.irc.martyr.modes.channel.SecretMode;
|
||||
import f00f.net.irc.martyr.modes.channel.TopicLockMode;
|
||||
import f00f.net.irc.martyr.modes.channel.VoiceMode;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Defines the ChannelMode command. Can be used to send a Channel
|
||||
* mode. For receiving, this defines which channel modes Martyr knows
|
||||
* about and passes them on to the Channel object. Note that the
|
||||
* actual logic of what happens when a mode arrives lies in the
|
||||
* clientstate.Channel object.
|
||||
*/
|
||||
public class ChannelModeCommand extends ModeCommand
|
||||
{
|
||||
|
||||
private String prefix;
|
||||
private String channelName;
|
||||
private FullNick sender;
|
||||
|
||||
private List modes;
|
||||
|
||||
private static HashMap<Character,Mode> modeTypes;
|
||||
|
||||
/**
|
||||
* For receiving a mode command.
|
||||
* @param prefix Currently unused prefix string
|
||||
* @param channelName Channel that the mode change is in reference to
|
||||
* @param params List of params to be parsed
|
||||
*/
|
||||
public ChannelModeCommand( String prefix, String channelName,
|
||||
StringTokenizer params )
|
||||
{
|
||||
makeModes();
|
||||
|
||||
this.prefix = prefix;
|
||||
this.channelName = channelName;
|
||||
|
||||
modes = parseModes( modeTypes, params );
|
||||
|
||||
// System.out.println( modes );
|
||||
}
|
||||
|
||||
/**
|
||||
* For sending a mode discovery.
|
||||
*
|
||||
* @param channelName Channel that the mode change is in reference to
|
||||
*/
|
||||
public ChannelModeCommand( String channelName )
|
||||
{
|
||||
sender = null;
|
||||
this.channelName = channelName;
|
||||
|
||||
// Empty list, no modes.
|
||||
modes = new LinkedList();
|
||||
}
|
||||
|
||||
public void makeModes()
|
||||
{
|
||||
if( modeTypes == null )
|
||||
{
|
||||
modeTypes = new HashMap<Character,Mode>();
|
||||
|
||||
registerMode( modeTypes, new BanMode() );
|
||||
registerMode( modeTypes, new KeyMode() );
|
||||
registerMode( modeTypes, new OperMode() );
|
||||
registerMode( modeTypes, new VoiceMode() );
|
||||
registerMode( modeTypes, new LimitMode() );
|
||||
// registerMode( modeTypes, new QuietMode() );
|
||||
registerMode( modeTypes, new SecretMode() );
|
||||
registerMode( modeTypes, new PrivateMode() );
|
||||
registerMode( modeTypes, new NoExtMsgMode() );
|
||||
registerMode( modeTypes, new ExceptionMode() );
|
||||
registerMode( modeTypes, new TopicLockMode() );
|
||||
registerMode( modeTypes, new ModeratedMode() );
|
||||
registerMode( modeTypes, new InviteMaskMode() );
|
||||
registerMode( modeTypes, new InviteOnlyMode() );
|
||||
registerMode( modeTypes, new AnonChannelMode() );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shouldn't be called, as ModeCommand should be responsible for parsing
|
||||
* and creating this class.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
throw new IllegalStateException( "Don't call this method!" );
|
||||
}
|
||||
|
||||
public String render()
|
||||
{
|
||||
return "MODE " + channelName + renderParams();
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
Iterator modesI = modes.iterator();
|
||||
|
||||
String modes = "";
|
||||
String params = "";
|
||||
|
||||
while( modesI.hasNext() )
|
||||
{
|
||||
Mode mode = (Mode)modesI.next();
|
||||
|
||||
if( mode.getSign() != Mode.Sign.NOSIGN )
|
||||
{
|
||||
modes += (mode.getSign() == Mode.Sign.POSITIVE ? "+" : "-" );
|
||||
}
|
||||
modes += mode.getChar();
|
||||
|
||||
if( mode.getParam() != null )
|
||||
{
|
||||
// Does the parameter list already have params?
|
||||
// If so, stick in a space.
|
||||
if( params.length() > 0 )
|
||||
{
|
||||
params += " ";
|
||||
}
|
||||
params += mode.getParam();
|
||||
}
|
||||
}
|
||||
|
||||
return modes + " " + params;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channelName;
|
||||
}
|
||||
|
||||
public FullNick getSender()
|
||||
{
|
||||
return sender;
|
||||
}
|
||||
|
||||
public String getPrefix() {
|
||||
return prefix;
|
||||
}
|
||||
|
||||
/**
|
||||
* Passes the modes on to the clientstate.Channel object.
|
||||
*/
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
boolean changed = false;
|
||||
|
||||
Iterator modesI = modes.iterator();
|
||||
Channel channel = state.getChannel( channelName );
|
||||
|
||||
while( modesI.hasNext() )
|
||||
{
|
||||
Mode mode = (Mode)modesI.next();
|
||||
|
||||
channel.setMode( mode );
|
||||
|
||||
changed = true;
|
||||
}
|
||||
|
||||
return changed;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,129 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* This facilitates the sending and receiving of CTCP messages. Upon
|
||||
* receiving a message, MessageCommand checks to see if it is a CTCP,
|
||||
* and if it is, it instantiates this class instead of a
|
||||
* MessageCommand. You can then use the getAction() and getMessage()
|
||||
* methods to retreive the action and payload, respectively.
|
||||
*
|
||||
* @see MessageCommand
|
||||
*/
|
||||
public class CtcpMessage extends MessageCommand
|
||||
{
|
||||
private String actionStr;
|
||||
|
||||
/**
|
||||
* Use this to send a CTCP message. This simply wraps the string
|
||||
* with the CTCP tags, \001.
|
||||
*
|
||||
* @param dest Target of CTCP message
|
||||
* @param message Actual CTCP message
|
||||
*/
|
||||
public CtcpMessage( String dest, String message )
|
||||
{
|
||||
super( dest, "\001" + message + "\001" );
|
||||
}
|
||||
|
||||
public CtcpMessage( String dest, String action, String message )
|
||||
{
|
||||
this( dest, action + " " + message );
|
||||
}
|
||||
|
||||
/**
|
||||
* This is only to be called by MessageCommand, as a way of
|
||||
* receiving a Ctcp message. It strips the \001's off and holds
|
||||
* the message left over.
|
||||
*
|
||||
* @param from Nick that sent the message
|
||||
* @param dest Target of the CTCP message
|
||||
* @param message Actual CTCP message
|
||||
*/
|
||||
protected CtcpMessage( FullNick from, String dest, String message )
|
||||
{
|
||||
super( from, dest, getMessageStr( stripCtcpWrapper( message ) ) );
|
||||
|
||||
actionStr = getActionStr( stripCtcpWrapper( message ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the action of this CTCP. Use getMessage() to retreive
|
||||
* the payload of the action.
|
||||
*
|
||||
* @return The action specified by the CTCP message
|
||||
*/
|
||||
public String getAction()
|
||||
{
|
||||
return actionStr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a stripped CTCP message, returns the ctcp action string.
|
||||
*
|
||||
* @param msg Message to be parsed into an action
|
||||
* @return Action string from message
|
||||
*/
|
||||
public static String getActionStr( String msg )
|
||||
{
|
||||
StringTokenizer tokens = new StringTokenizer( msg );
|
||||
return tokens.nextToken();
|
||||
}
|
||||
|
||||
public static String getMessageStr( String msg )
|
||||
{
|
||||
String acn = getActionStr( msg );
|
||||
return msg.substring( acn.length() ).trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* If the string is wrapped with CTCP signal chars (\001) returns
|
||||
* true.
|
||||
*
|
||||
* @param msg String to check whether it's a CTCP message or not
|
||||
* @return True or false if it's a CTCP message
|
||||
*/
|
||||
public static boolean isCtcpString( String msg )
|
||||
{
|
||||
return msg.charAt(0) == '\001' && msg.charAt(msg.length()-1) == '\001';
|
||||
}
|
||||
|
||||
/**
|
||||
* Strips a CTCP wrapper, if there is one.
|
||||
*
|
||||
* @param msg String to be stripped
|
||||
* @return Stripped string
|
||||
*/
|
||||
public static String stripCtcpWrapper( String msg )
|
||||
{
|
||||
if( isCtcpString( msg ) )
|
||||
{
|
||||
return msg.substring( 1, msg.length()-1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
return msg;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Dysfunctional. Returns dat immediatly.
|
||||
*/
|
||||
/*public static byte[] escapeMsg( byte[] dat )
|
||||
{
|
||||
return dat;
|
||||
}*/
|
||||
|
||||
/**
|
||||
* Dysfunctional. Returns dat immediatly.
|
||||
*/
|
||||
/*public static byte[] unEscapeMsg( byte[] dat )
|
||||
{
|
||||
return dat;
|
||||
}*/
|
||||
}
|
||||
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* This facilitates the sending and receiving of CTCP messages. Upon
|
||||
* receiving a message, MessageCommand checks to see if it is a CTCP,
|
||||
* and if it is, it instantiates this class instead of a
|
||||
* MessageCommand. You can then use the getAction() and getMessage()
|
||||
* methods to retreive the action and payload, respectively.
|
||||
*
|
||||
* @see NoticeCommand
|
||||
*/
|
||||
public class CtcpNotice extends NoticeCommand
|
||||
{
|
||||
private String actionStr;
|
||||
|
||||
/**
|
||||
* Use this to send a CTCP message. This simply wraps the string
|
||||
* with the CTCP tags, \001.
|
||||
*
|
||||
* @param dest Target of CTCP message
|
||||
* @param message Actual CTCP message
|
||||
*/
|
||||
public CtcpNotice( String dest, String message )
|
||||
{
|
||||
super( dest, "\001" + message + "\001" );
|
||||
}
|
||||
|
||||
public CtcpNotice( String dest, String action, String message )
|
||||
{
|
||||
this( dest, action + " " + message );
|
||||
|
||||
actionStr = action;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is only to be called by MessageCommand, as a way of
|
||||
* receiving a Ctcp message. It strips the \001's off and holds
|
||||
* the message left over.
|
||||
*
|
||||
* @param from Nick that sent the message
|
||||
* @param dest Target of the CTCP message
|
||||
* @param message Actual CTCP message
|
||||
*/
|
||||
protected CtcpNotice( FullNick from, String dest, String message )
|
||||
{
|
||||
super( from, dest, getMessageStr( stripCtcpWrapper( message ) ) );
|
||||
|
||||
actionStr = getActionStr( stripCtcpWrapper( message ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the action of this CTCP. Use getMessage() to retreive
|
||||
* the payload of the action.
|
||||
*
|
||||
* @return The action specified by the CTCP message
|
||||
*/
|
||||
public String getAction()
|
||||
{
|
||||
return actionStr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a stripped CTCP message, returns the ctcp action string.
|
||||
*
|
||||
* @param msg Message to be parsed into an action
|
||||
* @return Action string from message
|
||||
*/
|
||||
public static String getActionStr( String msg )
|
||||
{
|
||||
StringTokenizer tokens = new StringTokenizer( msg );
|
||||
return tokens.nextToken();
|
||||
}
|
||||
|
||||
public static String getMessageStr( String msg )
|
||||
{
|
||||
String acn = getActionStr( msg );
|
||||
return msg.substring( acn.length() ).trim();
|
||||
}
|
||||
|
||||
/**
|
||||
* If the string is wrapped with CTCP signal chars (\001) returns
|
||||
* true.
|
||||
*
|
||||
* @param msg String to check whether it's a CTCP message or not
|
||||
* @return True or false if it's a CTCP message
|
||||
*/
|
||||
public static boolean isCtcpString( String msg )
|
||||
{
|
||||
return msg.charAt(0) == '\001' && msg.charAt(msg.length()-1) == '\001';
|
||||
}
|
||||
|
||||
/**
|
||||
* Strips a CTCP wrapper, if there is one.
|
||||
*
|
||||
* @param msg String to be stripped
|
||||
* @return Stripped string
|
||||
*/
|
||||
public static String stripCtcpWrapper( String msg )
|
||||
{
|
||||
if( isCtcpString( msg ) )
|
||||
{
|
||||
return msg.substring( 1, msg.length()-1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
return msg;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Dysfunctional. Returns dat immediatly.
|
||||
*/
|
||||
/*public static byte[] escapeMsg( byte[] dat )
|
||||
{
|
||||
return dat;
|
||||
}*/
|
||||
|
||||
/**
|
||||
* Dysfunctional. Returns dat immediatly.
|
||||
*/
|
||||
/*public static byte[] unEscapeMsg( byte[] dat )
|
||||
{
|
||||
return dat;
|
||||
}*/
|
||||
}
|
||||
|
||||
|
|
@ -1,90 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
import f00f.net.irc.martyr.util.ParameterIterator;
|
||||
|
||||
/**
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
*/
|
||||
public class InviteCommand extends AbstractCommand {
|
||||
|
||||
private String _channel;
|
||||
private String _nick;
|
||||
private FullNick _user;
|
||||
|
||||
/** For use as a factory */
|
||||
public InviteCommand()
|
||||
{
|
||||
_channel = null;
|
||||
_nick = null;
|
||||
_user = null;
|
||||
}
|
||||
|
||||
private InviteCommand(FullNick user, String nick, String channel)
|
||||
{
|
||||
_user = user;
|
||||
_nick = nick;
|
||||
_channel = channel;
|
||||
}
|
||||
|
||||
public InviteCommand(String nick, String channel)
|
||||
{
|
||||
_nick = nick;
|
||||
_channel = channel;
|
||||
}
|
||||
|
||||
public InviteCommand(FullNick nick, String channel)
|
||||
{
|
||||
this(nick.getNick(), channel);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see f00f.net.irc.martyr.Command#parse(java.lang.String, java.lang.String, java.lang.String)
|
||||
*/
|
||||
public InCommand parse(String prefix, String identifier, String params)
|
||||
{
|
||||
ParameterIterator iter = new ParameterIterator(params);
|
||||
return new InviteCommand( new FullNick( prefix ), (String)iter.next(), (String)iter.next() );
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see f00f.net.irc.martyr.commands.AbstractCommand#getIrcIdentifier()
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "INVITE";
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
* @see f00f.net.irc.martyr.commands.AbstractCommand#renderParams()
|
||||
*/
|
||||
public String renderParams()
|
||||
{
|
||||
return _nick+" "+_channel;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The channel invited to. */
|
||||
public String getChannel()
|
||||
{
|
||||
return _channel;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The nick sending the invite.
|
||||
*/
|
||||
public String getNick()
|
||||
{
|
||||
return _nick;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The user the invite is sent to.
|
||||
*/
|
||||
public FullNick getUser()
|
||||
{
|
||||
return _user;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,144 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.CommandRegister;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* Defines the ISON command, which is used to determine if a user or a list of users is online.
|
||||
*
|
||||
* @author Daniel Henninger
|
||||
*/
|
||||
public class IsonCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
public static final String IDENTIFIER_PRIMARY = "ISON";
|
||||
public static final String IDENTIFIER_SECONDARY = "303";
|
||||
|
||||
/* List of nicks that we will check for online status */
|
||||
List<String> nicks = new ArrayList<String>();
|
||||
|
||||
/* Destination nick */
|
||||
String dest = null;
|
||||
|
||||
/**
|
||||
* No parameter passed to the ISON is not valid. This is used for factories.
|
||||
*/
|
||||
public IsonCommand()
|
||||
{
|
||||
// Nothing to do
|
||||
}
|
||||
|
||||
/**
|
||||
* Check online status of a single nickname.
|
||||
*
|
||||
* @param nick Nick you want to check the online status of.
|
||||
*/
|
||||
public IsonCommand(String nick)
|
||||
{
|
||||
this.nicks.add(nick);
|
||||
}
|
||||
|
||||
public IsonCommand(String dest, String nick) {
|
||||
this.dest = dest;
|
||||
this.nicks.add(nick);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check online status of a number of nicknames.
|
||||
*
|
||||
* @param nicks List of nicks you want to check the online status of.
|
||||
*/
|
||||
public IsonCommand(List<String> nicks)
|
||||
{
|
||||
this.nicks.addAll(nicks);
|
||||
}
|
||||
|
||||
public IsonCommand(String dest, List<String> nicks) {
|
||||
this.dest = dest;
|
||||
this.nicks.addAll(nicks);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see AbstractCommand#parse(String, String, String)
|
||||
*/
|
||||
public InCommand parse(String prefix, String identifier, String params)
|
||||
{
|
||||
// when the command is used as a reply, the nick is parameter 0 and the rest are parameter 1.
|
||||
if ( identifier.equals( IDENTIFIER_SECONDARY ) ) {
|
||||
String nickParam = getParameter(params, 1);
|
||||
List<String> nicks = Arrays.asList(nickParam.split(" "));
|
||||
return new IsonCommand(getParameter(params, 0), nicks);
|
||||
}
|
||||
else {
|
||||
String nickParam = getParameter(params, 0);
|
||||
List<String> nicks = Arrays.asList(nickParam.split(" "));
|
||||
return new IsonCommand(nicks);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @see f00f.net.irc.martyr.commands.AbstractCommand#renderParams()
|
||||
*/
|
||||
public String renderParams()
|
||||
{
|
||||
String ret = "";
|
||||
if (nicks.size() > 0) {
|
||||
Boolean isFirst = true;
|
||||
for (String nick : nicks) {
|
||||
if (isFirst) {
|
||||
ret = ret + nick;
|
||||
isFirst = false;
|
||||
}
|
||||
else {
|
||||
ret = ret + " " + nick;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see f00f.net.irc.martyr.Command#getIrcIdentifier()
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
//
|
||||
// This command uses "ISON" on outgoing, so that is why we use
|
||||
// "ISON" here instead of "303".
|
||||
//
|
||||
return IDENTIFIER_PRIMARY;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see AbstractCommand#selfRegister(f00f.net.irc.martyr.CommandRegister)
|
||||
*/
|
||||
public void selfRegister(CommandRegister commandRegister)
|
||||
{
|
||||
commandRegister.addCommand( IDENTIFIER_PRIMARY, this );
|
||||
commandRegister.addCommand( IDENTIFIER_SECONDARY, this );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the target of the ISON command
|
||||
*
|
||||
* @return Target of command
|
||||
*/
|
||||
public String getDest() {
|
||||
return dest;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the list of nicks that are online after an ISON command
|
||||
*
|
||||
* @return List of online nicks
|
||||
*/
|
||||
public List<String> getNicks()
|
||||
{
|
||||
return nicks;
|
||||
}
|
||||
|
||||
}
|
|
@ -1,131 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
|
||||
/**
|
||||
* Defines JOIN command.
|
||||
*/
|
||||
public class JoinCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
static Logger log = Logger.getLogger(JoinCommand.class.getName());
|
||||
|
||||
private String channel;
|
||||
private String secret;
|
||||
private FullNick user;
|
||||
|
||||
/** For use as a factory */
|
||||
public JoinCommand()
|
||||
{
|
||||
this.user = null;
|
||||
this.channel = null;
|
||||
this.secret = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* This constructor is used with an incoming JOIN command from the server.
|
||||
*
|
||||
* @param user User that joined the channel
|
||||
* @param channel Channel that was joined
|
||||
*/
|
||||
private JoinCommand( FullNick user, String channel )
|
||||
{
|
||||
this.user = user;
|
||||
this.channel = channel;
|
||||
this.secret = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* This constructor is used to make a request to join a channel that
|
||||
* requires a secret key to join.
|
||||
*
|
||||
* @param channel The channel
|
||||
* @param secret The secret key required to enter the channel, or null of
|
||||
* none.
|
||||
*/
|
||||
public JoinCommand( String channel, String secret )
|
||||
{
|
||||
this.secret = secret;
|
||||
this.user = null;
|
||||
this.channel = channel;
|
||||
}
|
||||
|
||||
/**
|
||||
* This constructor is used to make a request to join a channel.
|
||||
*
|
||||
* @param channel Channel that will be joined
|
||||
*/
|
||||
public JoinCommand( String channel )
|
||||
{
|
||||
this.secret = null;
|
||||
this.user = null;
|
||||
this.channel = channel;
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new JoinCommand( new FullNick( prefix ), getParameter( params, 0 ) );
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "JOIN";
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
if( secret == null )
|
||||
return channel;
|
||||
else
|
||||
return channel + " " + secret;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getSecret()
|
||||
{
|
||||
return secret;
|
||||
}
|
||||
|
||||
public FullNick getUser()
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
public boolean weJoined( ClientState state )
|
||||
{
|
||||
return user.equals( state.getNick() );
|
||||
}
|
||||
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
if( weJoined( state ) )
|
||||
{
|
||||
// We've joined a group.
|
||||
//log.debug("JOIN: We've joined " + channel);
|
||||
state.addChannel( channel );
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Someone else joined the group.
|
||||
//log.debug("JOIN: " + user + " joined " + channel);
|
||||
// 1) Grab group
|
||||
Channel channelObj = state.getChannel( channel );
|
||||
// 2) Add user
|
||||
channelObj.addMember( user, this );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
|
||||
/**
|
||||
* Defines KICK command.
|
||||
*/
|
||||
public class KickCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
static Logger log = Logger.getLogger(KickCommand.class.getName());
|
||||
|
||||
private String channel;
|
||||
private FullNick userKicker;
|
||||
private FullNick userKicked;
|
||||
private String comment;
|
||||
|
||||
/** For use as a factory */
|
||||
public KickCommand()
|
||||
{
|
||||
this( null, null, null, null );
|
||||
}
|
||||
|
||||
public KickCommand( FullNick userKicker, String channel,
|
||||
String userKicked, String comment )
|
||||
{
|
||||
this.userKicker = userKicker;
|
||||
this.channel = channel;
|
||||
this.userKicked = new FullNick( userKicked );
|
||||
this.comment = comment;
|
||||
}
|
||||
|
||||
public KickCommand( String channel, String userToKick, String comment )
|
||||
{
|
||||
this( null, channel, userToKick, comment );
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new KickCommand(
|
||||
new FullNick( prefix ),
|
||||
getParameter( params, 0 ),
|
||||
getParameter( params, 1 ),
|
||||
getParameter( params, 2 )
|
||||
);
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "KICK";
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
return channel + " " + userKicked + " :" + comment;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public FullNick getKicker()
|
||||
{
|
||||
return userKicker;
|
||||
}
|
||||
|
||||
public FullNick getKicked()
|
||||
{
|
||||
return userKicked;
|
||||
}
|
||||
|
||||
public String getComment()
|
||||
{
|
||||
return comment;
|
||||
}
|
||||
|
||||
public boolean kickedUs( ClientState state )
|
||||
{
|
||||
return userKicked.equals( state.getNick() );
|
||||
}
|
||||
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
if( kickedUs( state ) )
|
||||
{
|
||||
// We've been kicked.
|
||||
//log.debug("KICK: We've been kicked " + channel);
|
||||
state.removeChannel( channel );
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Someone else was kicked.
|
||||
//log.debug("KICK: " + userKicked.getNick() + " kicked " + channel);
|
||||
// 1) Grab group
|
||||
Channel channelObj = state.getChannel( channel );
|
||||
channelObj.removeMember( userKicked, this );
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
|
||||
/**
|
||||
* Defines the PRIVMSG command. Messages can be sent to groups or to users.
|
||||
*/
|
||||
public class MessageCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
private FullNick from;
|
||||
private String dest;
|
||||
private String message;
|
||||
|
||||
|
||||
/** Factory */
|
||||
public MessageCommand()
|
||||
{
|
||||
from = null;
|
||||
dest = null;
|
||||
message = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to send a message.
|
||||
*
|
||||
* @param dest Target for message
|
||||
* @param message Message to be sent
|
||||
*/
|
||||
public MessageCommand( String dest, String message )
|
||||
{
|
||||
this( null, dest, message );
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to send a message.
|
||||
*
|
||||
* @param dest Target for message
|
||||
* @param message Message to be sent
|
||||
*/
|
||||
public MessageCommand( FullNick dest, String message )
|
||||
{
|
||||
this( dest.getNick(), message );
|
||||
}
|
||||
|
||||
public MessageCommand( FullNick source, String dest, String message )
|
||||
{
|
||||
this.from = source;
|
||||
this.dest = dest;
|
||||
this.message = message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
FullNick from;
|
||||
if( prefix == null || prefix.trim().length() == 0 )
|
||||
{
|
||||
from = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
from = new FullNick( prefix );
|
||||
}
|
||||
String dest = getParameter( params, 0 );
|
||||
String msg = getParameter( params, 1 );
|
||||
|
||||
if( CtcpMessage.isCtcpString( msg ) )
|
||||
{
|
||||
return new CtcpMessage( from, dest, msg );
|
||||
}
|
||||
|
||||
return new MessageCommand( from, dest, msg );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the string IRC uses to identify this command. Examples:
|
||||
* NICK, PING, KILL, 332
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "PRIVMSG";
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the parameters of this command.
|
||||
*/
|
||||
public String renderParams()
|
||||
{
|
||||
return dest + " :" + message;
|
||||
}
|
||||
|
||||
public FullNick getSource()
|
||||
{
|
||||
return from;
|
||||
}
|
||||
|
||||
public String getDest()
|
||||
{
|
||||
return dest;
|
||||
}
|
||||
|
||||
public String getMessage()
|
||||
{
|
||||
return message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the message is both private and for us.
|
||||
*
|
||||
* @param state Client state to compare with
|
||||
* @return True or false if this is a private message to us
|
||||
*/
|
||||
public boolean isPrivateToUs( ClientState state )
|
||||
{
|
||||
return state.getNick().equals( dest );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,237 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.CommandRegister;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* Defines MODE command. Since the MODE command is of two distinct
|
||||
* types, this class is really more of a command mini-factory. It
|
||||
* determines which type of command it is, either a UserModeCommand or
|
||||
* a ChannelModeCommand.
|
||||
*
|
||||
*/
|
||||
public class ModeCommand implements InCommand, OutCommand
|
||||
{
|
||||
static Logger log = Logger.getLogger(ModeCommand.class.getName());
|
||||
|
||||
public static final String IDENTIFIER = "MODE";
|
||||
private String source;
|
||||
|
||||
/** For use as a factory */
|
||||
public ModeCommand()
|
||||
{
|
||||
}
|
||||
|
||||
public Iterator getAttributeKeys()
|
||||
{
|
||||
return new LinkedList().iterator();
|
||||
}
|
||||
|
||||
public String getAttribute( String key )
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void registerMode( Map<Character,Mode> modes, Mode mode )
|
||||
{
|
||||
Character modeChar = mode.getChar();
|
||||
|
||||
if( modes.get( modeChar ) != null )
|
||||
{
|
||||
log.severe("ModeCommand: Warning: Two modes with same letter: " +
|
||||
modes.get( modeChar ) + " and " + mode);
|
||||
}
|
||||
|
||||
modes.put( modeChar, mode );
|
||||
}
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.REGISTERED;
|
||||
}
|
||||
|
||||
public void selfRegister( CommandRegister reg )
|
||||
{
|
||||
reg.addCommand( IDENTIFIER, this );
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return IDENTIFIER;
|
||||
}
|
||||
|
||||
// Example
|
||||
// <pre>:repp_!bdamm@dammfine.com MODE #bytesex +oo z * repp_telnet</pre>
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
// there are two kinds of modes. Either a channel mode, or a user
|
||||
// mode. We need to figure out which we are dealing with, and
|
||||
// return that.
|
||||
|
||||
// TODO: Research: Should we specify delimiters other than whitespace?
|
||||
StringTokenizer tokens = new StringTokenizer( params );
|
||||
|
||||
String str = tokens.nextToken();
|
||||
|
||||
//log.debug("ModeCommand: Prefix: " + prefix + " str: " + str
|
||||
// + " total: " + params);
|
||||
|
||||
// Malformed command.
|
||||
if( str == null )
|
||||
return null;
|
||||
|
||||
// Should we check to see if the string is really a channel
|
||||
// that we know about?
|
||||
if( Channel.isChannel( str ) )
|
||||
{
|
||||
return new ChannelModeCommand( prefix, str, tokens );
|
||||
}
|
||||
else
|
||||
{
|
||||
return new UserModeCommand( prefix, str, tokens );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Should not be called, as ModeCommand doesn't actually represent a
|
||||
* command. Use UserModeCommand or ChannelModeCommand instead.
|
||||
*/
|
||||
public String render()
|
||||
{
|
||||
throw new IllegalStateException("Don't try to send ModeCommand!");
|
||||
}
|
||||
|
||||
public void setSourceString( String source )
|
||||
{
|
||||
this.source = source;
|
||||
}
|
||||
|
||||
public String getSourceString()
|
||||
{
|
||||
return source;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does nothing, as this is a factory command.
|
||||
*/
|
||||
public boolean updateClientState( ClientState cs )
|
||||
{
|
||||
// Nothing here, move on.
|
||||
return false;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return "ModeCommand";
|
||||
}
|
||||
|
||||
/** Takes a mode string, such as: '+ooo A B C' or '+o A +o B' or even
|
||||
* '+o-o A B' and returns a List containing Mode objects that
|
||||
* correspond to the modes specified.
|
||||
*
|
||||
* @param modes is a Map of Character to Mode objects.
|
||||
* @param tokens is the sequence of tokens making up the parameters of
|
||||
* the command.
|
||||
* @return List of modes
|
||||
*/
|
||||
public List<Mode> parseModes( Map<Character,Mode> modes, StringTokenizer tokens )
|
||||
{
|
||||
LinkedList<Mode> results = new LinkedList<Mode>();
|
||||
|
||||
while( true )
|
||||
{
|
||||
if( tokens.hasMoreTokens() )
|
||||
{
|
||||
parseOneModeSet( modes, tokens, results );
|
||||
}
|
||||
else
|
||||
{
|
||||
return results;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses one group of modes. '+ooo A B C' and not '+o A +o B'. It
|
||||
* will parse the first group it finds and will ignore the rest.
|
||||
*
|
||||
* @param modes Map of character to Mode objects.
|
||||
* @param tokens Sequence of tokens making up the parameters of the command.
|
||||
* @param results List of Mode results to be filled in
|
||||
*/
|
||||
private void parseOneModeSet( Map<Character,Mode> modes, StringTokenizer tokens, List<Mode> results )
|
||||
{
|
||||
// A list of modes that we have.
|
||||
LinkedList<Mode> localModes = new LinkedList<Mode>();
|
||||
|
||||
Mode.Sign sign = Mode.Sign.NOSIGN;
|
||||
String chars = tokens.nextToken();
|
||||
|
||||
int stop = chars.length();
|
||||
for( int i = 0; i < stop; ++i )
|
||||
{
|
||||
char lookingAt = chars.charAt( i );
|
||||
if( lookingAt == '+' )
|
||||
sign = Mode.Sign.POSITIVE;
|
||||
else if( lookingAt == '-' )
|
||||
sign = Mode.Sign.NEGATIVE;
|
||||
else if( lookingAt == ':' )
|
||||
// This is to get around a bug in some ircds
|
||||
continue;
|
||||
else
|
||||
{
|
||||
// A real mode character!
|
||||
Mode mode = modes.get( lookingAt );
|
||||
if( mode == null )
|
||||
{
|
||||
//TODO: Is there some way we can figure out if the mode
|
||||
// we don't know anything about needs a parameter?
|
||||
// Things get messy if it does need a parameter, and we
|
||||
// don't eat the string.
|
||||
//log.severe("ModeCommand: Unknown mode: " + lookingAt);
|
||||
}
|
||||
else
|
||||
{
|
||||
mode = mode.newInstance();
|
||||
mode.setSign( sign );
|
||||
localModes.add( mode );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Now we know what modes are specified, and whether they are
|
||||
// positive or negative. Now we need to fill in the parameters for
|
||||
// any that require parameters, and place the results in the result
|
||||
// list.
|
||||
for (Mode localMode : localModes) {
|
||||
/*
|
||||
* What we do if the server doesn't pass us a parameter
|
||||
* for a mode is rather undefined - except that we don't
|
||||
* want to run off the end of the tokens. So we just
|
||||
* ignore it. The problem is that we don't always know
|
||||
* when a server is going to send us a parameter or not.
|
||||
* We can only hope that servers don't send ambiguous
|
||||
* masks followed by more modes instead of a parameter.
|
||||
*/
|
||||
if (localMode != null && localMode.requiresParam() && tokens.hasMoreTokens()) {
|
||||
localMode.setParam(tokens.nextToken());
|
||||
}
|
||||
|
||||
results.add(localMode);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
|
||||
/**
|
||||
* Defines the NAMES command, which is used to get the members of certain channels, or all of them.
|
||||
*
|
||||
* @author Daniel Henninger
|
||||
*/
|
||||
public class NamesCommand implements OutCommand
|
||||
{
|
||||
|
||||
/* List of channels we will request membership of. */
|
||||
List<String> channels = new ArrayList<String>();
|
||||
|
||||
/**
|
||||
* No parameter passed to the NAMES command represents a request for all channels.
|
||||
*/
|
||||
public NamesCommand()
|
||||
{
|
||||
// Nothing to do
|
||||
}
|
||||
|
||||
/**
|
||||
* Request the membership of a single channel.
|
||||
*
|
||||
* @param channel Channel you want to request membership of.
|
||||
*/
|
||||
public NamesCommand(String channel)
|
||||
{
|
||||
this.channels.add(channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* Request the membership of multiple channels.
|
||||
*
|
||||
* @param channels List of channels you want to retrieve the membership list of.
|
||||
*/
|
||||
public NamesCommand(List<String> channels)
|
||||
{
|
||||
this.channels.addAll(channels);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see f00f.net.irc.martyr.OutCommand#render()
|
||||
*/
|
||||
public String render()
|
||||
{
|
||||
String ret = getIrcIdentifier();
|
||||
if (channels.size() > 0) {
|
||||
ret = ret + " ";
|
||||
Boolean isFirst = true;
|
||||
for (String channel : channels) {
|
||||
if (isFirst) {
|
||||
ret = ret + channel;
|
||||
isFirst = false;
|
||||
}
|
||||
else {
|
||||
ret = ret + "," + channel;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see f00f.net.irc.martyr.Command#getIrcIdentifier()
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "NAMES";
|
||||
}
|
||||
|
||||
}
|
|
@ -1,97 +0,0 @@
|
|||
/*
|
||||
* Original version: Ben Damm <bdamm@dammfine.com>
|
||||
* Changes by: Mog
|
||||
* - added getOldNick
|
||||
* */
|
||||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.Enumeration;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.clientstate.Member;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Defines NICK command.
|
||||
*/
|
||||
public class NickCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
private FullNick oldNick;
|
||||
private FullNick newNick;
|
||||
|
||||
/** For use as a factory */
|
||||
public NickCommand()
|
||||
{
|
||||
this( null, null );
|
||||
}
|
||||
|
||||
public NickCommand( FullNick oldNick, FullNick newNick )
|
||||
{
|
||||
this.oldNick = oldNick;
|
||||
this.newNick = newNick;
|
||||
}
|
||||
|
||||
public NickCommand( String newNick )
|
||||
{
|
||||
this( null, new FullNick( newNick ) );
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NickCommand( new FullNick( prefix ), new FullNick ( getParameter( params, 0 ) ) );
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "NICK";
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
return getNick();
|
||||
}
|
||||
|
||||
public String getNick()
|
||||
{
|
||||
return newNick.getNick();
|
||||
}
|
||||
|
||||
public String getOldNick()
|
||||
{
|
||||
return oldNick.getNick();
|
||||
}
|
||||
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
// Does this apply to us?
|
||||
if( oldNick.equals( state.getNick() ) )
|
||||
{
|
||||
state.setNick( newNick );
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Ok, so we need to change someone's nick.
|
||||
// This needs to occur for each member with that nick in each
|
||||
// channel that we are in. Just use Member.setNick for each
|
||||
// occurance.
|
||||
// Note: I do not believe this code has received a vigorous
|
||||
// test.
|
||||
Enumeration channels = state.getChannels();
|
||||
while( channels.hasMoreElements() )
|
||||
{
|
||||
Channel channel = (Channel)channels.nextElement();
|
||||
Member member = channel.findMember( oldNick.getNick() );
|
||||
if( member != null )
|
||||
member.setNick( newNick );
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,129 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
|
||||
/**
|
||||
* Defines the NOTICE command.
|
||||
*/
|
||||
public class NoticeCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
private FullNick from;
|
||||
private String dest;
|
||||
private String notice;
|
||||
|
||||
/** Factory */
|
||||
public NoticeCommand()
|
||||
{
|
||||
from = null;
|
||||
dest = null;
|
||||
notice = null;
|
||||
}
|
||||
|
||||
public NoticeCommand( String notice )
|
||||
{
|
||||
this.notice = notice;
|
||||
}
|
||||
|
||||
public NoticeCommand( String dest, String notice )
|
||||
{
|
||||
this(null, dest, notice);
|
||||
}
|
||||
|
||||
public NoticeCommand( FullNick dest, String notice )
|
||||
{
|
||||
this(dest.getNick(), notice);
|
||||
}
|
||||
|
||||
public NoticeCommand( FullNick source, String dest, String notice ) {
|
||||
this.from = source;
|
||||
this.dest = dest;
|
||||
this.notice = notice;
|
||||
}
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
FullNick from;
|
||||
if( prefix == null || prefix.trim().length() == 0 )
|
||||
{
|
||||
from = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
from = new FullNick( prefix );
|
||||
}
|
||||
String dest = getParameter( params, 0 );
|
||||
String msg = getParameter( params, 1 );
|
||||
|
||||
if( CtcpNotice.isCtcpString( msg ) )
|
||||
{
|
||||
return new CtcpNotice( from, dest, msg );
|
||||
}
|
||||
|
||||
return new NoticeCommand( from, dest, msg );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the string IRC uses to identify this command. Examples:
|
||||
* NICK, PING, KILL, 332
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "NOTICE";
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the parameters of this command.
|
||||
*/
|
||||
public String renderParams()
|
||||
{
|
||||
if (dest != null) {
|
||||
return dest + " :" + notice;
|
||||
}
|
||||
else {
|
||||
return ":" + notice;
|
||||
}
|
||||
}
|
||||
|
||||
public FullNick getFrom()
|
||||
{
|
||||
return from;
|
||||
}
|
||||
|
||||
public String getDest()
|
||||
{
|
||||
return dest;
|
||||
}
|
||||
|
||||
public String getNotice()
|
||||
{
|
||||
return notice;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the message is both private and for us.
|
||||
*
|
||||
* @param state Client state to compare with
|
||||
* @return True or false if this is a private message to us
|
||||
*/
|
||||
public boolean isPrivateToUs( ClientState state )
|
||||
{
|
||||
return state.getNick().equals( dest );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* <p>Defines PART command. If the part command is from us, we should
|
||||
* remove that channel from the list of channels. If the part command
|
||||
* is from someone else, we should remove that user from the list of
|
||||
* users for that channel.
|
||||
*/
|
||||
|
||||
public class PartCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
private String reason;
|
||||
private String channel;
|
||||
private FullNick user;
|
||||
|
||||
/** For use as a factory */
|
||||
public PartCommand()
|
||||
{
|
||||
this( null, null, null );
|
||||
}
|
||||
|
||||
/**
|
||||
* For use as an incoming command.
|
||||
*
|
||||
* @param user User that is parting
|
||||
* @param channel Channel that the user is parting from
|
||||
* @param reason Reason for part
|
||||
*/
|
||||
public PartCommand( FullNick user, String channel, String reason )
|
||||
{
|
||||
this.user = user;
|
||||
this.reason = reason;
|
||||
this.channel = channel;
|
||||
}
|
||||
|
||||
/**
|
||||
* For use as an outgoing command.
|
||||
*
|
||||
* @param channel Channel that we are parting from
|
||||
* @param reason Reason we are parting
|
||||
*/
|
||||
public PartCommand( String channel, String reason )
|
||||
{
|
||||
this( null, channel, reason );
|
||||
}
|
||||
|
||||
/**
|
||||
* For use as an outgoing command. Part with no reason.
|
||||
*
|
||||
* @param channel Channel that we are parting from
|
||||
*/
|
||||
public PartCommand( String channel )
|
||||
{
|
||||
this( null, channel, null );
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new PartCommand( new FullNick( prefix ), getParameter( params, 0 ), getParameter( params, 1 ) );
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "PART";
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
if( reason != null )
|
||||
return channel + " :" + reason;
|
||||
else
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getReason()
|
||||
{
|
||||
return reason;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public FullNick getUser()
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
/** Takes client state action. If we are parting, then remove that
|
||||
* channel from our list of channels. If someone else is parting,
|
||||
* remove them from the channel they are parting from.
|
||||
*/
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
// We parted
|
||||
if( user.equals( state.getNick() ) )
|
||||
{
|
||||
state.removeChannel( channel );
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Someone else parted.
|
||||
|
||||
// 1) Grab channel
|
||||
Channel chanObj = state.getChannel( channel );
|
||||
|
||||
// 2) Remove user
|
||||
chanObj.removeMember( user, this );
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
|
||||
/**
|
||||
* Defines PASS command, optional part of the handshake to register on the network.
|
||||
* @author Daniel Henninger
|
||||
*/
|
||||
public class PassCommand implements OutCommand
|
||||
{
|
||||
private String pass;
|
||||
|
||||
public static final String IDENTIFIER = "PASS";
|
||||
|
||||
/**
|
||||
* @param pass the password for the user who is authenticating
|
||||
* */
|
||||
public PassCommand(String pass)
|
||||
{
|
||||
this.pass = pass;
|
||||
}
|
||||
|
||||
public String render()
|
||||
{
|
||||
return IDENTIFIER + " " + pass;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return IDENTIFIER;
|
||||
}
|
||||
|
||||
}
|
|
@ -1,67 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
|
||||
|
||||
/**
|
||||
* Defines the PING command. At this point, PINGs only come in from
|
||||
* the server, so all we need to do is capture the parameters.
|
||||
*/
|
||||
public class PingCommand extends AbstractCommand
|
||||
{
|
||||
|
||||
private String pingSource;
|
||||
|
||||
/** Factory */
|
||||
public PingCommand()
|
||||
{
|
||||
pingSource = null;
|
||||
}
|
||||
|
||||
public PingCommand( String source )
|
||||
{
|
||||
pingSource = source;
|
||||
}
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
String str = getParameter( params, 0 );
|
||||
return new PingCommand( str );
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the string IRC uses to identify this command. Examples:
|
||||
* NICK, PING, KILL, 332
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "PING";
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the parameters of this command.
|
||||
*/
|
||||
public String renderParams()
|
||||
{
|
||||
return ":" + pingSource;
|
||||
}
|
||||
|
||||
// ===== Ping-specific methods =======================================
|
||||
public String getPingSource()
|
||||
{
|
||||
return pingSource;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
|
||||
/**
|
||||
* Defines the PONG command. At this point, PONGs can only be sent to
|
||||
* the server, so all we need to do is provide render().
|
||||
*/
|
||||
public class PongCommand extends PingCommand
|
||||
{
|
||||
|
||||
public PongCommand( String dest )
|
||||
{
|
||||
super( dest );
|
||||
}
|
||||
|
||||
/**
|
||||
* PONG shouldn't be sent to us.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
throw new UnsupportedOperationException("PONG is not an incommand.");
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "PONG";
|
||||
}
|
||||
|
||||
// ===== Pong-specific methods =======================================
|
||||
public String getPongDest()
|
||||
{
|
||||
return getPingSource();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,132 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.Enumeration;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* <p>Defines QUIT command. The QUIT command asks the irc server to
|
||||
* disconnect us, and we can optionally give a reason. The QUIT
|
||||
* command is also received by us if someone on a channel we are on
|
||||
* quits.</p>
|
||||
*
|
||||
* <p>What should be done to signal to the framework that the
|
||||
* disconnection that should come from the server is legit, and we
|
||||
* shouldn't try to re-connecet? For now it will be assumed that the
|
||||
* user of the framework will signal all the appropriate classes that
|
||||
* a legit disconnection will happen (ie AutoRegister which will try
|
||||
* to re-connect otherwise).</p>
|
||||
*/
|
||||
public class QuitCommand extends AbstractCommand
|
||||
{
|
||||
//static Logger log = Logger.getLogger(QuitCommand.class);
|
||||
|
||||
private String reason;
|
||||
private FullNick user;
|
||||
|
||||
/** For use as a factory */
|
||||
public QuitCommand()
|
||||
{
|
||||
this( null, null );
|
||||
}
|
||||
|
||||
/**
|
||||
* For use as an incoming command.
|
||||
*
|
||||
* @param user User that has quit
|
||||
* @param reason Specified reason for quitting
|
||||
*/
|
||||
public QuitCommand( FullNick user, String reason )
|
||||
{
|
||||
this.user = user;
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
/**
|
||||
* For use as an outgoing command.
|
||||
*
|
||||
* @param reason Specified reason for quitting
|
||||
*/
|
||||
public QuitCommand( String reason )
|
||||
{
|
||||
this( null, reason );
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new QuitCommand( new FullNick( prefix ), getParameter( params, 0 ) );
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "QUIT";
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
return ":" + reason;
|
||||
}
|
||||
|
||||
public String getReason()
|
||||
{
|
||||
return reason;
|
||||
}
|
||||
|
||||
public FullNick getUser()
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if we are the ones quitting.
|
||||
*
|
||||
* @param state Client state we are checking against
|
||||
* @return True or false if the quit is us quitting
|
||||
*/
|
||||
public boolean isOurQuit( ClientState state )
|
||||
{
|
||||
return user.equals( state.getNick() );
|
||||
}
|
||||
|
||||
/** If we are quitting, we won't be worrying about our client state.
|
||||
* If someone else is leaving, then remove them from all the groups
|
||||
* they are in.
|
||||
*/
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
//log.debug( "Nick: " + state.getNick().toString() );
|
||||
if( isOurQuit(state) )
|
||||
{
|
||||
// We've quit
|
||||
//log.debug("QUIT: We've quit: " + reason);
|
||||
|
||||
// What should we do with the client state here?
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Someone else quit. We need to remove them from each group
|
||||
// they are in.
|
||||
//log.debug("QUIT: " + user + " quit: " + reason);
|
||||
|
||||
// 1) Grab channels
|
||||
Enumeration channelNames = state.getChannelNames();
|
||||
while( channelNames.hasMoreElements() )
|
||||
{
|
||||
String chanName = channelNames.nextElement().toString();
|
||||
|
||||
// 2) Remove from group.
|
||||
Channel channelObj = state.getChannel( chanName);
|
||||
channelObj.removeMember( user, this );
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
|
||||
public class RawCommand implements OutCommand
|
||||
{
|
||||
|
||||
private String sourceString;
|
||||
private String ident;
|
||||
|
||||
/**
|
||||
* Tries to use the first "word" in the command as the identifier.
|
||||
* Using this constructor is not recommended.
|
||||
*
|
||||
* @param raw Raw command to send to server
|
||||
*/
|
||||
public RawCommand( String raw )
|
||||
{
|
||||
sourceString = raw;
|
||||
StringTokenizer tokens = new StringTokenizer( raw );
|
||||
ident = tokens.nextToken();
|
||||
}
|
||||
|
||||
/**
|
||||
* The rendered command will be <code>identifier + " " +
|
||||
* parameters</code>. This constructure simply allows a correct
|
||||
* response to the <code>getIrcIdentifier</code> method.
|
||||
*
|
||||
* @param identifier Command identifier
|
||||
* @param parameters Parameters to pass
|
||||
*/
|
||||
public RawCommand( String identifier, String parameters )
|
||||
{
|
||||
ident = identifier;
|
||||
sourceString = ident + " " + parameters;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the identifier, if supplied, or null.
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return ident;
|
||||
}
|
||||
|
||||
/**
|
||||
* Simply returns the string given in the constructor.
|
||||
*/
|
||||
public String render()
|
||||
{
|
||||
return sourceString;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.Date;
|
||||
|
||||
import f00f.net.irc.martyr.CommandRegister;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.Channel;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
|
||||
public class TopicCommand extends AbstractCommand
|
||||
{
|
||||
//static Logger log = Logger.getLogger(TopicCommand.class);
|
||||
|
||||
private String channel;
|
||||
private String topic;
|
||||
|
||||
public static final String IDENTIFIER_PRIMARY = "TOPIC";
|
||||
public static final String IDENTIFIER_SECONDARY = "332";
|
||||
|
||||
public TopicCommand()
|
||||
{
|
||||
this( null, null );
|
||||
}
|
||||
|
||||
public TopicCommand( String channel, String topic )
|
||||
{
|
||||
this.channel = channel;
|
||||
this.topic = topic;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
//
|
||||
// This command uses "TOPIC" on outgoing, so that is why we use
|
||||
// "TOPIC" here instead of "332".
|
||||
//
|
||||
return IDENTIFIER_PRIMARY;
|
||||
}
|
||||
|
||||
public void selfRegister( CommandRegister commandRegister )
|
||||
{
|
||||
commandRegister.addCommand( IDENTIFIER_PRIMARY, this );
|
||||
commandRegister.addCommand( IDENTIFIER_SECONDARY, this );
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
// when the command is used as a reply, the nick is parameter 0.
|
||||
if( identifier.equals( IDENTIFIER_SECONDARY ) )
|
||||
return new TopicCommand( getParameter(params, 1), getParameter(params, 2) );
|
||||
else
|
||||
return new TopicCommand( getParameter(params, 0), getParameter(params, 1) );
|
||||
}
|
||||
|
||||
public String renderParams()
|
||||
{
|
||||
return getChannel() + " :" + getTopic();
|
||||
}
|
||||
|
||||
public String getTopic()
|
||||
{
|
||||
return topic;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
//log.debug("Topic: Channel: " + channel);
|
||||
Channel chan = state.getChannel( channel );
|
||||
chan.setTopic( topic );
|
||||
chan.setTopicDate( new Date() );
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
|
||||
|
||||
/**
|
||||
* Some unknown command, for which there is no factory. This is a
|
||||
* special case command, created by IRCConnection if it can't find a
|
||||
* proper command object.
|
||||
*/
|
||||
public class UnknownCommand extends AbstractInCommand
|
||||
{
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Never parsed.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
throw new UnsupportedOperationException("UnknownCommand does no parsing.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Unknown, so we don't know what the identifier is ahead of time.
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.IRCConnection;
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
/**
|
||||
* Defines USER command, part of the handshake to register on the
|
||||
* network.
|
||||
*/
|
||||
public class UserCommand implements OutCommand
|
||||
{
|
||||
|
||||
private String name;
|
||||
private String user;
|
||||
private String someA; // Might be a mode on some networks
|
||||
private String someB; // might be ignored
|
||||
|
||||
public static final String IDENTIFIER = "USER";
|
||||
|
||||
/**
|
||||
* @param user the login name on the computer the client is on
|
||||
* @param name the purported full name of the user, can be anything.
|
||||
* @param connection the connection the user command is affiliated with
|
||||
* */
|
||||
public UserCommand( String user, String name, IRCConnection connection )
|
||||
{
|
||||
this.name = name;
|
||||
this.user = user;
|
||||
//localhost = connection.getLocalhost();
|
||||
//remotehost = connection.getRemotehost();
|
||||
someA = "0"; // Can be 0|4|8, with 4=+w, 8=+i
|
||||
someB = connection.getRemotehost(); // ignored, apparently
|
||||
}
|
||||
|
||||
public String render()
|
||||
{
|
||||
return IDENTIFIER + " " + user + " " + someA + " " + someB + " :" + name;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return IDENTIFIER;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.modes.user.InvisibleMode;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* Defines a user MODE command.
|
||||
*/
|
||||
public class UserModeCommand extends ModeCommand
|
||||
{
|
||||
static Logger log = Logger.getLogger(ModeCommand.class.getName());
|
||||
|
||||
private FullNick user;
|
||||
private FullNick sender;
|
||||
//private List modes;
|
||||
|
||||
private static HashMap<Character,Mode> modeTypes;
|
||||
|
||||
public UserModeCommand( String prefix, String userStr, StringTokenizer tokens )
|
||||
{
|
||||
// System.out.println( prefix );
|
||||
sender = new FullNick( prefix );
|
||||
user = new FullNick( userStr );
|
||||
|
||||
if( !sender.equals( user ) )
|
||||
{
|
||||
log.severe("UserModeCommand: Odd: mode change for a user that isn't us.");
|
||||
return;
|
||||
}
|
||||
|
||||
makeModeTypes();
|
||||
|
||||
//modes = parseModes( modeTypes, tokens );
|
||||
|
||||
// System.out.println( modes );
|
||||
}
|
||||
|
||||
private void makeModeTypes()
|
||||
{
|
||||
if( modeTypes == null )
|
||||
{
|
||||
modeTypes = new HashMap<Character,Mode>();
|
||||
|
||||
// Add new mode types here
|
||||
registerMode( modeTypes, new InvisibleMode() );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Should not be called, as ModeCommand does the parsing and instantiation
|
||||
* of this class.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
throw new IllegalStateException( "Don't call this method!" );
|
||||
}
|
||||
|
||||
public String render()
|
||||
{
|
||||
throw new UnsupportedOperationException("Can't send user modes, yet." );
|
||||
}
|
||||
|
||||
public FullNick getUser()
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
public FullNick getSender() {
|
||||
return sender;
|
||||
}
|
||||
|
||||
{
|
||||
//log.debug("TODO: UserModeCommand: Can't send");
|
||||
//log.debug("TODO: UserModeCommand: Does not update client state");
|
||||
}
|
||||
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
// TODO implement
|
||||
return false;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return "UserModeCommand";
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.CommandRegister;
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.clientstate.ClientState;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
import f00f.net.irc.martyr.util.ParameterIterator;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
|
||||
/**
|
||||
* Defines the commands that a server issues to welcome us. These are
|
||||
* identified with 001, 002... etc. These commands are only received
|
||||
* after we register, unlike the NOTICE command.
|
||||
*/
|
||||
public class WelcomeCommand extends AbstractInCommand
|
||||
{
|
||||
static Logger log = Logger.getLogger(WelcomeCommand.class.getName());
|
||||
|
||||
private String notice;
|
||||
private String nick;
|
||||
|
||||
/** Factory */
|
||||
public WelcomeCommand()
|
||||
{
|
||||
this( null, null );
|
||||
}
|
||||
|
||||
/**
|
||||
* Used by parse to create an instance of WelcomeCommand.
|
||||
*
|
||||
* @param nick Nick that send the welcome
|
||||
* @param notice Notice that was sent
|
||||
* */
|
||||
public WelcomeCommand( String nick, String notice )
|
||||
{
|
||||
this.notice = notice;
|
||||
this.nick = nick;
|
||||
//log.debug("WelcomeCommand: Nick is: `" + nick + "'");
|
||||
//log.debug("WelcomeCommand: Notice is: `"+notice+"'");
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a string and produces a formed command object, if it can.
|
||||
* Should return null if it cannot form the command object.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
ParameterIterator pi = new ParameterIterator( params );
|
||||
String nick = pi.next().toString();
|
||||
String notice;
|
||||
if( pi.hasNext() )
|
||||
{
|
||||
// We are looking at a "nick :msg" pair
|
||||
notice = pi.next().toString();
|
||||
}
|
||||
else
|
||||
{
|
||||
// There is only one parameter, a notice.
|
||||
notice = nick;
|
||||
nick = null;
|
||||
}
|
||||
if( pi.hasNext() )
|
||||
{
|
||||
//log.severe("WelcomeCommand: More than two parameters, confused.");
|
||||
}
|
||||
|
||||
|
||||
//String str = getParameter( params, 0 );
|
||||
//
|
||||
return new WelcomeCommand( nick, notice );
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the nick of the client state, if there is one included with
|
||||
* this command.
|
||||
*/
|
||||
public boolean updateClientState( ClientState state )
|
||||
{
|
||||
//log.debug("WelcomeCommand: updated client state with: " + new FullNick( nick ));
|
||||
state.setNick( new FullNick( nick ) );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the string IRC uses to identify this command. Examples:
|
||||
* NICK, PING, KILL, 332. In our case, there is no one thing.
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "001";
|
||||
}
|
||||
|
||||
public void selfRegister( CommandRegister commandRegister )
|
||||
{
|
||||
commandRegister.addCommand( "001", this );
|
||||
commandRegister.addCommand( "002", this );
|
||||
commandRegister.addCommand( "003", this );
|
||||
commandRegister.addCommand( "004", this );
|
||||
commandRegister.addCommand( "005", this );
|
||||
}
|
||||
|
||||
public String getNotice()
|
||||
{
|
||||
return notice;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the nick received with this command, or null if there isn't
|
||||
* one.
|
||||
* */
|
||||
public String getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return "WelcomeCommand";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.commands;
|
||||
|
||||
import f00f.net.irc.martyr.OutCommand;
|
||||
|
||||
/**
|
||||
* Implements a WHOIS command, to query details about a user.
|
||||
*
|
||||
*/
|
||||
public class WhoisCommand implements OutCommand
|
||||
{
|
||||
private static final String WHOIS = "WHOIS";
|
||||
|
||||
private String target;
|
||||
|
||||
/**
|
||||
* @param target the nick or mask that you wish to know about.
|
||||
*/
|
||||
public WhoisCommand( String target )
|
||||
{
|
||||
this.target = target;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return "WHOIS"
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return WHOIS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Simply returns the string given in the constructor.
|
||||
*/
|
||||
public String render()
|
||||
{
|
||||
return WHOIS + " " + target;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 462 ERR_ALREADYREGISTERED
|
||||
* :You may not reregister
|
||||
* Returned by the server to any link which tries to change part of the registered details (such as
|
||||
* password or user details from second USER message).
|
||||
*/
|
||||
public class AlreadyRegisteredError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public AlreadyRegisteredError()
|
||||
{
|
||||
}
|
||||
|
||||
public AlreadyRegisteredError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "462";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new AlreadyRegisteredError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 404 ERR_CANNOTSENDTOCHAN
|
||||
* <channel name> :Cannot send to channel
|
||||
* Sent to a user who is either (a) not on a channel which is mode +n or (b) not a chanop (or mode +v)
|
||||
* on a channel which has mode +m set and is trying to send a PRIVMSG message to that channel.
|
||||
*/
|
||||
public class CannotSendToChanError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public CannotSendToChanError()
|
||||
{
|
||||
}
|
||||
|
||||
public CannotSendToChanError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "404";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new CannotSendToChanError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 483 ERR_CANTKILLSERVER
|
||||
* :You can't kill a server!
|
||||
* Any attempts to use the KILL command on a server are to be refused and this
|
||||
* error returned directly to the client.
|
||||
*/
|
||||
public class CantKillServerError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public CantKillServerError()
|
||||
{
|
||||
}
|
||||
|
||||
public CantKillServerError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "483";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new CantKillServerError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 482 ERR_CHANOPRIVSNEEDED
|
||||
* <channel> :You're not channel operator
|
||||
* Any command requiring 'chanop' privileges (such as MODE messages) must return
|
||||
* this error if the client making the attempt is not a chanop on the specified
|
||||
* channel.
|
||||
*/
|
||||
public class ChanOPrivsNeededError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public ChanOPrivsNeededError()
|
||||
{
|
||||
}
|
||||
|
||||
public ChanOPrivsNeededError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "482";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new ChanOPrivsNeededError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
/*
|
||||
* ChannelBannedError.java
|
||||
*
|
||||
* Copyright (C) 2000, 2001, 2002, 2003 Ben Damm
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* See: http://www.fsf.org/copyleft/lesser.txt
|
||||
*/
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 474 ERR_BANNEDFROMCHAN
|
||||
* <channel> :Cannot join channel (+b)
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
* @version $Id: ChannelBannedError.java 85 2007-08-02 18:26:59Z jadestorm $
|
||||
* TODO: Should er rename this to BannedFromChanError to match others?
|
||||
*/
|
||||
public class ChannelBannedError extends GenericJoinError {
|
||||
public ChannelBannedError()
|
||||
{
|
||||
// This one's for registering.
|
||||
}
|
||||
|
||||
protected ChannelBannedError( String chan, String comment )
|
||||
{
|
||||
super(chan, comment);
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "474";
|
||||
}
|
||||
|
||||
protected InCommand create( String channel, String comment)
|
||||
{
|
||||
return new ChannelBannedError( channel, comment );
|
||||
}
|
||||
}
|
|
@ -1,48 +0,0 @@
|
|||
/*
|
||||
* ChannelInviteOnlyError.java
|
||||
*
|
||||
* Copyright (C) 2000, 2001, 2002, 2003 Ben Damm
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* See: http://www.fsf.org/copyleft/lesser.txt
|
||||
*/
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
/**
|
||||
* Code: 473 ERR_INVITEONLYCHAN
|
||||
* <channel> :Cannot join channel (+i)
|
||||
* @version $Id: ChannelInviteOnlyError.java 85 2007-08-02 18:26:59Z jadestorm $
|
||||
* TODO: Should we rename this to InviteOnlyChanError to match others?
|
||||
*/
|
||||
public class ChannelInviteOnlyError extends GenericJoinError
|
||||
{
|
||||
public ChannelInviteOnlyError()
|
||||
{
|
||||
// This one's for registering.
|
||||
}
|
||||
|
||||
protected ChannelInviteOnlyError( String chan, String comment )
|
||||
{
|
||||
super(chan, comment);
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "473";
|
||||
}
|
||||
|
||||
protected InCommand create(String channel, String comment)
|
||||
{
|
||||
return new ChannelInviteOnlyError( channel, comment );
|
||||
}
|
||||
}
|
|
@ -1,50 +0,0 @@
|
|||
/*
|
||||
* ChannelLimitError.java
|
||||
*
|
||||
* Copyright (C) 2000, 2001, 2002, 2003 Ben Damm
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* See: http://www.fsf.org/copyleft/lesser.txt
|
||||
*/
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 471 ERR_CHANNELISFULL
|
||||
* <channel> :Cannot join channel (+l)
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
* @version $Id: ChannelLimitError.java 85 2007-08-02 18:26:59Z jadestorm $
|
||||
* TODO: Rename to ChannelIsFullError to match style of others?
|
||||
*/
|
||||
public class ChannelLimitError extends GenericJoinError
|
||||
{
|
||||
public ChannelLimitError()
|
||||
{
|
||||
// This one's for registering.
|
||||
}
|
||||
|
||||
protected ChannelLimitError( String chan, String comment )
|
||||
{
|
||||
super(chan, comment);
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "471";
|
||||
}
|
||||
|
||||
protected InCommand create(String channel, String comment)
|
||||
{
|
||||
return new ChannelLimitError( channel, comment );
|
||||
}
|
||||
}
|
|
@ -1,50 +0,0 @@
|
|||
/*
|
||||
* ChannelWrongKeyError.java
|
||||
*
|
||||
* Copyright (C) 2000, 2001, 2002, 2003 Ben Damm
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* See: http://www.fsf.org/copyleft/lesser.txt
|
||||
*/
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 475 ERR_BADCHANNELKEY
|
||||
* <channel> :Cannot join channel (+k)
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
* @version $Id: ChannelWrongKeyError.java 85 2007-08-02 18:26:59Z jadestorm $
|
||||
* TODO: Should we rename to BadChannelKeyError to match others?
|
||||
*/
|
||||
public class ChannelWrongKeyError extends GenericJoinError
|
||||
{
|
||||
public ChannelWrongKeyError()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
protected ChannelWrongKeyError(String chan, String comment)
|
||||
{
|
||||
super(chan, comment);
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "475";
|
||||
}
|
||||
|
||||
protected InCommand create(String channel, String comment) {
|
||||
return new ChannelWrongKeyError(channel, comment);
|
||||
}
|
||||
|
||||
}
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 432 ERR_ERRONEUSNICKNAME
|
||||
* <nick> :Erroneus nickname
|
||||
* Returned after receiving a NICK message which contains characters which do not fall in the defined set.
|
||||
*/
|
||||
public class ErroneusNicknameError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String errorMessage;
|
||||
|
||||
public ErroneusNicknameError()
|
||||
{
|
||||
}
|
||||
|
||||
public ErroneusNicknameError(FullNick nick, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "432";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new ErroneusNicknameError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 424 ERR_FILEERROR
|
||||
* :File error doing <file op> on <file>
|
||||
* Generic error message used to report a failed file operation during the processing of a message.
|
||||
*/
|
||||
public class FileErrorError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public FileErrorError()
|
||||
{
|
||||
}
|
||||
|
||||
public FileErrorError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "424";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new FileErrorError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.commands.AbstractInCommand;
|
||||
|
||||
/**
|
||||
* Defines what an error is. All errors are commands.
|
||||
*/
|
||||
public abstract class GenericError extends AbstractInCommand
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
/*
|
||||
* GenericJoinError.java
|
||||
*
|
||||
* Copyright (C) 2000, 2001, 2002, 2003 Ben Damm
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* See: http://www.fsf.org/copyleft/lesser.txt
|
||||
*/
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.util.ParameterIterator;
|
||||
|
||||
/**
|
||||
* @author <a href="mailto:martyr@mog.se">Morgan Christiansson</a>
|
||||
* @version $Id: GenericJoinError.java 31 2004-04-01 22:02:33Z bdamm $
|
||||
*/
|
||||
public abstract class GenericJoinError extends GenericError {
|
||||
private String channel;
|
||||
private String comment;
|
||||
|
||||
public GenericJoinError() {
|
||||
}
|
||||
|
||||
protected GenericJoinError(String chan, String comment)
|
||||
{
|
||||
this.channel = chan;
|
||||
this.comment = comment;
|
||||
}
|
||||
|
||||
protected abstract InCommand create(String channel, String comment);
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getComment()
|
||||
{
|
||||
return comment;
|
||||
}
|
||||
|
||||
public State getState() {
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
ParameterIterator pI = new ParameterIterator( params );
|
||||
|
||||
pI.next(); // We know what our name is.
|
||||
String channel = (String)pI.next();
|
||||
String comment = (String)pI.next();
|
||||
|
||||
return create( channel, comment );
|
||||
}
|
||||
}
|
|
@ -1,45 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 467 ERR_KEYSEY
|
||||
* <channel> :Channel key already set
|
||||
*/
|
||||
public class KeySetError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public KeySetError()
|
||||
{
|
||||
}
|
||||
|
||||
public KeySetError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "467";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new KeySetError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
public class LoadTooHighError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String command;
|
||||
private String errorMessage;
|
||||
|
||||
public LoadTooHighError()
|
||||
{
|
||||
}
|
||||
|
||||
public LoadTooHighError(FullNick nick, String command, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.command = command;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "263";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new LoadTooHighError(new FullNick(getParameter(params, 1)), getParameter(params, 2), getParameter(params, 3));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getCommand()
|
||||
{
|
||||
return command;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 461 ERR_NEEDMOREPARAMS
|
||||
* <command> :Not enough parameters
|
||||
* Returned by the server by numerous commands to indicate to the client that it didn't
|
||||
* supply enough parameters.
|
||||
*/
|
||||
public class NeedMoreParamsError extends GenericError
|
||||
{
|
||||
private String command;
|
||||
private String errorMessage;
|
||||
|
||||
public NeedMoreParamsError()
|
||||
{
|
||||
}
|
||||
|
||||
public NeedMoreParamsError(String command, String errorMessage)
|
||||
{
|
||||
this.command = command;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "461";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NeedMoreParamsError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getCommand()
|
||||
{
|
||||
return command;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 436 ERR_NICKCOLLISION
|
||||
* <nick> :Nickname collision KILL
|
||||
* Returned by a server to a client when it detects a nickname collision (registered of a NICK that
|
||||
* already exists by another server).
|
||||
*/
|
||||
public class NickCollisionError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String errorMessage;
|
||||
|
||||
public NickCollisionError()
|
||||
{
|
||||
}
|
||||
|
||||
public NickCollisionError(FullNick nick, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "436";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NickCollisionError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
/*
|
||||
* Original version: Ben Damm <bdamm@dammfine.com>
|
||||
* Changes by: Mog
|
||||
* - Retains the nick that is in use
|
||||
* */
|
||||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 433 ERR_ERRONEUSNICKNAME
|
||||
* <nick> :Nickname is already in use
|
||||
* Returned when a NICK message is processed that result in an attempt to change
|
||||
* to a currently existing nickname.
|
||||
* TODO: Should we rename this to NicknameInUseError for consistency with rest of errors/matching RFC?
|
||||
*/
|
||||
public class NickInUseError extends GenericError
|
||||
{
|
||||
private FullNick _nick;
|
||||
String errorMessage;
|
||||
|
||||
public NickInUseError()
|
||||
{
|
||||
_nick = null;
|
||||
}
|
||||
public NickInUseError(FullNick nick, String errorMessage)
|
||||
{
|
||||
_nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "433";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NickInUseError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The nick in use.
|
||||
*/
|
||||
public FullNick getNick()
|
||||
{
|
||||
return _nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 423 ERR_NOADMININFO
|
||||
* <server name> :No administrative info available
|
||||
* Returned by a server in response to an ADMIN message when there is an error in finding the
|
||||
* appropriate information.
|
||||
*/
|
||||
public class NoAdminInfoError extends GenericError
|
||||
{
|
||||
private String server;
|
||||
private String errorMessage;
|
||||
|
||||
public NoAdminInfoError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoAdminInfoError(String server, String errorMessage)
|
||||
{
|
||||
this.server = server;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "423";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoAdminInfoError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getServer()
|
||||
{
|
||||
return server;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 444 ERR_NOLOGIN
|
||||
* <user> :User not logged in
|
||||
* Returned by the summon after a SUMMON command for a user was unable to be performed
|
||||
* since they were not logged in.
|
||||
*/
|
||||
public class NoLoginError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String errorMessage;
|
||||
|
||||
public NoLoginError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoLoginError(FullNick nick, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "444";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoLoginError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 422 ERR_NOMOTD
|
||||
* :MOTD File is missing
|
||||
* Server's MOTD file could not be opened by the server.
|
||||
*/
|
||||
public class NoMotdError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoMotdError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoMotdError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "422";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoMotdError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 431 ERR_NONICKNAMEGIVEN
|
||||
* :No nickname given
|
||||
* Returned when a nickname parameter expected for a command and isn't found.
|
||||
*/
|
||||
public class NoNicknameGivenError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoNicknameGivenError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoNicknameGivenError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "431";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoNicknameGivenError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 491 ERR_NOOPERHOST
|
||||
* :No O-lines for your host
|
||||
* If a client sends an OPER message and the server has not been configured to allow
|
||||
* connections from the client's host as an operator, this error must be returned.
|
||||
*/
|
||||
public class NoOperHostError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoOperHostError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoOperHostError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "491";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoOperHostError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 409 ERR_NOORIGIN
|
||||
* :No origin specified
|
||||
* PING or PONG message missing the originator parameter which is required since these commands must
|
||||
* work without valid prefixes.
|
||||
*/
|
||||
public class NoOriginError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoOriginError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoOriginError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "409";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoOriginError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 463 ERR_NOPERMFORHOST
|
||||
* :Your host isn't among the privileged
|
||||
* Returned to a client which attempts to register with a server which does not been setup to allow
|
||||
* connections from the host the attempted connection is tried.
|
||||
*/
|
||||
public class NoPermForHostError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoPermForHostError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoPermForHostError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "463";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoPermForHostError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 481 ERR_NOPRIVILEGES
|
||||
* :Permission Denied- You're not an IRC operator
|
||||
* Any command requiring operator privileges to operate must return this error to
|
||||
* indicate the attempt was unsuccessful.
|
||||
*/
|
||||
public class NoPrivilegesError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoPrivilegesError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoPrivilegesError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "481";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoPrivilegesError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 411 ERR_NORECIPIENT
|
||||
* :No recipient given (<command>)
|
||||
*/
|
||||
public class NoRecipientError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoRecipientError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoRecipientError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "411";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoRecipientError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 403 ERR_NOSUCHCHANNEL
|
||||
* <channel name> :No such channel
|
||||
* Used to indicate the given channel name is invalid.
|
||||
*/
|
||||
public class NoSuchChannelError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public NoSuchChannelError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoSuchChannelError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "403";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoSuchChannelError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 401 ERR_NOSUCHNICK
|
||||
* <nickname> :No such nick/channel
|
||||
* Used to indicated the nickname parameter supplied to a command is currently unused.
|
||||
*/
|
||||
public class NoSuchNickError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String errorMessage;
|
||||
|
||||
public NoSuchNickError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoSuchNickError(FullNick nick, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "401";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoSuchNickError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 402 ERR_NOSUCHSERVER
|
||||
* <server name> :No such server
|
||||
* Used to indicate the server name given currently doesn't exist.
|
||||
*/
|
||||
public class NoSuchServerError extends GenericError
|
||||
{
|
||||
private String server;
|
||||
private String errorMessage;
|
||||
|
||||
public NoSuchServerError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoSuchServerError(String server, String errorMessage)
|
||||
{
|
||||
this.server = server;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "402";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoSuchServerError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getServer()
|
||||
{
|
||||
return server;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 412 ERR_NOTEXTTOSEND
|
||||
* :No text to send
|
||||
* 412 - 414 are returned by PRIVMSG to indicate that the message wasn't delivered for some reason.
|
||||
* ERR_NOTOPLEVEL and ERR_WILDTOPLEVEL are errors that are returned when an invalid use of
|
||||
* "PRIVMSG $<server>" or "PRIVMSG #<host>" is attempted.
|
||||
*/
|
||||
public class NoTextToSendError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NoTextToSendError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoTextToSendError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "412";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoTextToSendError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 413 ERR_NOTOPLEVEL
|
||||
* <mask> :No toplevel domain specified
|
||||
* 412 - 414 are returned by PRIVMSG to indicate that the message wasn't delivered for some reason.
|
||||
* ERR_NOTOPLEVEL and ERR_WILDTOPLEVEL are errors that are returned when an invalid use of
|
||||
* "PRIVMSG $<server>" or "PRIVMSG #<host>" is attempted.
|
||||
*/
|
||||
public class NoTopLevelError extends GenericError
|
||||
{
|
||||
private String mask;
|
||||
private String errorMessage;
|
||||
|
||||
public NoTopLevelError()
|
||||
{
|
||||
}
|
||||
|
||||
public NoTopLevelError(String mask, String errorMessage)
|
||||
{
|
||||
this.mask = mask;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "413";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NoTopLevelError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getMask()
|
||||
{
|
||||
return mask;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 442 ERR_NOTONCHANNEL
|
||||
* <channel> :You're not on that channel
|
||||
* Returned by the server whenever a client tries to perform a channel effecting command for which the
|
||||
* client isn't a member.
|
||||
*/
|
||||
public class NotOnChannelError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public NotOnChannelError()
|
||||
{
|
||||
}
|
||||
|
||||
public NotOnChannelError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "442";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NotOnChannelError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 451 ERR_NOTREGISTERED
|
||||
* :You have not registered
|
||||
* Returned by the server to indicate that the client must be registered before the
|
||||
* server will allow it to be parsed in detail.
|
||||
*/
|
||||
public class NotRegisteredError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public NotRegisteredError()
|
||||
{
|
||||
}
|
||||
|
||||
public NotRegisteredError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "451";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new NotRegisteredError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 464 ERR_PASSWDMISMATCH
|
||||
* :Password incorrect
|
||||
* Returned to indicate a failed attempt at registering a connection for which a
|
||||
* password was required and was either not given or incorrect.
|
||||
*/
|
||||
public class PasswdMismatchError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public PasswdMismatchError()
|
||||
{
|
||||
}
|
||||
|
||||
public PasswdMismatchError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "464";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new PasswdMismatchError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 445 ERR_SUMMONDISABLED
|
||||
* :SUMMON has been disabled
|
||||
* Returned as a response to the SUMMON command. Must be returned by any server
|
||||
* which does not implement it.
|
||||
*/
|
||||
public class SummonDisabledError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public SummonDisabledError()
|
||||
{
|
||||
}
|
||||
|
||||
public SummonDisabledError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "445";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new SummonDisabledError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 405 ERR_TOOMANYCHANNELS
|
||||
* <channel name> :You have joined too many channels
|
||||
* Sent to a user when they have joined the maximum number of allowed channels and they try to join another channel.
|
||||
*/
|
||||
public class TooManyChannelsError extends GenericError
|
||||
{
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public TooManyChannelsError()
|
||||
{
|
||||
}
|
||||
|
||||
public TooManyChannelsError(String channel, String errorMessage)
|
||||
{
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "405";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new TooManyChannelsError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 407 ERR_TOOMANYTARGETS
|
||||
* <target> :Duplicate recipients. No message delivered
|
||||
* Returned to a client which is attempting to send a PRIVMSG/NOTICE using the user@host destination
|
||||
* format and for a user@host which has several occurrences.
|
||||
*/
|
||||
public class TooManyTargetsError extends GenericError
|
||||
{
|
||||
private String dest;
|
||||
private String errorMessage;
|
||||
|
||||
public TooManyTargetsError()
|
||||
{
|
||||
}
|
||||
|
||||
public TooManyTargetsError(String dest, String errorMessage)
|
||||
{
|
||||
this.dest = dest;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "407";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new TooManyTargetsError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getDest()
|
||||
{
|
||||
return dest;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 501 ERR_UMODEUNKNOWNFLAG
|
||||
* :Unknown MODE flag
|
||||
* Returned by the server to indicate that a MODE message was sent with a nickname
|
||||
* parameter and that the a mode flag sent was not recognized.
|
||||
*/
|
||||
public class UModeUnknownFlagError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public UModeUnknownFlagError()
|
||||
{
|
||||
}
|
||||
|
||||
public UModeUnknownFlagError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "501";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UModeUnknownFlagError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 421 ERR_UNKNOWNCOMMAND
|
||||
* <command> :Unknown command
|
||||
* Returned to a registered client to indicate that the command sent is unknown by the server.
|
||||
*/
|
||||
public class UnknownCommandError extends GenericError
|
||||
{
|
||||
private String command;
|
||||
private String errorMessage;
|
||||
|
||||
public UnknownCommandError()
|
||||
{
|
||||
}
|
||||
|
||||
public UnknownCommandError(String command, String errorMessage)
|
||||
{
|
||||
this.command = command;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "421";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UnknownCommandError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getCommand()
|
||||
{
|
||||
return command;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.State;
|
||||
import f00f.net.irc.martyr.commands.UnknownCommand;
|
||||
|
||||
|
||||
/**
|
||||
* Some unknown command, for which there is no factory. This is a
|
||||
* special case command, created by IRCConnection if it can't find a
|
||||
* proper command object.
|
||||
*/
|
||||
public class UnknownError extends UnknownCommand
|
||||
{
|
||||
|
||||
private String errorStr;
|
||||
private int errorCode;
|
||||
|
||||
public UnknownError( String ident )
|
||||
{
|
||||
errorStr = ident;
|
||||
errorCode = Integer.parseInt( ident );
|
||||
}
|
||||
|
||||
public int getErrorCode()
|
||||
{
|
||||
return errorCode;
|
||||
}
|
||||
|
||||
public String getError()
|
||||
{
|
||||
return errorStr;
|
||||
}
|
||||
|
||||
public static boolean isError( String ident )
|
||||
{
|
||||
char c = ident.charAt(0);
|
||||
return ( c == '4' || c == '5' );
|
||||
}
|
||||
|
||||
public State getState()
|
||||
{
|
||||
return State.UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* Never parsed.
|
||||
*/
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
throw new UnsupportedOperationException("UnknownError does no parsing.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Unknown, so we don't know what the identifier is ahead of time.
|
||||
*/
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return errorStr;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
return "UnknownError[" + errorStr + "]";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 472 ERR_UNKNOWNMODE
|
||||
* <char> :is unknown mode char to me
|
||||
*/
|
||||
public class UnknownModeError extends GenericError
|
||||
{
|
||||
private Character mode;
|
||||
private String errorMessage;
|
||||
|
||||
public UnknownModeError()
|
||||
{
|
||||
}
|
||||
|
||||
public UnknownModeError(Character mode, String errorMessage)
|
||||
{
|
||||
this.mode = mode;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "472";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UnknownModeError(getParameter(params, 1).charAt(0), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public Character getMode()
|
||||
{
|
||||
return mode;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 441 ERR_USERNOTINCHANNEL
|
||||
* <user> <channel> :They aren't on that channel
|
||||
* Returned by the server to indicate that the target user of the command is not on the given channel.
|
||||
*/
|
||||
public class UserNotInChannelError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public UserNotInChannelError()
|
||||
{
|
||||
}
|
||||
|
||||
public UserNotInChannelError(FullNick nick, String channel, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "441";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UserNotInChannelError(new FullNick(getParameter(params, 1)), getParameter(params, 2), getParameter(params, 3));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 443 ERR_USERONCHANNEL
|
||||
* <user> <channel> :is already on channel
|
||||
* Returned when a client tries to invite a user to a channel they are already on.
|
||||
*/
|
||||
public class UserOnChannelError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String channel;
|
||||
private String errorMessage;
|
||||
|
||||
public UserOnChannelError()
|
||||
{
|
||||
}
|
||||
|
||||
public UserOnChannelError(FullNick nick, String channel, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.channel = channel;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "443";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UserOnChannelError(new FullNick(getParameter(params, 1)), getParameter(params, 2), getParameter(params, 3));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getChannel()
|
||||
{
|
||||
return channel;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 446 ERR_USERSDISABLED
|
||||
* :USERS has been disabled
|
||||
* Returned as a response to the USERS command. Must be returned by any server which
|
||||
* does not implement it.
|
||||
*/
|
||||
public class UsersDisabledError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public UsersDisabledError()
|
||||
{
|
||||
}
|
||||
|
||||
public UsersDisabledError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "446";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UsersDisabledError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 502 ERR_USERSDONTMATCH
|
||||
* :Cant change mode for other users
|
||||
* Error sent to any user trying to view or change the user mode for a user other than themselves.
|
||||
*/
|
||||
public class UsersDontMatchError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public UsersDontMatchError()
|
||||
{
|
||||
}
|
||||
|
||||
public UsersDontMatchError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "502";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new UsersDontMatchError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
import f00f.net.irc.martyr.util.FullNick;
|
||||
|
||||
/**
|
||||
* Code: 406 ERR_WASNOSUCHNICK
|
||||
* <nickname> :There was no such nickname
|
||||
* Returned by WHOWAS to indicate there is no history information for that nickname.
|
||||
*/
|
||||
public class WasNoSuchNickError extends GenericError
|
||||
{
|
||||
private FullNick nick;
|
||||
private String errorMessage;
|
||||
|
||||
public WasNoSuchNickError()
|
||||
{
|
||||
}
|
||||
|
||||
public WasNoSuchNickError(FullNick nick, String errorMessage)
|
||||
{
|
||||
this.nick = nick;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "406";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new WasNoSuchNickError(new FullNick(getParameter(params, 1)), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public FullNick getNick()
|
||||
{
|
||||
return nick;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 414 ERR_WILDTOPLEVEL
|
||||
* <mask> :Wildcard in toplevel domain
|
||||
* 412 - 414 are returned by PRIVMSG to indicate that the message wasn't delivered for some reason.
|
||||
* ERR_NOTOPLEVEL and ERR_WILDTOPLEVEL are errors that are returned when an invalid use of
|
||||
* "PRIVMSG $<server>" or "PRIVMSG #<host>" is attempted.
|
||||
*/
|
||||
public class WildTopLevelError extends GenericError
|
||||
{
|
||||
private String mask;
|
||||
private String errorMessage;
|
||||
|
||||
public WildTopLevelError()
|
||||
{
|
||||
}
|
||||
|
||||
public WildTopLevelError(String mask, String errorMessage)
|
||||
{
|
||||
this.mask = mask;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "414";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new WildTopLevelError(getParameter(params, 1), getParameter(params, 2));
|
||||
}
|
||||
|
||||
public String getMask()
|
||||
{
|
||||
return mask;
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
package f00f.net.irc.martyr.errors;
|
||||
|
||||
import f00f.net.irc.martyr.InCommand;
|
||||
|
||||
/**
|
||||
* Code: 465 ERR_YOUREBANNEDCREEP
|
||||
* :You are banned from this server
|
||||
* Returned after an attempt to connect and register yourself with a server which has been setup to
|
||||
* explicitly deny connections to you.
|
||||
*/
|
||||
public class YoureBannedCreepError extends GenericError
|
||||
{
|
||||
private String errorMessage;
|
||||
|
||||
public YoureBannedCreepError()
|
||||
{
|
||||
}
|
||||
|
||||
public YoureBannedCreepError(String errorMessage)
|
||||
{
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
public String getIrcIdentifier()
|
||||
{
|
||||
return "465";
|
||||
}
|
||||
|
||||
public InCommand parse( String prefix, String identifier, String params )
|
||||
{
|
||||
return new YoureBannedCreepError(getParameter(params, 1));
|
||||
}
|
||||
|
||||
public String getErrorMessage()
|
||||
{
|
||||
return errorMessage;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
package f00f.net.irc.martyr.modes;
|
||||
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
|
||||
/**
|
||||
* GenericNode uses the character to specify the hash code. Thus, two
|
||||
* mode types are the same, in a hash table, even if they have
|
||||
* different parameters or positive/negative values.
|
||||
*/
|
||||
public abstract class GenericMode implements Mode
|
||||
{
|
||||
private String str;
|
||||
private Mode.Sign sign = Mode.Sign.NOSIGN;
|
||||
|
||||
public void setParam( String str )
|
||||
{
|
||||
this.str = str;
|
||||
}
|
||||
|
||||
public String getParam()
|
||||
{
|
||||
return str;
|
||||
}
|
||||
|
||||
public void setSign( Mode.Sign sign )
|
||||
{
|
||||
this.sign = sign;
|
||||
}
|
||||
|
||||
public Mode.Sign getSign()
|
||||
{
|
||||
return sign;
|
||||
}
|
||||
|
||||
public String toString()
|
||||
{
|
||||
String pString = " ";
|
||||
if( sign != Mode.Sign.NOSIGN )
|
||||
pString += ( sign == Mode.Sign.POSITIVE ? "+" : "-" );
|
||||
String className = this.getClass().getName();
|
||||
className = className.substring( className.indexOf('$')+1 );
|
||||
|
||||
String result = className + pString + getChar();
|
||||
if( requiresParam() )
|
||||
{
|
||||
result += " " + getParam();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public boolean equals( Object o )
|
||||
{
|
||||
if( o instanceof Mode )
|
||||
{
|
||||
Mode oMode = (Mode)o;
|
||||
|
||||
if( oMode.getParam() == null || this.getParam() == null )
|
||||
return oMode.getChar() == this.getChar();
|
||||
|
||||
if( oMode.getParam() == null && this.getParam() != null )
|
||||
return false;
|
||||
if( oMode.getParam() == null && this.getParam() == null )
|
||||
return oMode.getChar() == this.getChar();
|
||||
|
||||
return oMode.getChar() == this.getChar() &&
|
||||
oMode.getParam().equals(this.getParam());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public int hashCode()
|
||||
{
|
||||
return (int)getChar();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
This directory contains modes. Unlike commands, errors, and replies,
|
||||
these modes do NOT contain any information about the mode other than
|
||||
what it is. The Mode objects know if the mode takes a parameter, what
|
||||
character represents the mode, and contain a method to create a new
|
||||
instance of itself.
|
||||
|
||||
You can get and set parameters using the Mode related commands.
|
||||
|
|
@ -1,44 +0,0 @@
|
|||
package f00f.net.irc.martyr.modes.channel;
|
||||
|
||||
import f00f.net.irc.martyr.Mode;
|
||||
|
||||
/**
|
||||
* <p>The channel flag 'a' defines an anonymous channel. This means that
|
||||
* when a message sent to the channel is sent by the server to users,
|
||||
* and the origin is a user, then it MUST be masked. To mask the
|
||||
* message, the origin is changed to "anonymous!anonymous@anonymous."
|
||||
* (e.g., a user with the nickname "anonymous", the username "anonymous"
|
||||
* and from a host called "anonymous."). Because of this, servers MUST
|
||||
* forbid users from using the nickname "anonymous". Servers MUST also
|
||||
* NOT send QUIT messages for users leaving such channels to the other
|
||||
* channel members but generate a PART message instead.</p>
|
||||
*
|
||||
* <p>On channels with the character '&' as prefix, this flag MAY be
|
||||
* toggled by channel operators, but on channels with the character '!'
|
||||
* as prefix, this flag can be set (but SHALL NOT be unset) by the
|
||||
* "channel creator" only. This flag MUST NOT be made available on
|
||||
* other types of channels.</p>
|
||||
*
|
||||
* <p>Replies to the WHOIS, WHO and NAMES commands MUST NOT reveal the
|
||||
* presence of other users on channels for which the anonymous flag is
|
||||
* set.</p>
|
||||
* (From RFC2811)
|
||||
*/
|
||||
public class AnonChannelMode extends GenericChannelMode
|
||||
{
|
||||
public boolean requiresParam()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public char getChar()
|
||||
{
|
||||
return 'a';
|
||||
}
|
||||
|
||||
public Mode newInstance()
|
||||
{
|
||||
return new AnonChannelMode();
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user