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);
}
