public static async Task<Account> Authenticate(Connection con)
{
await con.SendAsync("Please enter your username: (hit enter to register a new account)");
var username = await con.ReadNextMsgAsync();
Account account;
if (username == "") {
account = await Registrar.Register(con);;
} else {
var accounttask = Account.FromUsername(username);
await con.SendAsync("Enter password: "******"Wrong password");
return await Authenticate(con);
}
}
return account;
}
private static async Task<string> ReceiveValidUsername(Connection con)
{
await con.SendAsync("Please enter your desired username (a-Z, 0-9, _): ");
var username = await con.ReadNextMsgAsync();
if (await Account.IsUsernameTaken(username)) {
await con.SendAsync("That name is already taken, please choose another one");
return await ReceiveValidUsername(con);
}
return username;
}
private static async Task<string> ReceiveValidPassword(Connection con)
{
await con.SendAsync("Enter your desired password: "******"Enter it again: ");
var pw2 = await con.ReadNextMsgAsync();
if (pw1 != pw2) {
await con.SendAsync("Passwords don't match, try again ");
return await ReceiveValidPassword(con);
}
return pw1;
}
/// <summary>
/// This sends a network message with a message Id to the server. This message is sent on channel zero, which by default is the reliable channel.
/// <para>The message must be an instance of a class derived from MessageBase.</para>
/// <para>The message id passed to Send() is used to identify the handler function to invoke on the server when the message is received.</para>
/// </summary>
/// <typeparam name="T">The message type to unregister.</typeparam>
/// <param name="message"></param>
/// <param name="channelId"></param>
/// <returns>True if message was sent.</returns>
public Task SendAsync <T>(T message, int channelId = Channels.DefaultReliable)
{
return(Connection.SendAsync(message, channelId));
}
/// <summary>s
/// Updates the branding for a tenant.
/// </summary>
/// <param name="request">A <see cref="BrandingUpdateRequest" /> containing the branding information to update.</param>
/// <returns>The newly updated <see cref="Branding"/>.</returns>
public Task <Branding> UpdateAsync(BrandingUpdateRequest request)
{
return(Connection.SendAsync <Branding>(new HttpMethod("PATCH"), BuildUri("branding"), request, DefaultHeaders));
}
/// <summary>
/// Creates a new connection according to the request.
/// </summary>
/// <param name="request">The request containing the properties for the new connection.</param>
/// <returns>A <see cref="Connection"/> containing the newly created Connection.</returns>
public Task <Connection> CreateAsync(ConnectionCreateRequest request)
{
return(Connection.SendAsync <Connection>(HttpMethod.Post, BuildUri("connections"), request, DefaultHeaders));
}
/// <summary>
/// Updates a resource server,
/// </summary>
/// <param name="id">The id of the resource server to update.</param>
/// <param name="request">Contains the information for the resource server to update.</param>
/// <returns>The newly updated <see cref="ResourceServer"/>.</returns>
public Task <ResourceServer> UpdateAsync(string id, ResourceServerUpdateRequest request)
{
return(Connection.SendAsync <ResourceServer>(new HttpMethod("PATCH"), BuildUri($"resource-servers/{EncodePath(id)}"), request, DefaultHeaders));
}
/// <summary>
/// Send an email to the specified user that asks them to click a link to verify their email address.
/// </summary>
/// <param name="request">The <see cref="VerifyEmailJobRequest"/> containing the information of the user whose email you want verified.</param>
/// <returns>A <see cref="Job"/> instance containing the information about the job.</returns>
public Task <Job> SendVerificationEmailAsync(VerifyEmailJobRequest request)
{
return(Connection.SendAsync <Job>(HttpMethod.Post, BuildUri("jobs/verification-email"), request, DefaultHeaders));
}
public override async ValueTask HandleMessageAsync(IMessageReader reader, MessageType messageType)
{
var flag = reader.Tag;
_logger.LogTrace("[{0}] Server got {1}.", Id, flag);
switch (flag)
{
case MessageFlags.HostGame:
{
// Read game settings.
var gameInfo = Message00HostGameC2S.Deserialize(reader, out _);
// Create game.
var game = await _gameManager.CreateAsync(this, gameInfo);
if (game == null)
{
await DisconnectAsync(DisconnectReason.GameMissing);
return;
}
// Code in the packet below will be used in JoinGame.
using (var writer = MessageWriter.Get(MessageType.Reliable))
{
Message00HostGameS2C.Serialize(writer, game.Code);
await Connection.SendAsync(writer);
}
break;
}
case MessageFlags.JoinGame:
{
Message01JoinGameC2S.Deserialize(reader, out var gameCode);
var game = _gameManager.Find(gameCode);
if (game == null)
{
await DisconnectAsync(DisconnectReason.GameMissing);
return;
}
var result = await game.AddClientAsync(this);
switch (result.Error)
{
case GameJoinError.None:
break;
case GameJoinError.InvalidClient:
await DisconnectAsync(DisconnectReason.Custom, "Client is in an invalid state.");
break;
case GameJoinError.Banned:
await DisconnectAsync(DisconnectReason.Banned);
break;
case GameJoinError.GameFull:
await DisconnectAsync(DisconnectReason.GameFull);
break;
case GameJoinError.InvalidLimbo:
await DisconnectAsync(DisconnectReason.Custom, "Invalid limbo state while joining.");
break;
case GameJoinError.GameStarted:
await DisconnectAsync(DisconnectReason.GameStarted);
break;
case GameJoinError.GameDestroyed:
await DisconnectAsync(DisconnectReason.Custom, DisconnectMessages.Destroyed);
break;
case GameJoinError.Custom:
await DisconnectAsync(DisconnectReason.Custom, result.Message);
break;
default:
await DisconnectAsync(DisconnectReason.Custom, "Unknown error.");
break;
}
break;
}
case MessageFlags.StartGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
await Player !.Game.HandleStartGame(reader);
break;
}
// No idea how this flag is triggered.
case MessageFlags.RemoveGame:
break;
case MessageFlags.RemovePlayer:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message04RemovePlayerC2S.Deserialize(
reader,
out var playerId,
out var reason);
await Player !.Game.HandleRemovePlayer(playerId, (DisconnectReason)reason);
break;
}
case MessageFlags.GameData:
case MessageFlags.GameDataTo:
{
if (!IsPacketAllowed(reader, false))
{
return;
}
var toPlayer = flag == MessageFlags.GameDataTo;
var position = reader.Position;
var verified = await Player !.Game.HandleGameDataAsync(reader, Player, toPlayer);
reader.Seek(position);
if (verified && Player != null)
{
// Broadcast packet to all other players.
using (var writer = MessageWriter.Get(messageType))
{
if (toPlayer)
{
var target = reader.ReadPackedInt32();
reader.CopyTo(writer);
await Player.Game.SendToAsync(writer, target);
}
else
{
reader.CopyTo(writer);
await Player.Game.SendToAllExceptAsync(writer, Id);
}
}
}
break;
}
case MessageFlags.EndGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message08EndGameC2S.Deserialize(
reader,
out var gameOverReason);
await Player !.Game.HandleEndGame(reader, gameOverReason);
break;
}
case MessageFlags.AlterGame:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message10AlterGameC2S.Deserialize(
reader,
out var gameTag,
out var value);
if (gameTag != AlterGameTags.ChangePrivacy)
{
return;
}
await Player !.Game.HandleAlterGame(reader, Player, value);
break;
}
case MessageFlags.KickPlayer:
{
if (!IsPacketAllowed(reader, true))
{
return;
}
Message11KickPlayerC2S.Deserialize(
reader,
out var playerId,
out var isBan);
await Player !.Game.HandleKickPlayer(playerId, isBan);
break;
}
case MessageFlags.GetGameListV2:
{
Message16GetGameListC2S.Deserialize(reader, out var options, out _);
await OnRequestGameListAsync(options);
break;
}
default:
if (_customMessageManager.TryGet(flag, out var customRootMessage))
{
await customRootMessage.HandleMessageAsync(this, reader, messageType);
break;
}
_logger.LogWarning("Server received unknown flag {0}.", flag);
break;
}
#if DEBUG
if (flag != MessageFlags.GameData &&
flag != MessageFlags.GameDataTo &&
flag != MessageFlags.EndGame &&
reader.Position < reader.Length)
{
_logger.LogWarning(
"Server did not consume all bytes from {0} ({1} < {2}).",
flag,
reader.Position,
reader.Length);
}
#endif
}
public async Task GetSessionID()
{
await Connection.SendAsync("GetSessionID");
}
public async Task SendDeviceInfo(string serviceID, string machineName, string deviceID)
{
await Connection.SendAsync("ReceiveDeviceInfo", serviceID, machineName, deviceID);
}
public async Task SendCursorChange(CursorInfo cursor, string viewerID)
{
await Connection.SendAsync("SendCursorChange", cursor, viewerID);
}
public async Task SendCtrlAltDel()
{
await Connection.SendAsync("CtrlAltDel");
}
public async Task SendConnectionRequestDenied(string viewerID)
{
await Connection.SendAsync("SendConnectionRequestDenied", viewerID);
}
public async Task SendConnectionFailedToViewers(List <string> viewerIDs)
{
await Connection.SendAsync("SendConnectionFailedToViewers", viewerIDs);
}
public async Task SendClipboardText(string clipboardText, string viewerID)
{
await Connection.SendAsync("SendClipboardText", clipboardText, viewerID);
}
public async Task SendAudioSample(byte[] buffer, string viewerID)
{
await Connection.SendAsync("SendAudioSample", buffer, viewerID);
}
private void ApplyConnectionHandlers()
{
var conductor = ServiceContainer.Instance.GetRequiredService <Conductor>();
Connection.Closed += (ex) =>
{
Logger.Write($"Connection closed. Error: {ex?.Message}");
return(Task.CompletedTask);
};
Connection.On("ReceiveIceCandidate", (string candidate, int sdpMlineIndex, string sdpMid, string viewerID) =>
{
try
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.RtcSession.AddIceCandidate(sdpMid, sdpMlineIndex, candidate);
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
Connection.On("ReceiveRtcAnswer", (string sdp, string viewerID) =>
{
try
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.RtcSession.SetRemoteDescription("answer", sdp);
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
Connection.On("ClipboardTransfer", (string transferText, bool typeText, string viewerID) =>
{
try
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
if (typeText)
{
KeyboardMouseInput.SendText(transferText, viewer);
}
else
{
ClipboardService.SetText(transferText);
}
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
Connection.On("CtrlAltDel", async(string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
await SendCtrlAltDel();
}
});
Connection.On("Disconnect", async(string reason) =>
{
Logger.Write($"Disconnecting caster socket. Reason: {reason}");
foreach (var viewer in conductor.Viewers.Values.ToList())
{
await Connection.SendAsync("ViewerDisconnected", viewer.ViewerConnectionID);
viewer.DisconnectRequested = true;
}
});
Connection.On("GetScreenCast", (string viewerID, string requesterName) =>
{
try
{
ScreenCaster.BeginScreenCasting(new ScreenCastRequest()
{
ViewerID = viewerID, RequesterName = requesterName
});
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
Connection.On("GetWindowsSessions", async(string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
await viewer.SendWindowsSessions();
}
});
Connection.On("RequestScreenCast", (string viewerID, string requesterName) =>
{
conductor.InvokeScreenCastRequested(new ScreenCastRequest()
{
ViewerID = viewerID, RequesterName = requesterName
});
});
Connection.On("KeyDown", (string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyDown(key, viewer);
}
});
Connection.On("KeyUp", (string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyUp(key, viewer);
}
});
Connection.On("KeyPress", async(string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyDown(key, viewer);
await Task.Delay(1);
KeyboardMouseInput.SendKeyUp(key, viewer);
}
});
Connection.On("MouseMove", (double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendMouseMove(percentX, percentY, viewer);
}
});
Connection.On("MouseDown", (int button, double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
if (button == 0)
{
KeyboardMouseInput.SendLeftMouseDown(percentX, percentY, viewer);
}
else if (button == 2)
{
KeyboardMouseInput.SendRightMouseDown(percentX, percentY, viewer);
}
}
});
Connection.On("MouseUp", (int button, double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
if (button == 0)
{
KeyboardMouseInput.SendLeftMouseUp(percentX, percentY, viewer);
}
else if (button == 2)
{
KeyboardMouseInput.SendRightMouseUp(percentX, percentY, viewer);
}
}
});
Connection.On("MouseWheel", (double deltaX, double deltaY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendMouseWheel(-(int)deltaY, viewer);
}
});
Connection.On("ViewerDisconnected", async(string viewerID) =>
{
await Connection.SendAsync("ViewerDisconnected", viewerID);
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.DisconnectRequested = true;
}
conductor.InvokeViewerRemoved(viewerID);
});
Connection.On("FrameReceived", (int bytesReceived, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.WebSocketBuffer = Math.Max(0, viewer.WebSocketBuffer - bytesReceived);
}
});
Connection.On("SelectScreen", (string displayName, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.Capturer.SetSelectedScreen(displayName);
}
});
Connection.On("QualityChange", (int qualityLevel, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.ImageQuality = qualityLevel;
}
});
Connection.On("AutoQualityAdjust", (bool isOn, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.AutoAdjustQuality = isOn;
}
});
Connection.On("ReceiveFile", async(byte[] buffer, string fileName, string messageId, bool endOfFile, bool startOfFile) =>
{
await FileDownloadService.ReceiveFile(buffer, fileName, messageId, endOfFile, startOfFile);
});
Connection.On("ToggleAudio", (bool toggleOn, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
AudioCapturer.ToggleAudio(toggleOn);
}
});
Connection.On("ToggleBlockInput", (bool toggleOn, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.ToggleBlockInput(toggleOn);
}
});
Connection.On("TouchDown", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseDown(point.X, point.Y);
}
});
Connection.On("LongPress", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendRightMouseDown(point.X, point.Y);
//Win32Interop.SendRightMouseUp(point.X, point.Y);
}
});
Connection.On("TouchMove", (double moveX, double moveY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendMouseMove(point.X + moveX, point.Y + moveY);
}
});
Connection.On("TouchUp", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseUp(point.X, point.Y);
}
});
Connection.On("Tap", (double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendLeftMouseDown(percentX, percentY, viewer);
KeyboardMouseInput.SendLeftMouseUp(percentX, percentY, viewer);
}
});
Connection.On("SharedFileIDs", (List <string> fileIDs) =>
{
fileIDs.ForEach(id =>
{
var url = $"{conductor.Host}/API/FileSharing/{id}";
var webRequest = WebRequest.CreateHttp(url);
var response = webRequest.GetResponse();
var contentDisp = response.Headers["Content-Disposition"];
var fileName = contentDisp
.Split(";".ToCharArray())
.FirstOrDefault(x => x.Trim().StartsWith("filename"))
.Split("=".ToCharArray())[1];
var legalChars = fileName.ToCharArray().Where(x => !Path.GetInvalidFileNameChars().Any(y => x == y));
fileName = new string(legalChars.ToArray());
var dirPath = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "RemotelySharedFiles")).FullName;
var filePath = Path.Combine(dirPath, fileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
using (var rs = response.GetResponseStream())
{
rs.CopyTo(fs);
}
}
Process.Start("explorer.exe", dirPath);
});
});
Connection.On("SessionID", (string sessionID) =>
{
conductor.InvokeSessionIDChanged(sessionID);
});
}
public async Task SendIceCandidateToBrowser(string candidate, int sdpMlineIndex, string sdpMid, string viewerConnectionID)
{
await Connection.SendAsync("SendIceCandidateToBrowser", candidate, sdpMlineIndex, sdpMid, viewerConnectionID);
}
public async Task NotifyRequesterUnattendedReady(string requesterID)
{
await Connection.SendAsync("NotifyRequesterUnattendedReady", requesterID);
}
public async Task SendMachineName(string machineName, string viewerID)
{
await Connection.SendAsync("SendMachineName", machineName, viewerID);
}
/// <summary>
/// Exports users from a connection to a file using a long running job.
/// </summary>
/// <remarks>
/// The documentation for user exports can be found <a href="https://auth0.com/docs/users/bulk-user-exports">here</a>.
/// </remarks>
/// <param name="request">The <see cref="UsersExportsJobRequest"/> containing the information for the job to export users.</param>
/// <returns>A <see cref="Job"/> instance containing the information about the job.</returns>
public Task <Job> ExportUsersAsync(UsersExportsJobRequest request)
{
return(Connection.SendAsync <Job>(HttpMethod.Post, BuildUri("jobs/users-exports"), request, DefaultHeaders));
}
public async Task SendRtcOfferToBrowser(string sdp, string viewerID, IceServerModel[] iceServers)
{
await Connection.SendAsync("SendRtcOfferToBrowser", sdp, viewerID, iceServers);
}
/// <summary>
/// Creates a new resource server.
/// </summary>
/// <param name="request">Contains the information for the resource server to create.</param>
/// <returns>The newly created <see cref="ResourceServer"/>.</returns>
public Task <ResourceServer> CreateAsync(ResourceServerCreateRequest request)
{
return(Connection.SendAsync <ResourceServer>(HttpMethod.Post, BuildUri("resource-servers"), request, DefaultHeaders));
}
public async Task SendScreenCapture(byte[] captureBytes, string viewerID, int left, int top, int width, int height, int imageQuality)
{
await Connection.SendAsync("SendScreenCapture", captureBytes, viewerID, left, top, width, height, imageQuality);
}
/// <summary>
/// Updates a connection.
/// </summary>
/// <param name="id">The id of the connection to update.</param>
/// <param name="request">The <see cref="ConnectionUpdateRequest"/> containing the properties of the connection you wish to update.</param>
/// <returns>The <see cref="Connection"/> that has been updated.</returns>
public Task <Connection> UpdateAsync(string id, ConnectionUpdateRequest request)
{
return(Connection.SendAsync <Connection>(new HttpMethod("PATCH"), BuildUri($"connections/{EncodePath(id)}"), request, DefaultHeaders));
}
public async Task SendScreenData(string selectedScreen, string[] displayNames, string viewerID)
{
await Connection.SendAsync("SendScreenDataToBrowser", selectedScreen, displayNames, viewerID);
}
/// <summary>
/// Deletes a connection and all its users.
/// </summary>
/// <param name="id">The id of the connection to delete.</param>
/// <returns>A <see cref="Task"/> that represents the asynchronous delete operation.</returns>
public Task DeleteAsync(string id)
{
return(Connection.SendAsync <object>(HttpMethod.Delete, BuildUri($"connections/{EncodePath(id)}"), null, DefaultHeaders));
}
public async Task SendScreenSize(int width, int height, string viewerID)
{
await Connection.SendAsync("SendScreenSize", width, height, viewerID);
}
/// <summary>
/// Sets the template for the New Universal Login Experience.
/// </summary>
/// <param name="request">The <see cref="UniversalLoginTemplateUpdateRequest"/> containing details of the template to set.</param>
/// <returns>The newly updated <see cref="UniversalLoginTemplate"/>.</returns>
public Task <UniversalLoginTemplate> SetUniversalLoginTemplateAsync(UniversalLoginTemplateUpdateRequest request)
{
return(Connection.SendAsync <UniversalLoginTemplate>(HttpMethod.Put, BuildUri("branding/templates/universal-login"), request, DefaultHeaders));
}
public async Task SendWindowsSessions(List <WindowsSession> windowsSessions, string viewerID)
{
await Connection.SendAsync("SendWindowsSessions", windowsSessions, viewerID);
}
public async Task SendViewerRemoved(string viewerID)
{
await Connection.SendAsync("SendViewerRemoved", viewerID);
}
public async Task NotifyViewersRelaunchedScreenCasterReady(string[] viewerIDs)
{
await Connection.SendAsync("NotifyViewersRelaunchedScreenCasterReady", viewerIDs);
}
