public async Task <int> CreateAnnounce([FromBody] AnnounceRequest request) { //判断request里是否满足前置条件 if (!ModelState.IsValid) { return(-5); } //取得存在cookie的当前账户id var user_id = Int32.Parse(User.Identity.Name); var role = await UserAccessor.CheckRole(user_id); if (role == Role.Student || role == Role.Provider) { return(-10); } //生成annouce实例 var announcement = _mapper.Map <AnnounceEntity>(request); announcement.user_id = user_id; //新建annouce var num = await AnnounceAccessor.Create(announcement); var s = await AnnounceAccessor.Createsend(num); return(num); }
public async ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token) { try { if (ConnectionIdTask == null || LastConnected.Elapsed > TimeSpan.FromMinutes(1)) { ConnectionIdTask = ConnectAsync(); } long connectionId = await ConnectionIdTask; var message = new AnnounceMessage(DateTime.Now.GetHashCode(), connectionId, parameters); (var response, var errorString) = await SendAndReceiveAsync(message); // Did we receive an 'ErrorMessage' from the tracker? If so, propagate the failure if (errorString != null) { ConnectionIdTask = null; return(new AnnounceResponse(TrackerState.InvalidResponse, failureMessage: errorString)); } var announce = (AnnounceResponseMessage)response; return(new AnnounceResponse(TrackerState.Ok, announce.Peers, minUpdateInterval: announce.Interval)); } catch (OperationCanceledException) { ConnectionIdTask = null; return(new AnnounceResponse(TrackerState.Offline, failureMessage: "Announce could not be completed")); } catch { ConnectionIdTask = null; return(new AnnounceResponse(TrackerState.InvalidResponse, failureMessage: "Announce could not be completed")); } }
private async Task <Stream> SendRequest(AnnounceRequest request) { byte[] peerId = new byte[20]; Array.Copy(Encoding.UTF8.GetBytes("-AZ5501-"), peerId, 8); byte[] rand = new byte[12]; Random r = new Random(); r.NextBytes(rand); Array.Copy(rand, 0, peerId, 8, 12); // Prepare query StringBuilder queryBuilder = new StringBuilder(); queryBuilder.Append("?event=started"); if (tcpConnectionDetails.PublicAddress != null) { queryBuilder.Append(string.Format("&ip={0}", tcpConnectionDetails.PublicAddress)); } queryBuilder.Append(string.Format("&port={0}", tcpConnectionDetails.Port)); // TODO: use public port queryBuilder.Append(string.Format("&peer_id={0}", Encoding.UTF8.GetString(WebUtility.UrlEncodeToBytes(peerId, 0, peerId.Length)))); queryBuilder.Append(string.Format("&left={0}", request.Remaining)); queryBuilder.Append(string.Format("&uploaded={0}", 0)); queryBuilder.Append(string.Format("&downloaded={0}", 0)); queryBuilder.Append(string.Format("&compact=1", 0)); queryBuilder.Append("&info_hash=" + Encoding.UTF8.GetString(WebUtility.UrlEncodeToBytes(request.InfoHash.Value, 0, request.InfoHash.Value.Length))); return(await HttpGet(BaseUrl.AbsoluteUri + queryBuilder)); }
private async Task ContactTracker() { _logger.LogInformation("Contacting tracker"); try { var request = new AnnounceRequest( _localPeerId, Remaining, Downloaded, Uploaded, Description.InfoHash); var result = await Tracker.Announce(request); _logger.LogInformation($"{result.Peers.Count} peers available"); ApplicationProtocol.PeersAvailable(result.Peers); } catch (Exception ex) { _logger.LogError(ex, "Unable to contact tracker"); // Cannot connect to tracker State = DownloadState.Error; } }
public AnnounceHomeModel() { CarMakes = new List <CarMake> (); CarModels = new List <CarModel>(); CarVersions = new List <CarVersion>(); Announces = new List <AnnounceModel>(); Request = new AnnounceRequest(); }
/// <summary> /// Sends the specified announce request to the tracker. /// </summary> /// <param name="request">The request to send.</param> public virtual async Task <AnnounceResult> Announce(AnnounceRequest request) { _logger.LogInformation($"Announcing to {BaseUrl}"); var response = await SendRequest(request); return(ProcessResponse(response)); }
public async Task <IActionResult> PostAnnounced(AnnounceRequest request) { var result = await ApiResultAsync <Announce>(async() => { return(await AnnounceService.PostAnnounce(request)); }); return(RedirectToAction("Index")); }
public ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token) { AnnouncedAt.Add(DateTime.Now); if (FailAnnounce) { throw new TrackerException("Deliberately failing announce request", null); } AnnounceParameters.Add(parameters); return(ReusableTask.FromResult(new AnnounceResponse(TrackerState.Ok, peers: peers.Select(t => new PeerInfo(t.ConnectionUri, t.PeerId?.AsMemory() ?? Memory <byte> .Empty)).ToArray()))); }
public async Task <Announce> PostAnnounce(AnnounceRequest request) { if (request == null) { throw new BadRequestException("O dados de requisição da criação do anúncio não foram informados."); } var entity = await WebMotorsAPI.GetAnnounceByAPI(request); return(await AnnounceRepository.InsertAnnounceAsync(entity)); }
/// <summary> /// Initial announce request information /// </summary> private void InitialAnnounceRequest() { _announceRequest = new AnnounceRequest(); _announceRequest.InfoHash = MetaInfo.InfoHash; _announceRequest.PeerId = Setting.GetPeerIdString(); _announceRequest.Compact = Setting.Compact; _announceRequest.Port = Setting.PeerListenningPort; _announceRequest.Uploaded = 0; _announceRequest.Downloaded = 0; _announceRequest.Event = EventMode.Started; }
public async Task <ActionResult <AnnounceResponse> > Get([FromQuery] AnnounceRequest request, string userId) { try { var result = await _tracker.Announce(request, userId); return(Ok(result)); } catch (Exception exception) { _logger.LogError(exception, exception.Message); return(StatusCode((int)HttpStatusCode.InternalServerError, exception.Message)); } }
Uri CreateAnnounceString(AnnounceRequest parameters) { var b = new UriQueryBuilder(Uri); b.Add("info_hash", parameters.InfoHash.UrlEncode()) .Add("peer_id", BEncodedString.FromMemory(parameters.PeerId).UrlEncode()) .Add("port", parameters.Port) .Add("uploaded", parameters.BytesUploaded) .Add("downloaded", parameters.BytesDownloaded) .Add("left", parameters.BytesLeft) .Add("compact", 1) .Add("numwant", 100); if (parameters.SupportsEncryption) { b.Add("supportcrypto", 1); } if (parameters.RequireEncryption) { b.Add("requirecrypto", 1); } if (!b.Contains("key") && Key != null) { b.Add("key", Key.UrlEncode()); } if (!string.IsNullOrEmpty(parameters.IPAddress)) { b.Add("ip", parameters.IPAddress !); } // If we have not successfully sent the started event to this tier, override the passed in started event // Otherwise append the event if it is not "none" //if (!parameters.Id.Tracker.Tier.SentStartedEvent) //{ // sb.Append("&event=started"); // parameters.Id.Tracker.Tier.SendingStartedEvent = true; //} if (parameters.ClientEvent != TorrentEvent.None) { b.Add("event", parameters.ClientEvent.ToString().ToLower()); } if (!BEncodedString.IsNullOrEmpty(TrackerId)) { b.Add("trackerid", TrackerId !.UrlEncode()); } return(b.ToUri()); }
public Task <AnnounceResult> Announce(AnnounceRequest request) { File.WriteAllText(Path.Combine(_baseDir, "announce", $"{_peerId}.txt"), _peerId.ToString()); var peers = Directory.GetFiles(Path.Combine(_baseDir, "announce")).Where(x => Path.GetFileName(x) != $"{_peerId}.txt") .Select(x => { var peerId = File.ReadAllText(x); return(new FileTransportStream( new DirectoryInfo(Path.Combine(_baseDir, _peerId.ToString(), peerId)), new DirectoryInfo(Path.Combine(_baseDir, peerId, _peerId.ToString())))); }).ToList(); return(Task.FromResult(new AnnounceResult(peers))); }
public async Task <IActionResult> Post(AnnounceRequest request) { if (string.IsNullOrWhiteSpace(request.Message)) { return(Ok()); // Do not send empty message } var channel = await _discordService.GetChannelAsync(request.ChannelId); if (channel == null) { return(NoContent()); // Channel not found } await channel.SendMessageAsync(request.Message); return(Ok()); }
public void SerializesAnnounceRequest() { var hash = new byte[20]; hash[18] = 0xfb; hash[19] = 0xff; var peerId = new byte[20]; peerId[18] = 0xfc; peerId[19] = 0xff; var announcement = new AnnounceRequest(hash, peerId, 0xb268, new State(0, 0, 0), 0, 0xc8, EventType.Completed, null, 0xfaff, 0xffff); var ser = GetSerializer(); var request = ser.Serialize(announcement); Assert.Equal(SharedData.AnnounceRequest, request); }
public async Task <AnnounceResult> Announce(AnnounceRequest request) { if (request == null) { throw new ArgumentNullException(nameof(request)); } int transactionId = rand.Next(); var connectionResponse = await SendAndWaitForResponse <ConnectionResponseMessage>(new ConnectionRequestMessage { ConnectionId = ConnectionProtocolId, // Identifies tracker UDP protocol TransactionId = transactionId }); if (connectionResponse.TransactionId != transactionId) { throw new InvalidDataException("Mismatching transaction ID"); } long connectionId = connectionResponse.ConnectionId; transactionId = rand.Next(); var announceResponse = await SendAndWaitForResponse <AnnounceResponseMessage>(new AnnounceRequestMessage { ConnectionId = connectionId, TransactionId = transactionId, InfoHash = request.InfoHash, PeerId = new byte[20], // todo Downloaded = 0, // todo LeftToDownload = request.Remaining, Uploaded = 0, // todo Event = AnnounceRequestMessage.EventType.Started, IPAddress = tcpConnectionDetails.PublicAddress, Key = rand.Next(), NumWant = -1, // default Port = (ushort)tcpConnectionDetails.Port }); if (announceResponse.TransactionId != transactionId) { throw new InvalidDataException("Mismatching transaction ID"); } return(new AnnounceResult(announceResponse.Peers.Select(x => new TcpTransportStream(tcpConnectionDetails.BindAddress, x.IPAddress, x.Port)))); }
public async Task <int> CreateAnnounce([FromBody] AnnounceRequest request) { //判断request里是否满足前置条件 if (!ModelState.IsValid) { return(-5); } //取得存在cookie的当前账户id var user_id = 6;//Int32.Parse(User.Identity.Name); //生成annouce实例 var announcement = _mapper.Map <AnnounceEntity>(request); announcement.user_id = user_id; //新建annouce var num = await AnnounceAccessor.Create(announcement); return(user_id); }
/// <inheritdoc/> public Uri Serialize(Uri baseUri, AnnounceRequest announcement) { baseUri = baseUri ?? throw new ArgumentNullException(nameof(baseUri)); if (!(string.Compare(baseUri.Scheme, "http", true) == 0 || string.Compare(baseUri.Scheme, "https", true) == 0)) { throw new NotSupportedException($"Request schema {baseUri.Scheme} not supported"); } var query = new List <string> { $"info_hash={HttpUtility.UrlEncode(announcement.Hash)}", $"peer_id={HttpUtility.UrlEncode(announcement.PeerId)}", $"port={announcement.Port}", $"uploaded={announcement.State.Uploaded}", $"downloaded={announcement.State.Downloaded}", $"left={announcement.State.Left}", $"num_want={announcement.NumWant}", $"key={announcement.Key}", "compact=1" }; if (announcement.State.Corrupt != null) { query.Add($"corrupt={announcement.State.Corrupt.Value}"); } if (announcement.IPAddress != null) { query.Add($"ip={announcement.IPAddress.ToString()}"); } if (announcement.Event != EventType.None) { query.Add(Enum.GetName(typeof(EventType), announcement.Event).ToLowerInvariant()); } var builder = new UriBuilder(baseUri) { Query = string.Join("&", query) }; return(builder.Uri); }
public AnnounceMessage(int transactionId, long connectionId, AnnounceRequest parameters) : base(1, transactionId) { ConnectionId = connectionId; if (parameters == null) { return; } Downloaded = parameters.BytesDownloaded; InfoHash = parameters.InfoHash; IP = 0; Key = (uint)DateTime.Now.GetHashCode(); // FIXME: Don't do this! It should be constant Left = parameters.BytesLeft; NumWanted = 50; PeerId = parameters.PeerId; Port = (ushort)parameters.Port; TorrentEvent = parameters.ClientEvent; Uploaded = parameters.BytesUploaded; }
public virtual BEncodedDictionary Handle(NameValueCollection collection, IPAddress remoteAddress, bool isScrape) { if (collection == null) { throw new ArgumentNullException(nameof(collection)); } if (remoteAddress == null) { throw new ArgumentNullException(nameof(remoteAddress)); } TrackerRequest request; if (isScrape) { request = new TrackerScrapeRequest(collection, remoteAddress); } else { request = new AnnounceRequest(collection, remoteAddress); } // If the parameters are invalid, the failure reason will be added to the response dictionary if (!request.IsValid) { return(request.Response); } // Fire the necessary event so the request will be handled and response filled in if (isScrape) { RaiseScrapeReceived((TrackerScrapeRequest)request); } else { RaiseAnnounceReceived((AnnounceRequest)request); } // Return the response now that the connection has been handled correctly. return(request.Response); }
public async Task PerformsRequest() { var peerId = GeneratePeerId(); var announcement = new AnnounceRequest(Hash, Encoding.ASCII.GetBytes(peerId), 6882, new State(0, 0, 0)); using (var httpClient = new HttpClient()) { var helper = new DefaultHttpSerializer(false); var req = new HttpRequestMessage(); req.Headers.Clear(); req.Headers.Add("User-Agent", "something"); req.RequestUri = helper.Serialize(Tracker, announcement); var response = await httpClient.SendAsync(req); Assert.True(response.IsSuccessStatusCode); var bytes = await response.Content.ReadAsByteArrayAsync(); var resp = helper.Deserialize(bytes); Assert.True(resp.Peers.Count > 0); } }
private async Task <Stream> SendRequest(AnnounceRequest request) { var encodedPeerId = WebUtility.UrlEncodeToBytes(request.PeerId.Value.ToArray(), 0, request.PeerId.Value.Count); // Prepare query StringBuilder queryBuilder = new StringBuilder(); queryBuilder.Append("?event=started"); if (_tcpConnectionDetails.PublicAddress != null) { queryBuilder.Append(string.Format("&ip={0}", _tcpConnectionDetails.PublicAddress)); } queryBuilder.Append(string.Format("&port={0}", _tcpConnectionDetails.Port)); // TODO: use public port queryBuilder.Append(string.Format("&peer_id={0}", Encoding.UTF8.GetString(encodedPeerId))); queryBuilder.Append(string.Format("&left={0}", request.Remaining)); queryBuilder.Append(string.Format("&uploaded={0}", request.Uploaded)); queryBuilder.Append(string.Format("&downloaded={0}", request.Downloaded)); queryBuilder.Append(string.Format("&compact=1", 0)); queryBuilder.Append("&info_hash=" + Encoding.UTF8.GetString(WebUtility.UrlEncodeToBytes(request.InfoHash.Value, 0, request.InfoHash.Value.Length))); return(await HttpGet(BaseUrl.AbsoluteUri + queryBuilder)); }
private async Task ContactTracker() { Log.LogInformation("Contacting tracker"); try { var request = new AnnounceRequest( localPeerId, Remaining, Description.InfoHash); var result = await Tracker.Announce(request); Log.LogInformation($"{result.Peers.Count} peers available"); ApplicationProtocol.PeersAvailable(result.Peers); } catch (System.Net.Http.HttpRequestException) { // Cannot connect to tracker State = DownloadState.Error; } }
public async Task <AnnounceResponse> Announce(AnnounceRequest request, string userId) { var eventId = request.GenerateEventId(); _logger.LogInformation(eventId, "announceRequest: {announceRequest} userId: {userId}", request, userId); if (request == null) { _logger.LogError(eventId, "announceRequest is null. userId: {userId}", userId); return(CreateResponseFromError($"The incoming request is in bad state. EventId: {eventId}")); } if (string.IsNullOrWhiteSpace(userId)) { _logger.LogError(eventId, "UserId is null. announceRequest: {announceRequest}", request); return(CreateResponseFromError($"The incoming request is in bad state. EventId: {eventId}")); } try { var context = await _sharingOperation.GetSharingContext(userId, request.Info_Hash); if (context == null) { _logger.LogWarning(eventId, "sharing context not found"); return(CreateResponseFromError($"This file no longer exists. EventId: {eventId}")); } var response = CreateResponseFromContext(context); response.TrackerId = request.TrackerId ?? Guid.NewGuid().ToString(); return(response); } catch (Exception exception) { _logger.LogError(eventId, exception, exception.Message); return(CreateResponseFromError($"Something went wrong while fetching the announce information. EventId: {eventId}")); } }
public async ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token) { // WebRequest.Create can be a comparatively slow operation as reported // by profiling. Switch this to the threadpool so the querying of default // proxies, and any DNS requests, are definitely not run on the main thread. await new ThreadSwitcher(); var peers = new List <PeerInfo> (); Uri announceString = CreateAnnounceString(parameters); HttpResponseMessage response; try { response = await Client.GetAsync(announceString, HttpCompletionOption.ResponseHeadersRead, token); } catch { return(new AnnounceResponse( state: TrackerState.Offline, failureMessage: "The tracker could not be contacted" )); } try { using var responseRegistration = token.Register(() => response.Dispose()); using (response) { var announceResponse = await AnnounceReceivedAsync(response).ConfigureAwait(false); logger.InfoFormatted("Tracker {0} sent {1} peers", Uri, peers.Count); return(announceResponse); } } catch { return(new AnnounceResponse( state: TrackerState.InvalidResponse, failureMessage: "The tracker returned an invalid or incomplete response" )); } }
/// <summary> /// Returns the <see cref="AnnounceRequest.ClientAddress"/> field to use to compare peers. /// </summary> /// <param name="parameters">The data sent as part of the Announce request</param> /// <returns></returns> public object GetKey(AnnounceRequest parameters) { return(parameters.ClientAddress); }
public Task <AnnounceResult> Announce(AnnounceRequest request) { var result = new AnnounceResult(peers.Select(x => new TcpTransportStream(IPAddress.Loopback, x.Address, x.Port))); return(Task.FromResult(result)); }
protected void RaiseAnnounceReceived(AnnounceRequest e) { AnnounceReceived?.Invoke(this, e); }
/// <summary> /// Sends the specified announce request to the tracker. /// </summary> /// <param name="request">The request to send.</param> public virtual async Task <AnnounceResult> Announce(AnnounceRequest request) { var response = await SendRequest(request); return(ProcessResponse(response)); }
/// <summary> /// Returns the <see cref="AnnounceRequest.PeerId"/> field to use to compare peers. /// </summary> /// <param name="parameters">The data sent as part of the Announce request</param> /// <returns></returns> public object GetKey(AnnounceRequest parameters) { return(parameters.PeerId); }