public void Initialize(bool loadSave = true, string saveFile = "", bool allowOutOfDateSaves = false, bool skipInitialSpawn = false) { this.persistance = new UserPersistance(ConVar.Server.rootFolder); this.SpawnMapEntities(); if (SingletonComponent <SpawnHandler> .Instance) { using (TimeWarning timeWarning = TimeWarning.New("SpawnHandler.UpdateDistributions", 0.1f)) { SingletonComponent <SpawnHandler> .Instance.UpdateDistributions(); } } if (loadSave) { skipInitialSpawn = SaveRestore.Load(saveFile, allowOutOfDateSaves); } if (SingletonComponent <SpawnHandler> .Instance) { if (!skipInitialSpawn) { using (timeWarning = TimeWarning.New("SpawnHandler.InitialSpawn", (long)200)) { SingletonComponent <SpawnHandler> .Instance.InitialSpawn(); } } using (timeWarning = TimeWarning.New("SpawnHandler.StartSpawnTick", (long)200)) { SingletonComponent <SpawnHandler> .Instance.StartSpawnTick(); } } this.CreateImportantEntities(); this.auth = base.GetComponent <ConnectionAuth>(); }
private object OnUserApprove(Network.Connection connection) { // Call out and see if we should reject object canlogin = Interface.CallHook("CanClientLogin", new object[] { connection }); if (canlogin != null) { // If it's a bool and it's true, let them in if (canlogin is bool && (bool)canlogin) { return(null); } // If it's a string, reject them with a message if (canlogin is string) { ConnectionAuth.Reject(connection, (string)canlogin); return(true); } // We don't know what type it is, reject them with it anyway ConnectionAuth.Reject(connection, canlogin.ToString()); return(true); } return(null); }
public void Initialize( bool loadSave = true, string saveFile = "", bool allowOutOfDateSaves = false, bool skipInitialSpawn = false) { if (!ConVar.Server.official) { ExceptionReporter.set_Disabled(true); } this.persistance = new UserPersistance(ConVar.Server.rootFolder); this.SpawnMapEntities(); if (Object.op_Implicit((Object)SingletonComponent <SpawnHandler> .Instance)) { using (TimeWarning.New("SpawnHandler.UpdateDistributions", 0.1f)) ((SpawnHandler)SingletonComponent <SpawnHandler> .Instance).UpdateDistributions(); } if (loadSave) { skipInitialSpawn = SaveRestore.Load(saveFile, allowOutOfDateSaves); } if (Object.op_Implicit((Object)SingletonComponent <SpawnHandler> .Instance)) { if (!skipInitialSpawn) { using (TimeWarning.New("SpawnHandler.InitialSpawn", 200L)) ((SpawnHandler)SingletonComponent <SpawnHandler> .Instance).InitialSpawn(); } using (TimeWarning.New("SpawnHandler.StartSpawnTick", 200L)) ((SpawnHandler)SingletonComponent <SpawnHandler> .Instance).StartSpawnTick(); } this.CreateImportantEntities(); this.auth = (ConnectionAuth)((Component)this).GetComponent <ConnectionAuth>(); }
public void OnNewConnection(Connection connection) { connection.connected = false; if (connection.token == null || (int)connection.token.Length < 32) { ConnectionAuth.Reject(connection, "Invalid Token"); return; } if (connection.userid == 0) { ConnectionAuth.Reject(connection, "Invalid SteamID"); return; } if (connection.protocol != 2177) { if (!DeveloperList.Contains(connection.userid)) { ConnectionAuth.Reject(connection, "Incompatible Version"); return; } DebugEx.Log(string.Concat("Not kicking ", connection.userid, " for incompatible protocol (is a developer)"), StackTraceLogType.None); } if (ServerUsers.Is(connection.userid, ServerUsers.UserGroup.Banned)) { ConnectionAuth.Reject(connection, "You are banned from this server"); return; } if (ServerUsers.Is(connection.userid, ServerUsers.UserGroup.Moderator)) { DebugEx.Log(string.Concat(connection.ToString(), " has auth level 1"), StackTraceLogType.None); connection.authLevel = 1; } if (ServerUsers.Is(connection.userid, ServerUsers.UserGroup.Owner)) { DebugEx.Log(string.Concat(connection.ToString(), " has auth level 2"), StackTraceLogType.None); connection.authLevel = 2; } if (DeveloperList.Contains(connection.userid)) { DebugEx.Log(string.Concat(connection.ToString(), " is a developer"), StackTraceLogType.None); connection.authLevel = 3; } if (this.IsConnected(connection.userid)) { ConnectionAuth.Reject(connection, "You are already connected!"); return; } if (Interface.CallHook("IOnUserApprove", connection) != null) { return; } ConnectionAuth.m_AuthConnection.Add(connection); base.StartCoroutine(this.AuthorisationRoutine(connection)); }
void UserIsFollowingCallBack(int code, string response, Network.Connection connection) { if (code != 200) { Puts($"{connection.username} tried to log in but does not follow you on Twitch"); ConnectionAuth.Reject(connection, string.Format(lang.GetMessage("RejectMessage", this, connection.userid.ToString()), twitchAccount)); } else { Puts($"{connection.username} is a follower. Allowing."); } }
public static IEnumerator Run(Connection connection) { connection.authStatus = ""; if (!SteamServer.BeginAuthSession(connection.token, connection.userid)) { ConnectionAuth.Reject(connection, "Steam Auth Failed"); yield break; } Auth_Steam.waitingList.Add(connection); Stopwatch stopwatch = Stopwatch.StartNew(); while (stopwatch.Elapsed.TotalSeconds < 30 && connection.active && !(connection.authStatus != "")) { yield return(null); } Auth_Steam.waitingList.Remove(connection); if (!connection.active) { yield break; } if (connection.authStatus.Length == 0) { ConnectionAuth.Reject(connection, "Steam Auth Timeout"); SteamServer.EndSession(connection.userid); yield break; } if (connection.authStatus == "banned") { ConnectionAuth.Reject(connection, string.Concat("Auth: ", connection.authStatus)); SteamServer.EndSession(connection.userid); yield break; } if (connection.authStatus == "gamebanned") { ConnectionAuth.Reject(connection, string.Concat("Steam Auth: ", connection.authStatus)); SteamServer.EndSession(connection.userid); yield break; } if (connection.authStatus == "vacbanned") { ConnectionAuth.Reject(connection, string.Concat("Steam Auth: ", connection.authStatus)); SteamServer.EndSession(connection.userid); yield break; } if (connection.authStatus == "ok") { SteamServer.UpdatePlayer(connection.userid, connection.username, 0); yield break; } ConnectionAuth.Reject(connection, string.Concat("Steam Auth Error: ", connection.authStatus)); SteamServer.EndSession(connection.userid); }
public void OnDisconnected(string strReason, Network.Connection connection) { this.connectionQueue.RemoveConnection(connection); ConnectionAuth.OnDisconnect(connection); SteamServer.EndSession(connection.userid); EACServer.OnLeaveGame(connection); BasePlayer basePlayer = connection.player as BasePlayer; if (basePlayer) { Interface.CallHook("OnPlayerDisconnected", basePlayer, strReason); basePlayer.OnDisconnected(); } }
public static IEnumerator Run(Connection connection) { connection.authStatus = (__Null)""; if (!Global.get_SteamServer().get_Auth().StartSession((byte[])connection.token, (ulong)connection.userid)) { ConnectionAuth.Reject(connection, "Steam Auth Failed"); } else { Auth_Steam.waitingList.Add(connection); Stopwatch timeout = Stopwatch.StartNew(); while (timeout.Elapsed.TotalSeconds < 30.0 && connection.active != null && !((string)connection.authStatus != "")) { yield return((object)null); } Auth_Steam.waitingList.Remove(connection); if (connection.active != null) { if (((string)connection.authStatus).Length == 0) { ConnectionAuth.Reject(connection, "Steam Auth Timeout"); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); } else if ((string)connection.authStatus == "banned") { ConnectionAuth.Reject(connection, "Auth: " + (string)connection.authStatus); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); } else if ((string)connection.authStatus == "gamebanned") { ConnectionAuth.Reject(connection, "Steam Auth: " + (string)connection.authStatus); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); } else if ((string)connection.authStatus == "vacbanned") { ConnectionAuth.Reject(connection, "Steam Auth: " + (string)connection.authStatus); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); } else if ((string)connection.authStatus != "ok") { ConnectionAuth.Reject(connection, "Steam Auth Error: " + (string)connection.authStatus); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); } else { Global.get_SteamServer().UpdatePlayer((ulong)connection.userid, (string)connection.username, 0); } } } }
private object IOnUserApprove(Connection connection) { // Call out and see if we should reject var canlogin = Interface.CallHook("CanClientLogin", connection); if (canlogin != null && (!(canlogin is bool) || !(bool)canlogin)) { // Reject the user with the message ConnectionAuth.Reject(connection, canlogin.ToString()); return(true); } return(Interface.CallHook("OnUserApprove", connection)); }
// ConnectionAuth.Approve() public static void On_ClientAuth(ConnectionAuth ca, Connection connection) { var ae = new Events.AuthEvent(connection); OnNext("On_ClientAuth", ae); ConnectionAuth.m_AuthConnection.Remove(connection); if (!ae.Approved) { ConnectionAuth.Reject(connection, ae.Reason); return; } SingletonComponent <ServerMgr> .Instance.ConnectionApproved(connection); }
public static IEnumerator Run(Connection connection) { connection.authStatus = ""; if (!PlatformService.Instance.BeginPlayerSession(connection.userid, connection.token)) { ConnectionAuth.Reject(connection, "Steam Auth Failed"); yield break; } waitingList.Add(connection); Stopwatch timeout = Stopwatch.StartNew(); while (timeout.Elapsed.TotalSeconds < 30.0 && connection.active && !(connection.authStatus != "")) { yield return(null); } waitingList.Remove(connection); if (connection.active) { if (connection.authStatus.Length == 0) { ConnectionAuth.Reject(connection, "Steam Auth Timeout"); PlatformService.Instance.EndPlayerSession(connection.userid); } else if (connection.authStatus == "banned") { ConnectionAuth.Reject(connection, "Auth: " + connection.authStatus); PlatformService.Instance.EndPlayerSession(connection.userid); } else if (connection.authStatus == "gamebanned") { ConnectionAuth.Reject(connection, "Steam Auth: " + connection.authStatus); PlatformService.Instance.EndPlayerSession(connection.userid); } else if (connection.authStatus == "vacbanned") { ConnectionAuth.Reject(connection, "Steam Auth: " + connection.authStatus); PlatformService.Instance.EndPlayerSession(connection.userid); } else if (connection.authStatus != "ok") { ConnectionAuth.Reject(connection, "Steam Auth Failed", "Steam Auth Error: " + connection.authStatus); PlatformService.Instance.EndPlayerSession(connection.userid); } else { string userName = (ConVar.Server.censorplayerlist ? RandomUsernames.Get(connection.userid + (ulong)Random.Range(0, 100000)) : connection.username); PlatformService.Instance.UpdatePlayerSession(connection.userid, userName); } } }
public void OnDisconnected(string strReason, Network.Connection connection) { this.connectionQueue.RemoveConnection(connection); ConnectionAuth.OnDisconnect(connection); Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid); EACServer.OnLeaveGame(connection); BasePlayer player = connection.player as BasePlayer; if (!Object.op_Implicit((Object)player)) { return; } Interface.CallHook("OnPlayerDisconnected", (object)player, (object)strReason); player.OnDisconnected(); }
void UserHasSteamConnectedCallBack(int code, string response, Network.Connection connection) { if (code != 200) { Puts($"{connection.username} tried to log in but does not have its Steam account connected to Twitch"); ConnectionAuth.Reject(connection, string.Format(lang.GetMessage("RejectMessage", this, connection.userid.ToString()), twitchAccount)); } else { var user = JsonConvert.DeserializeObject <TwitchUser>(response); if (!string.IsNullOrEmpty(user?.Name)) { Puts($"{connection.username} connecting. Checking if is a follower."); UserIsFollowing(user.Name, connection); } } }
static bool Prefix(Connection connection) { if (DeveloperList.Contains(connection.userid)) { ConnectionAuth.Reject(connection, "Developer SteamId"); return(false); } var message = Interface.CallHook("CanNewConnection", connection, !ShouldIgnore(connection)); if (message != null) { ConnectionAuth.Reject(connection, message.ToString()); return(false); } return(true); }
public static string BuildConnectionString <TCon>(string server, ConnectionAuth auth, Option <string> database = new Option <string>()) where TCon : DbConnection { var a = typeof(TCon).Name; var dbStr = database.Map(db => typeof(TCon).Name == "HanaConnection" ? $"CS={db};":$"Initial Catalog={db};" ).ValueOr(""); var authStr = auth is ConnectionAuth.UserAndPass up ? typeof(TCon).Name == "HanaConnection" ? $"UserID={up.UserName};Password={up.Password};" : $"uid={up.UserName};pwd={up.Password};" : "Integrated Security=True;"; return($"Server={server};{dbStr}{authStr}"); }
// ConnectionAuth.Approve() public static void ClientAuth(ConnectionAuth ca, Connection connection) { var ae = new Events.AuthEvent(connection); OnClientAuth.OnNext(ae); ca.m_AuthConnection.Remove(connection); if (!ae.approved) { ConnectionAuth.Reject(connection, ae._reason); } Approval instance = new Approval(); instance.level = Application.loadedLevelName; instance.levelSeed = TerrainGenerator.Seed; instance.hostname = server.hostname; Net.sv.Approve(connection, Approval.SerializeToBytes(instance)); }
private object IOnUserApprove(Connection connection) { string name = connection.username; string id = connection.userid.ToString(); string ip = Regex.Replace(connection.ipaddress, ipPattern, ""); uint authLevel = connection.authLevel; // Update player's permissions group and name if (permission.IsLoaded) { permission.UpdateNickname(id, name); OxideConfig.DefaultGroups defaultGroups = Interface.Oxide.Config.Options.DefaultGroups; if (!permission.UserHasGroup(id, defaultGroups.Players)) { permission.AddUserGroup(id, defaultGroups.Players); } if (authLevel == 2 && !permission.UserHasGroup(id, defaultGroups.Administrators)) { permission.AddUserGroup(id, defaultGroups.Administrators); } } Covalence.PlayerManager.PlayerJoin(connection.userid, name); // TODO: Handle this automatically object loginSpecific = Interface.CallHook("CanClientLogin", connection); object loginCovalence = Interface.CallHook("CanUserLogin", name, id, ip); object canLogin = loginSpecific ?? loginCovalence; // TODO: Fix hook conflict when multiple return if (canLogin is string || canLogin is bool && !(bool)canLogin) { ConnectionAuth.Reject(connection, canLogin is string?canLogin.ToString() : lang.GetMessage("ConnectionRejected", this, id)); return(true); } // Call game and covalence hooks object approvedSpecific = Interface.CallHook("OnUserApprove", connection); object approvedCovalence = Interface.CallHook("OnUserApproved", name, id, ip); return(approvedSpecific ?? approvedCovalence); // TODO: Fix hook conflict when multiple return }
private object IOnUserApprove(Connection connection) { string playerName = connection.username; string connectionId = connection.userid.ToString(); string connectionIp = Regex.Replace(connection.ipaddress, ipPattern, ""); uint authLevel = connection.authLevel; // Update name and groups with permissions if (permission.IsLoaded) { permission.UpdateNickname(connectionId, playerName); OxideConfig.DefaultGroups defaultGroups = Interface.Oxide.Config.Options.DefaultGroups; if (!permission.UserHasGroup(connectionId, defaultGroups.Players)) { permission.AddUserGroup(connectionId, defaultGroups.Players); } if (authLevel == 2 && !permission.UserHasGroup(connectionId, defaultGroups.Administrators)) { permission.AddUserGroup(connectionId, defaultGroups.Administrators); } } // Let covalence know Covalence.PlayerManager.PlayerJoin(connection.userid, playerName); // Call hooks for plugins object loginSpecific = Interface.CallHook("CanClientLogin", connection); object loginCovalence = Interface.CallHook("CanUserLogin", playerName, connectionId, connectionIp); object canLogin = loginSpecific is null ? loginCovalence : loginSpecific; if (canLogin is string || canLogin is bool loginBlocked && !loginBlocked) { ConnectionAuth.Reject(connection, canLogin is string?canLogin.ToString() : lang.GetMessage("ConnectionRejected", this, connectionId)); return(true); } // Call hooks for plugins object approvedSpecific = Interface.CallHook("OnUserApprove", connection); object approvedCovalence = Interface.CallHook("OnUserApproved", playerName, connectionId, connectionIp); return(approvedSpecific is null ? approvedCovalence : approvedSpecific); }
private object IOnUserApprove(Connection connection) { var name = connection.username; var id = connection.userid.ToString(); var authLevel = connection.authLevel; var ip = Regex.Replace(connection.ipaddress, ipPattern, ""); // Update player's permissions group and name if (permission.IsLoaded) { permission.UpdateNickname(id, name); var defaultGroups = Interface.Oxide.Config.Options.DefaultGroups; if (!permission.UserHasGroup(id, defaultGroups.Players)) { permission.AddUserGroup(id, defaultGroups.Players); } if (authLevel == 2 && !permission.UserHasGroup(id, defaultGroups.Administrators)) { permission.AddUserGroup(id, defaultGroups.Administrators); } } // Let covalence know Covalence.PlayerManager.PlayerJoin(connection.userid, name); var loginSpecific = Interface.Call("CanClientLogin", connection); var loginCovalence = Interface.Call("CanUserLogin", name, id, ip); var canLogin = loginSpecific ?? loginCovalence; // TODO: Fix 'RustCore' hook conflict when both return if (canLogin is string || (canLogin is bool && !(bool)canLogin)) { ConnectionAuth.Reject(connection, canLogin is string?canLogin.ToString() : lang.GetMessage("ConnectionRejected", this, id)); return(true); } // Call game and covalence hooks var approvedSpecific = Interface.Call("OnUserApprove", connection); var approvedCovalence = Interface.Call("OnUserApproved", name, id, ip); return(approvedSpecific ?? approvedCovalence); // TODO: Fix 'RustCore' hook conflict when both return }
public IEnumerator AuthorisationRoutine(Connection connection) { ConnectionAuth connectionAuth = null; yield return(connectionAuth.StartCoroutine(Auth_Steam.Run(connection))); yield return(connectionAuth.StartCoroutine(Auth_EAC.Run(connection))); if (connection.rejected || !connection.active) { yield break; } BasePlayer basePlayer = BasePlayer.FindByID(connection.userid); if (basePlayer && basePlayer.net.connection != null) { ConnectionAuth.Reject(connection, "You are already connected as a player!"); yield break; } connectionAuth.Approve(connection); }
public IEnumerator AuthorisationRoutine(Connection connection) { ConnectionAuth connectionAuth = this; yield return((object)connectionAuth.StartCoroutine(Auth_Steam.Run(connection))); yield return((object)connectionAuth.StartCoroutine(Auth_EAC.Run(connection))); if (connection.rejected == null && connection.active != null) { BasePlayer byId = BasePlayer.FindByID((ulong)connection.userid); if (Object.op_Implicit((Object)byId) && byId.net.get_connection() != null) { ConnectionAuth.Reject(connection, "You are already connected as a player!"); } else { connectionAuth.Approve(connection); } } }
//Oxide Hook void CanClientLogin(Network.Connection connection) { //Checks if the player has been verified before, if not -> verify player. if (!verifiedPlayers.Contains(connection.userid.ToString())) { if (steamAPIKey != "insertAPIKeyHere") { string url = "http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=" + steamAPIKey + "&format=json&input_json={\"appids_filter\":[252490],\"steamid\":" + connection.userid + "}"; ConnectingPlayer connectingPlayer = new ConnectingPlayer(connection); webRequests.EnqueueGet(url, (code, response) => connectingPlayer.connectionResponse = WebRequestCallback(code, response), this, null, 1.5f); RespondOnWebRequest(connectingPlayer); } else { ConnectionAuth.Reject(connection, "MinimumPlaytime has no steamAPI key entered by the server owner yet."); } } }
private void RespondOnWebRequest(ConnectingPlayer connectingPlayer) { timer.Once(timerDelay, () => { if (connectingPlayer.connectionResponse != null) { if (connectingPlayer.connectionResponse.Equals("LoginAllowed")) { verifiedPlayers.Add(connectingPlayer.connection.userid.ToString()); Config["verifiedPlayers"] = verifiedPlayers; SaveConfig(); } else { ConnectionAuth.Reject(connectingPlayer.connection, connectingPlayer.connectionResponse); } } else { RespondOnWebRequest(connectingPlayer); } }); }
public void Reject(string reason = "no reason") { ConnectionAuth.Reject(basePlayer.net.connection, reason); }
/// <summary> /// Sends an array of email messages using a session state object. /// Credentials, Enable SSL and Client Hostname are NOT taken from the state object but /// rather from the properties of this class. /// </summary> /// <param name="sessionStates">The session states.</param> /// <param name="sessionId">The session identifier.</param> /// <param name="ct">The cancellation token.</param> /// <returns> /// A task that represents the asynchronous of send email operation. /// </returns> /// <exception cref="ArgumentNullException">sessionStates.</exception> /// <exception cref="SecurityException">Could not upgrade the channel to SSL.</exception> /// <exception cref="SmtpException">Defines an SMTP Exceptions class.</exception> public async Task SendMailAsync(IEnumerable <SmtpSessionState> sessionStates, string sessionId = null, CancellationToken ct = default) { if (sessionStates == null) { throw new ArgumentNullException(nameof(sessionStates)); } using (var tcpClient = new TcpClient()) { await tcpClient.ConnectAsync(Host, Port); using (var connection = new Connection(tcpClient, Encoding.UTF8, "\r\n", true, 1000)) { var sender = new SmtpSender(sessionId); try { // Read the greeting message sender.ReplyText = await connection.ReadLineAsync(ct); // EHLO 1 sender.RequestText = $"{SmtpCommandNames.EHLO} {ClientHostname}"; await connection.WriteLineAsync(sender.RequestText, ct); do { sender.ReplyText = await connection.ReadLineAsync(ct); } while (!sender.IsReplyOk); sender.ValidateReply(); // STARTTLS if (EnableSsl) { sender.RequestText = $"{SmtpCommandNames.STARTTLS}"; await connection.WriteLineAsync(sender.RequestText, ct); sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); if (await connection.UpgradeToSecureAsClientAsync() == false) { throw new SecurityException("Could not upgrade the channel to SSL."); } } { // EHLO 2 sender.RequestText = $"{SmtpCommandNames.EHLO} {ClientHostname}"; await connection.WriteLineAsync(sender.RequestText, ct); do { sender.ReplyText = await connection.ReadLineAsync(ct); } while (!sender.IsReplyOk); sender.ValidateReply(); } // AUTH if (Credentials != null) { var auth = new ConnectionAuth(connection, sender, Credentials); await auth.AuthenticateAsync(ct); } foreach (var sessionState in sessionStates) { { // MAIL FROM sender.RequestText = $"{SmtpCommandNames.MAIL} FROM:<{sessionState.SenderAddress}>"; await connection.WriteLineAsync(sender.RequestText, ct); sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); } // RCPT TO foreach (var recipient in sessionState.Recipients) { sender.RequestText = $"{SmtpCommandNames.RCPT} TO:<{recipient}>"; await connection.WriteLineAsync(sender.RequestText, ct); sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); } { // DATA sender.RequestText = $"{SmtpCommandNames.DATA}"; await connection.WriteLineAsync(sender.RequestText, ct); sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); } { // CONTENT var dataTerminator = sessionState.DataBuffer.Skip(sessionState.DataBuffer.Count - 5).ToArray().ToText(); sender.RequestText = $"Buffer ({sessionState.DataBuffer.Count} bytes)"; await connection.WriteDataAsync(sessionState.DataBuffer.ToArray(), true, ct); if (dataTerminator.EndsWith(SmtpDefinitions.SmtpDataCommandTerminator) == false) { await connection.WriteTextAsync(SmtpDefinitions.SmtpDataCommandTerminator, ct); } sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); } } { // QUIT sender.RequestText = $"{SmtpCommandNames.QUIT}"; await connection.WriteLineAsync(sender.RequestText, ct); sender.ReplyText = await connection.ReadLineAsync(ct); sender.ValidateReply(); } } catch (Exception ex) { var errorMessage = $"Could not send email. {ex.Message}\r\n Last Request: {sender.RequestText}\r\n Last Reply: {sender.ReplyText}"; errorMessage.Error(typeof(SmtpClient).FullName, sessionId); throw new SmtpException(errorMessage); } } } }
/// <summary> /// Called from <c>ConnectionAuth.Approve(Connection)</c> . /// </summary> public static void On_ClientAuth(ConnectionAuth ca, Connection connection) { var ae = new Pre<AuthEvent>(connection); OnNext("Pre_ClientAuth", ae); if (!ae.IsCanceled) OnNext("On_ClientAuth", ae.Event); ConnectionAuth.m_AuthConnection.Remove(connection); if (!ae.Event.Approved) { ConnectionAuth.Reject(connection, ae.Event.Reason); return; } SingletonComponent<ServerMgr>.Instance.ConnectionApproved(connection); }
// ConnectionAuth.Approve() public static void ClientAuth(ConnectionAuth ca, Connection connection) { var ae = new Events.AuthEvent(connection); OnClientAuth.OnNext(ae); ca.m_AuthConnection.Remove(connection); if (!ae.approved) { ConnectionAuth.Reject(connection, ae._reason); return; } SingletonComponent<ServerMgr>.Instance.ConnectionApproved(connection); }
/// <summary> /// Sends an array of email messages using a session state object. /// Credentials, Enable SSL and Client Hostname are NOT taken from the state object but /// rather from the properties of this class. /// </summary> /// <param name="sessionStates">The session states.</param> /// <param name="sessionId">The session identifier.</param> /// <param name="callback">The callback.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// A task that represents the asynchronous of send email operation. /// </returns> /// <exception cref="ArgumentNullException">sessionStates.</exception> /// <exception cref="SecurityException">Could not upgrade the channel to SSL.</exception> /// <exception cref="SmtpException">Defines an SMTP Exceptions class.</exception> public async Task SendMailAsync( IEnumerable <SmtpSessionState> sessionStates, string?sessionId = null, RemoteCertificateValidationCallback?callback = null, CancellationToken cancellationToken = default) { if (sessionStates == null) { throw new ArgumentNullException(nameof(sessionStates)); } using var tcpClient = new TcpClient(); await tcpClient.ConnectAsync(Host, Port, cancellationToken).ConfigureAwait(false); using var connection = new Connection(tcpClient, Encoding.UTF8, "\r\n", true, 1000); var sender = new SmtpSender(sessionId); try { // Read the greeting message sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); // EHLO 1 await SendEhlo(sender, connection, cancellationToken).ConfigureAwait(false); // STARTTLS if (EnableSsl) { sender.RequestText = $"{SmtpCommandNames.STARTTLS}"; await connection.WriteLineAsync(sender.RequestText, cancellationToken).ConfigureAwait(false); sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); if (await connection.UpgradeToSecureAsClientAsync(callback: callback).ConfigureAwait(false) == false) { throw new SecurityException("Could not upgrade the channel to SSL."); } } // EHLO 2 await SendEhlo(sender, connection, cancellationToken).ConfigureAwait(false); // AUTH if (Credentials != null) { var auth = new ConnectionAuth(connection, sender, Credentials); await auth.AuthenticateAsync(cancellationToken).ConfigureAwait(false); } foreach (var sessionState in sessionStates) { { // MAIL FROM sender.RequestText = $"{SmtpCommandNames.MAIL} FROM:<{sessionState.SenderAddress}>"; await connection.WriteLineAsync(sender.RequestText, cancellationToken).ConfigureAwait(false); sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); } // RCPT TO foreach (var recipient in sessionState.Recipients) { sender.RequestText = $"{SmtpCommandNames.RCPT} TO:<{recipient}>"; await connection.WriteLineAsync(sender.RequestText, cancellationToken).ConfigureAwait(false); sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); } { // DATA sender.RequestText = $"{SmtpCommandNames.DATA}"; await connection.WriteLineAsync(sender.RequestText, cancellationToken).ConfigureAwait(false); sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); } { // CONTENT var dataTerminator = sessionState.DataBuffer .Skip(sessionState.DataBuffer.Count - 5) .ToText(); sender.RequestText = $"Buffer ({sessionState.DataBuffer.Count} bytes)"; await connection.WriteDataAsync(sessionState.DataBuffer.ToArray(), true, cancellationToken).ConfigureAwait(false); if (!dataTerminator.EndsWith(SmtpDefinitions.SmtpDataCommandTerminator, StringComparison.OrdinalIgnoreCase)) { await connection.WriteTextAsync(SmtpDefinitions.SmtpDataCommandTerminator, cancellationToken).ConfigureAwait(false); } sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); } } { // QUIT sender.RequestText = $"{SmtpCommandNames.QUIT}"; await connection.WriteLineAsync(sender.RequestText, cancellationToken).ConfigureAwait(false); sender.ReplyText = await connection.ReadLineAsync(cancellationToken).ConfigureAwait(false); sender.ValidateReply(); } } catch (Exception ex) { throw new SmtpException($"Could not send email - Session ID {sessionId}. {ex.Message}\r\n Last Request: {sender.RequestText}\r\n Last Reply: {sender.ReplyText}"); } }
public DBConnectionData(string server, ConnectionAuth auth, Option <string> database = new Option <string>()) : base(DB.BuildConnectionString <TCon>(server, auth, database)) => (Server, Auth, Database) = (server, auth, database);
public void OnNewConnection(Connection connection) { connection.connected = (__Null)0; if (connection.token == null || connection.token.Length < 32) { ConnectionAuth.Reject(connection, "Invalid Token"); } else if (connection.userid == null) { ConnectionAuth.Reject(connection, "Invalid SteamID"); } else { if (connection.protocol != 2161) { if (DeveloperList.Contains((ulong)connection.userid)) { DebugEx.Log((object)("Not kicking " + (object)(ulong)connection.userid + " for incompatible protocol (is a developer)"), (StackTraceLogType)0); } else { ConnectionAuth.Reject(connection, "Incompatible Version"); return; } } if (ServerUsers.Is((ulong)connection.userid, ServerUsers.UserGroup.Banned)) { ConnectionAuth.Reject(connection, "You are banned from this server"); } else { if (ServerUsers.Is((ulong)connection.userid, ServerUsers.UserGroup.Moderator)) { DebugEx.Log((object)(((object)connection).ToString() + " has auth level 1"), (StackTraceLogType)0); connection.authLevel = (__Null)1; } if (ServerUsers.Is((ulong)connection.userid, ServerUsers.UserGroup.Owner)) { DebugEx.Log((object)(((object)connection).ToString() + " has auth level 2"), (StackTraceLogType)0); connection.authLevel = (__Null)2; } if (DeveloperList.Contains((ulong)connection.userid)) { DebugEx.Log((object)(((object)connection).ToString() + " is a developer"), (StackTraceLogType)0); connection.authLevel = (__Null)3; } if (this.IsConnected((ulong)connection.userid)) { ConnectionAuth.Reject(connection, "You are already connected!"); } else { if (Interface.CallHook("IOnUserApprove", (object)connection) != null) { return; } ConnectionAuth.m_AuthConnection.Add(connection); this.StartCoroutine(this.AuthorisationRoutine(connection)); } } } }