public void Start(XmppConnection connection)
{
connection.Features = Stanza.Parse <Features>(connection.NextElement());
if (connection.Features.Bind)
{
var bind = new Elements.Bind(connection.Jid.Resource);
var iq = new XMPPIq(XMPPIq.IqTypes.set);
iq.Add(bind);
connection.Query(iq, (bindResult) =>
{
var jid = bindResult.Element(XNamespace.Get(Namespaces.XmppBind) + "bind");
if (jid == null)
{
return;
}
connection.Jid = new JID(jid.Element(XNamespace.Get(Namespaces.XmppBind) + "jid").Value);
if (connection.Features.Session)
{
var sess = new XElement(XNamespace.Get(Namespaces.XmppSession) + "session");
var sessIq = new XMPPIq(XMPPIq.IqTypes.set);
sessIq.Add(sess);
connection.Query(sessIq, (sessionResponse) => OnSessionStarted(connection));
}
else
{
OnSessionStarted(connection);
}
});
connection.SessionLoop();
}
}
public void Start(XmppConnection connection)
{
var auth = new SASLAuth();
auth.SetAttributeValue("mechanism", SASLMethod);
auth.SetValue(Initiate());
connection.Send(auth);
var authResponse = connection.NextElement();
var nextResponse = string.Empty;
Task.Run(() =>
{
while ((nextResponse = NextChallenge(authResponse.Value)) != "")
{
if (nextResponse == "error")
{
OnAuthenticationFailed(connection);
return;
}
var response = new SASLResponse();
response.SetValue(nextResponse);
connection.Send(response);
authResponse = connection.NextElement();
}
OnAuthenticated(connection);
});
}
public async Task <TlsSettings> ProvideAsync(XmppConnection xmppConnection)
{
return(await Task <TlsSettings> .Run(() =>
{
return new ClientTlsSettings(xmppConnection.XmppDomain);
}));
}
public void HandleError(XmppConnection connection, XMPPIq element)
{
if (element.IqType == XMPPIq.IqTypes.get || element.IqType == XMPPIq.IqTypes.set)
{
connection.Send(element.Error());
}
}
public void SendMessage(XmppConnection Connection, string To, string Message, bool IM)
{
if (!IM)
{
if (encrypt)
{
Connection.GetXmppClient().SendMessage(To, encryption.EncryptString(Message, Password));
}
else
{
Connection.GetXmppClient().SendMessage(To, Message);
}
}
else
{
if (encrypt)
{
Connection.GetXmppIm().SendMessage(To, encryption.EncryptString(Message, Password));
}
else
{
Connection.GetXmppIm().SendMessage(To, Message);
}
}
}
public ReconnectHandler(XmppConnection xmppCon)
{
this.xmppCon = xmppCon;
xmppCon
.XmppSessionState
.Subject
.DistinctUntilChanged()
.Skip(1)
.Subscribe(st =>
{
if (st == SessionState.Disconnected &&
shouldReconnect &&
!reconnecting)
{
// got disconnected
Task.Run(async() => await Reconnect());
}
});
xmppCon
.XmppSessionEvent
.Subject
.DistinctUntilChanged()
.Subscribe(se =>
{
if (se == SessionEvent.CallDisconnect)
{
// intented disconnect by user, no recconect required
this.shouldReconnect = false;
}
});
}
public BookmarksManager(XmppConnection conn, bool autoAsk = true)
{
connection = conn;
connection.SignedIn += (sender, e) =>
{
if (autoAsk)
{
var query = new XMPPIq(XMPPIq.IqTypes.get);
var priv = new XElement(XNamespace.Get("jabber:iq:private") + "query",
new XElement(XNamespace.Get(Namespaces.StorageBookmarks) + "storage")
);
query.Add(priv);
connection.Query(query, (response) =>
{
var roomsXML = response.Element(XNamespace.Get("jabber:iq:private") + "query")
.Element(XNamespace.Get(Namespaces.StorageBookmarks) + "storage")
.Elements(XNamespace.Get(Namespaces.StorageBookmarks) + "conference");
foreach (var roomObj in roomsXML)
{
var room = Stanza.Parse <BookmarkedConference>(roomObj);
Rooms.Add(room);
if (room.IsAutojoin)
{
Join(room);
}
}
OnBookmarksSynced(conn);
});
}
};
}
public static void Main(string[] args)
{
var host = args.Get("host");
var port = int.Parse(args.Get("port"));
var user = args.Get("user");
var domain = args.Get("domain");
var password = args.Get("password");
var recipient = args.Get("recipient");
var resource = args.Get("resource");
var timeout = int.Parse(args.Get("timeout"));
using (var xmpp = new XmppConnection(host, port, domain))
{
var pending = new BlockingCollection <XmlElement>();
var source = new CancellationTokenSource();
var commands = new Dictionary <string, Action>
{
{ "authenticate", () => xmpp.SendAuthenticate(user, password, resource) },
{ "connect", () => xmpp.Connect() },
{ "disconnect", () => source.Cancel() },
{ "register", () => xmpp.SendRegister(user, password) },
{ "message", () => xmpp.SendMessage($"{recipient}@{domain}", "Test message.") },
{ "presence", () => xmpp.SendPresence() },
{ "roster", () => xmpp.SendRoster() }
};
xmpp.OnElement += (_, e) => pending.Add(e);
xmpp.OnInternalException += (_, e) => Print(e);
Print($"Available commands: {string.Join(", ", commands.Keys)}.");
while (!source.Token.IsCancellationRequested)
{
Action action;
var currentTimeout = 300;
var command = Ask("command").Trim().ToLower();
if (command == string.Empty)
{
currentTimeout = timeout;
}
else if (commands.TryGetValue(command, out action))
{
action();
}
else
{
Print("Invalid command.");
}
PrintReceived(pending.TakeAll(currentTimeout));
}
}
}
public override bool Handle(XmppConnection sender, XMPPIq element)
{
if (Stanza.Parse <DiscoItems>(element.Elements().FirstOrDefault()) != null)
{
sender.Send(element.Reply());
return(true);
}
return(false);
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
/// <summary>
/// Basic Constructor
/// </summary>
/// <history>
/// 10/08/2018 Created [Fabian Sauter]
/// </history>
internal OmemoSessionBuildHelper(string chatJid, string bareAccountJid, string fullAccountJid, XmppConnection connection, OmemoHelper omemoHelper)
{
CONNECTION = connection;
CHAT_JID = chatJid;
BARE_ACCOUNT_JID = bareAccountJid;
FULL_ACCOUNT_JID = fullAccountJid;
OMEMO_HELPER = omemoHelper;
STATE = OmemoSessionBuildHelperState.NOT_STARTED;
}
/// <summary>
/// Initializes a new instance of the <see cref = "XmppRoster" /> class
/// </summary>
internal XmppRoster(XmppSession session)
{
this.session = session;
connection = session.Connection;
contacts = new ObservableCollection <XmppContact>();
pendingMessages = new List <string>();
SubscribeToSessionState();
}
private XmppConnection ConnectTo(string hostName, string userName, string password)
{
var connection = XmppConnection.CreateXmppConnection(hostName);
connection.Connect();
connection.Login(userName, password, AuctionResource);
return(connection);
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
internal OmemoSessionBuildHelper(string srcBareJid, string dstBareJid, XmppConnection connection, OmemoHelper omemoHelper, bool trustedSrcKeysOnly, bool trustedDstKeysOnly)
{
CONNECTION = connection;
SRC_BARE_JID = srcBareJid;
DST_BARE_JID = dstBareJid;
OMEMO_HELPER = omemoHelper;
TRUSTED_SRC_KEYS_ONLY = trustedSrcKeysOnly;
TRUSTED_DST_KEYS_ONLY = trustedDstKeysOnly;
STATE = OmemoSessionBuildHelperState.NOT_STARTED;
}
private void init(XMPPAccount account)
{
connection = new XmppConnection(account);
connection.NewRoosterMessage += Connection_ConnectionNewRoosterMessage;
connection.ConnectionStateChanged += Connection_ConnectionStateChanged;
connection.NewValidMessage += Connection_ConnectionNewValidMessage;
connection.NewPresenceMessage += Connection_ConnectionNewPresenceMessage;
connection.MessageSend += Connection_MessageSend;
connection.NewBookmarksResultMessage += Connection_NewBookmarksResultMessage;
connection.OmemoSessionBuildError += Connection_OmemoSessionBuildErrorEvent;
}
public Tests()
{
KillRunningApplication(ApplicationProcessName);
KillRunningApplication(ServerProcessName);
Process.Start(ServerPath);
Application application = Application.Launch(ApplicationPath);
_application = new ApplicationRunner(application);
_connection = new XmppConnection();
}
private void JoinAuction(XmppConnection connection, string itemId)
{
var formattedAuctionId = AuctionId(itemId, connection);
var chat = connection.ChatManager.CreateChat(formattedAuctionId, null);
const int bidAmount = 35;
IAuction auction = new XmppAuction(chat);
chat.AddMessageListener(
new AuctionMessageTranslator(connection.UserName, new Domain.AuctionSniper(auction, new SniperStateDisplayer(this))));
auction.Join();
}
public void Handle(XmppConnection sender, XMPPIq element)
{
bool handled = false;
PayloadHandlers.ForEach((h) =>
{
handled |= h.Handle(sender, element);
});
if (!handled)
{
HandleError(sender, element);
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "XmppSession" /> class
/// </summary>
public XmppSession()
{
State = XmppSessionState.LoggedOut;
avatarStorage = new AvatarStorage();
chats = new Dictionary <string, XmppChat>();
syncObject = new object();
connection = new XmppConnection();
serviceDiscovery = new XmppServiceDiscovery(this);
personalEventing = new XmppPersonalEventing(this);
activity = new XmppActivity(this);
clientCapabilitiesStorage = new XmppClientCapabilitiesStorage();
roster = new XmppRoster(this);
avatarStorage.Load();
clientCapabilitiesStorage.Load();
}
public override bool Handle(XmppConnection connection, XMPPIq element)
{
var info = Stanza.Parse <DiscoInfo>(element.Elements().FirstOrDefault());
if (info != null)
{
if (info.Node == string.Empty || info.Node == string.Format("{0}#{1}", _capabilities.Node, _capabilities.OurHash))
{
info.Identity = _capabilities.Identity;
info.Features = _capabilities.Features;
info.Node = _capabilities.Node;
var reply = element.Reply();
reply.RemoveNodes();
reply.Add(info);
connection.Send(reply);
return(true);
}
}
return(false);
}
public RosterManager(XmppConnection conn, bool autoAsk = true)
{
Roster = new ObservableCollection <RosterItem>();
conn.SignedIn += (sender, e) =>
{
if (autoAsk)
{
var query = new XMPPIq(XMPPIq.IqTypes.get);
query.Add(new XElement(XNamespace.Get(Namespaces.JabberRoster) + "query"));
conn.Query(query, (response) =>
{
var roster = response.Element(XNamespace.Get(Namespaces.JabberRoster) + "query")
.Elements(XNamespace.Get(Namespaces.JabberRoster) + "item");
foreach (var item in roster)
{
Roster.Add(Stanza.Parse <RosterItem>(item));
}
OnRosterUpdated(conn);
});
}
};
}
public IqManager(XmppConnection connection)
{
Connection = connection;
}
protected virtual void OnAuthenticationFailed(XmppConnection sender)
{
AuthenticationFailed(sender);
}
/// <summary>
/// Initializes a new instance of the <see cref = "T:XmppSaslPlainAuthenticator" /> class.
/// </summary>
public XmppSaslPlainAuthenticator(XmppConnection connection)
: base(connection)
{
waitEvent = new AutoResetEvent(false);
}
public FakeAuctionServer(string itemId)
{
ItemId = itemId;
_connection = XmppConnection.CreateXmppConnection(SharedConstants.XMPP_HOSTNAME);
}
public BoshClientSocket(XmppConnection con)
{
base.m_XmppCon = con;
}
public abstract bool Handle(XmppConnection sender, XMPPIq element);
public App()
{
XmppConnection = new XmppConnection();
}
public BoshClientSocket(XmppConnection con)
{
base.m_XmppCon = con;
}
public override bool Handle(XmppConnection sender, XMPPIq element)
{
var type = element.Attribute("type");
if (type == null)
{
return(false);
}
if (type.Equals("get"))
{
var query = element.Element("query");
if (query != null)
{
var ns = query.Attribute("xmlns");
var num = Array.IndexOf(Features, ns);
switch (num)
{
case 0:
var from = new JID(element.Attribute("from").Value);
_fields = _regHandler.GetCredentials(from);
var reply = element.Reply();
var instr = new Stanza("instructions")
{
Value = _regHandler.GetInstructions()
};
query.Add(instr);
foreach (string field in _fields.Keys)
{
var f = new Stanza(field)
{
Value = _fields[field]
};
query.Add(f);
}
sender.Send(reply);
return(true);
}
}
}
if (type.Equals("set"))
{
var query = element.Element("query");
if (query != null)
{
var ns = query.Attribute("xmlns");
var num = Array.IndexOf(Features, ns);
switch (num)
{
case 0:
var queryFields = FilterFields((Stanza)query, _fields);
var from = new JID(element.Attribute("from").Value);
var requestResult = queryFields.ContainsKey("remove") ? _regHandler.OnRegistrationRemove(from) : _regHandler.OnRegistrationRequest(from, queryFields);
if (requestResult)
{
var reply = element.Reply();
sender.Send(reply);
var subscribe = new XMPPPresence();
subscribe.SetAttributeValue("to", from.BareJid);
subscribe.SetAttributeValue("from", sender.Jid.BareJid);
if (queryFields.ContainsKey("remove"))
{
subscribe.SetAttributeValue("type", "unsubscribed");
sender.Send(subscribe);
subscribe.SetAttributeValue("type", "unsubscribe");
sender.Send(subscribe);
}
else
{
subscribe.SetAttributeValue("type", "subscribe");
sender.Send(subscribe);
}
}
else
{
sender.Send(element.Error());
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref = "XmppSession" /> class
/// </summary>
public XmppSession()
{
State = XmppSessionState.LoggedOut;
avatarStorage = new AvatarStorage();
chats = new Dictionary<string, XmppChat>();
syncObject = new object();
connection = new XmppConnection();
serviceDiscovery = new XmppServiceDiscovery(this);
personalEventing = new XmppPersonalEventing(this);
activity = new XmppActivity(this);
clientCapabilitiesStorage = new XmppClientCapabilitiesStorage();
roster = new XmppRoster(this);
avatarStorage.Load();
clientCapabilitiesStorage.Load();
}
/// <summary>
/// Initializes a new instance of the <see cref="XmppAuthenticator" /> class.
/// </summary>
/// <param name = "connection">A <see cref="XmppConnection" /> instance</param>
protected XmppAuthenticator(XmppConnection connection)
{
Connection = connection;
Subscribe();
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
/// <summary>
/// Basic Constructor
/// </summary>
/// <history>
/// 08/03/2018 Created [Fabian Sauter]
/// </history>
public MUCCommandHelper(XmppConnection connection)
{
CONNECTION = connection;
}
/// <summary>
/// Initializes a new instance of the <see cref = "T:XmppSaslPlainAuthenticator" /> class.
/// </summary>
public XmppSaslPlainAuthenticator(XmppConnection connection)
: base(connection)
{
waitEvent = new AutoResetEvent(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="XmppSaslDigestAuthenticator" /> class.
/// </summary>
public XmppSaslDigestAuthenticator(XmppConnection connection)
: base(connection)
{
cnonce = Convert.ToBase64String(Encoding.UTF8.GetBytes(XmppIdentifierGenerator.Generate()));
successEvent = new AutoResetEvent(false);
}
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\
#region --Constructors--
/// <summary>
/// Basic Constructor
/// </summary>
/// <history>
/// 22/08/2017 Created [Fabian Sauter]
/// </history>
public SASLConnection(TcpConnection tcpConnection, XmppConnection xmppConnection) : base(tcpConnection, xmppConnection)
{
reset();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:XmppJabberAuthenticator"/> class.
/// </summary>
public XmppJabberAuthenticator(XmppConnection connection)
: base(connection)
{
this.authInfoEvent = new AutoResetEvent(false);
}
