public NetSendResult EnqueueMessage(OperationType opType, PacketPayload payload, DeliveryMethod method, bool encrypt, byte channel, int connectionId) { outgoingMessageQueue.syncRoot.EnterWriteLock(); try { //This is similar to how Photon works on the Unity client. //They enqueue actions outgoingMessageQueue.Enqueue(() => { INetworkMessageRouterService sender = sendServiceStrategy.GetRouterService(connectionId); sender.TrySendMessage(opType, payload, method, encrypt, channel); }); //signal any handlers that a message is in the queue //it is important to do this in a lock. Reset could be called after Set //in the other thread and we'd end up with potential unhandled messages in that race condition outgoingMessageQueue.QueueSemaphore.Set(); } finally { outgoingMessageQueue.syncRoot.ExitWriteLock(); } return NetSendResult.Queued; }
public static bool Verify(this IStaticPayloadParameters actualParameters, bool encrypt, byte channel, DeliveryMethod method) { Throw<ArgumentNullException>.If.IsNull(actualParameters) ?.Now(nameof(actualParameters), $"{nameof(actualParameters)} cannot be null for {nameof(Verify)} extension method."); //Checks if the parameters match the expectation. return actualParameters.Channel == channel && actualParameters.Encrypted == encrypt && actualParameters.DeliveryMethod == method; }
public static void Test_DeliveryMethod_Is_As_Expected(bool isUnreliable, DeliveryMethod expectedMethod) { //arrange PhotonMessageParametersAdapter parameters = new PhotonMessageParametersAdapter(new Photon.SocketServer.SendParameters() { Unreliable = isUnreliable }); //assert Assert.AreEqual(expectedMethod, parameters.DeliveryMethod); }
/// <summary> /// Sends the specified to send message. /// </summary> /// <param name="toSendMessage">To send message.</param> /// <param name="deliveryMethod">The delivery method.</param> public void Send(OutgoingMessage toSendMessage, DeliveryMethod deliveryMethod) { foreach (var netConnection in this.server.Connections) { var message = this.server.CreateMessage(toSendMessage.Message.LengthBytes); message.Write(toSendMessage.Message.Data); this.server.SendMessage(message, netConnection, (NetDeliveryMethod)deliveryMethod); } }
/// <summary> /// Child implemented sending functionality. Sends a provided <see cref="INetworkMessage"/> strategy /// </summary> /// <param name="message">Network message to send.</param> /// <param name="deliveryMethod">Delivery method to send.</param> /// <param name="encrypt">Indicates if the message should be encrypted before being sent.</param> /// <param name="channel"></param> /// <returns></returns> protected override NetSendResult SendMessage(INetworkMessage message, DeliveryMethod deliveryMethod, bool encrypt, byte channel) { if (this.lidgrenNetworkConnection.Peer.Status != NetPeerStatus.Running) #if DEBUG || DEBUGBUILD throw new InvalidOperationException($"The {this.lidgrenNetworkConnection.GetType().Name} is not currently running."); #else return NetSendResult.FailedNotConnected; #endif NetOutgoingMessage outgoingMessage = this.lidgrenNetworkConnection.Peer.CreateMessage(); //TODO: Create a system to estimate message size. //We only need to serialize and send for user-messages outgoingMessage.Write(message.SerializeWithVisitor(serializer)); return this.lidgrenNetworkConnection.SendMessage(outgoingMessage, deliveryMethod.ToLidgren(), channel); }
private DeliveryMethodModel CreateDeliveryMethodModel(DeliveryMethod deliveryMethod) { DeliveryMethodModel model = new DeliveryMethodModel() { Id = deliveryMethod.Id, Name = deliveryMethod.Name, LogoUrl = deliveryMethod.LogoUrl, Description = deliveryMethod.Description, DeliveryPrice = deliveryMethod.DeliveryPrice, CODTax = deliveryMethod.CODTax, OrderIndex = deliveryMethod.OrderIndex }; this.deliveryMethodsTracker.TrackItemCreated(model); return model; }
public void Send(MailMessage message) { if (Logging.On) { Logging.Enter(Logging.Web, this, "Send", message); } if (disposed) { throw new ObjectDisposedException(this.GetType().FullName); } try { if (Logging.On) { Logging.PrintInfo(Logging.Web, this, "Send", "DeliveryMethod=" + DeliveryMethod.ToString()); } if (Logging.On) { Logging.Associate(Logging.Web, this, message); } SmtpFailedRecipientException recipientException = null; if (InCall) { throw new InvalidOperationException(SR.GetString(SR.net_inasync)); } if (message == null) { throw new ArgumentNullException("message"); } if (DeliveryMethod == SmtpDeliveryMethod.Network) { CheckHostAndPort(); } MailAddressCollection recipients = new MailAddressCollection(); if (message.From == null) { throw new InvalidOperationException(SR.GetString(SR.SmtpFromRequired)); } if (message.To != null) { foreach (MailAddress address in message.To) { recipients.Add(address); } } if (message.Bcc != null) { foreach (MailAddress address in message.Bcc) { recipients.Add(address); } } if (message.CC != null) { foreach (MailAddress address in message.CC) { recipients.Add(address); } } if (recipients.Count == 0) { throw new InvalidOperationException(SR.GetString(SR.SmtpRecipientRequired)); } transport.IdentityRequired = false; // everything completes on the same thread. try { InCall = true; timedOut = false; timer = new Timer(new TimerCallback(this.TimeOutCallback), null, Timeout, Timeout); bool allowUnicode = false; string pickupDirectory = PickupDirectoryLocation; MailWriter writer; switch (DeliveryMethod) { #if !FEATURE_PAL case SmtpDeliveryMethod.PickupDirectoryFromIis: pickupDirectory = IisPickupDirectory.GetPickupDirectory(); goto case SmtpDeliveryMethod.SpecifiedPickupDirectory; #endif // !FEATURE_PAL case SmtpDeliveryMethod.SpecifiedPickupDirectory: if (EnableSsl) { throw new SmtpException(SR.GetString(SR.SmtpPickupDirectoryDoesnotSupportSsl)); } allowUnicode = IsUnicodeSupported(); // Determend by the DeliveryFormat paramiter ValidateUnicodeRequirement(message, recipients, allowUnicode); writer = GetFileMailWriter(pickupDirectory); break; case SmtpDeliveryMethod.Network: default: GetConnection(); // Detected durring GetConnection(), restrictable using the DeliveryFormat paramiter allowUnicode = IsUnicodeSupported(); ValidateUnicodeRequirement(message, recipients, allowUnicode); writer = transport.SendMail(message.Sender ?? message.From, recipients, message.BuildDeliveryStatusNotificationString(), allowUnicode, out recipientException); break; } this.message = message; message.Send(writer, DeliveryMethod != SmtpDeliveryMethod.Network, allowUnicode); writer.Close(); transport.ReleaseConnection(); //throw if we couldn't send to any of the recipients if (DeliveryMethod == SmtpDeliveryMethod.Network && recipientException != null) { throw recipientException; } } catch (Exception e) { if (Logging.On) { Logging.Exception(Logging.Web, this, "Send", e); } if (e is SmtpFailedRecipientException && !((SmtpFailedRecipientException)e).fatal) { throw; } Abort(); if (timedOut) { throw new SmtpException(SR.GetString(SR.net_timeout)); } if (e is SecurityException || e is AuthenticationException || e is SmtpException) { throw; } throw new SmtpException(SR.GetString(SR.SmtpSendMailFailure), e); } finally { InCall = false; if (timer != null) { timer.Dispose(); } } } finally { if (Logging.On) { Logging.Exit(Logging.Web, this, "Send", null); } } }
public override void SendMessage(INetworkMessage message, IEnumerable<IRemote> recipients, DeliveryMethod method, int sequenceChannel) { if (!recipients.Any()) return; var clients = recipients .Cast<Client>() .Select(x => x.Connection) .ToArray(); Peer.SendMessage(PrepareMessage(message), clients, (NetDeliveryMethod) method, sequenceChannel); }
/// <summary> /// Res the send to clients. /// </summary> /// <param name="obj">The object.</param> /// <param name="deliveryMethod">The delivery method.</param> public void ReSendToClients(IncomingMessage obj, DeliveryMethod deliveryMethod) { this.networkServer.Send(obj, deliveryMethod); }
internal abstract void SendUpdate(bool isInitial, long connectionId, DeliveryMethod deliveryMethod);
/// <summary> /// Send data to all connected peers /// </summary> /// <param name="data">Data</param> /// <param name="options">Send options (reliable, unreliable, etc.)</param> public void SendToAll(byte[] data, DeliveryMethod options) { SendToAll(data, 0, data.Length, options); }
/// <summary> /// An owner cannot sell to himself. Business Rule. /// </summary> /// <param name="entity"></param> /// <summary> /// Note. When an entity is sent, either send the entity, or it's Id or both. /// </summary> /// <param name="comment"></param> /// <param name="consignTo"></param> /// <param name="consignToId"></param> /// <param name="deliveryMethod"></param> /// <param name="deliveryMethodId"></param> /// <param name="expectedDate"></param> /// <param name="informTo"></param> /// <param name="informToId"></param> /// <param name="miscPaymentAmount"></param> /// <param name="name"></param> /// <param name="owner"></param> /// <param name="ownerId"></param> /// <param name="paymentMethod"></param> /// <param name="paymentMethodId"></param> /// <param name="paymentTerm"></param> /// <param name="paymentTermId"></param> /// <param name="saleOrderTypeENUM"></param> /// <param name="salesman"></param> /// <param name="salesmanId"></param> /// <param name="shippingAmount"></param> /// <param name="shipTo"></param> /// <param name="shipToId"></param> /// <param name="taxAmount"></param> /// <param name="theirPurchaseOrderNumber"></param> /// <returns></returns> public bool CreateAutomaticly( string comment, Customer consignTo, Guid?consignToId, DeliveryMethod deliveryMethod, Guid?deliveryMethodId, DateTime expectedDate, AddressWithId informTo, Guid?informToId, decimal miscPaymentAmount, Owner owner, Guid?ownerId, PaymentMethod paymentMethod, Guid?paymentMethodId, PaymentTerm paymentTerm, Guid?paymentTermId, SaleTypeEnum saleOrderTypeENUM, Salesman salesman, Guid?salesmanId, decimal shippingAmount, AddressWithId shipTo, Guid?shipToId, decimal taxAmount, string theirPurchaseOrderNumber) { //Sale is the default type //SalesOrder so = new SalesOrder( // comment, // consignTo, // consignToId, // deliveryMethod, // deliveryMethodId, // expectedDate, // informTo, // informToId, // miscPaymentAmount, // name, // owner, // ownerId, // paymentMethod, // paymentMethodId, // paymentTerm, // paymentTermId, // saleOrderTypeENUM, // salesman, // salesmanId, // shippingAmount, // shipTo, // shipToId, // taxAmount, // theirPurchaseOrderNumber); SalesOrder so = Factory(); //Get parameter values so.MetaData.Comment = comment; so.ConsignTo = consignTo; so.ConsignToId = consignToId; so.DeliveryMethod = deliveryMethod; so.DeliveryMethodId = deliveryMethodId; //so.ExpectedDate = expectedDate; //so.InformToAddress = informTo.ToAddressComplex; so.InformToId = informToId; //so.MiscPaymentAmount = miscPaymentAmount; so.Owner = owner; if (!(ownerId.IsNullOrEmpty())) { so.OwnerId = ownerId.GetValueOrDefault(); } so.PaymentMethod = paymentMethod; so.PaymentMethodId = paymentMethodId; so.PaymentTerm = paymentTerm; so.PaymentTermId = paymentTermId; so.SaleTypeENUM = saleOrderTypeENUM; so.Salesman = salesman; so.SalesmanId = salesmanId; so.MiscCharges.ShippingAmount = shippingAmount; //so.ShipToAddress = shipTo.ToAddressComplex; so.ShipToId = shipToId; so.MiscCharges.TaxAmount = taxAmount; so.TheirPurchaseOrderNumber = theirPurchaseOrderNumber; //load the consignToAddress and the OwnersAddress //so.ConsignToAddress = ((Address)consignTo.AddressFromUser).ToAddressComplex; //so.OwnersAddress = ((Address) owner.AddressFromUser).ToAddressComplex; Create(so); return(true); }
public void SendMessage(short opCode, ISerializablePacket packet, DeliveryMethod method) { var msg = MessageHelper.Create(opCode, packet.ToBytes()); Peer.SendMessage(msg, method); }
/// <summary> /// Send data to peer /// </summary> /// <param name="data">Data</param> /// <param name="start">Start of data</param> /// <param name="length">Length of data</param> /// <param name="options">Send options (reliable, unreliable, etc.)</param> /// <exception cref="TooBigPacketException"> /// If size exceeds maximum limit:<para/> /// MTU - headerSize bytes for Unreliable<para/> /// Fragment count exceeded ushort.MaxValue<para/> /// </exception> public void Send(byte[] data, int start, int length, DeliveryMethod options) { if (_connectionState == ConnectionState.ShutdownRequested || _connectionState == ConnectionState.Disconnected) { return; } //Prepare PacketProperty property = SendOptionsToProperty(options); int headerSize = NetPacket.GetHeaderSize(property); int mtu = _mtu; //Check fragmentation if (length + headerSize > mtu) { if (options == DeliveryMethod.Sequenced || options == DeliveryMethod.Unreliable) { throw new TooBigPacketException("Unreliable packet size exceeded maximum of " + (_mtu - headerSize) + " bytes"); } int packetFullSize = mtu - headerSize; int packetDataSize = packetFullSize - NetConstants.FragmentHeaderSize; int fullPacketsCount = length / packetDataSize; int lastPacketSize = length % packetDataSize; int totalPackets = fullPacketsCount + (lastPacketSize == 0 ? 0 : 1); NetUtils.DebugWrite("FragmentSend:\n" + " MTU: {0}\n" + " headerSize: {1}\n" + " packetFullSize: {2}\n" + " packetDataSize: {3}\n" + " fullPacketsCount: {4}\n" + " lastPacketSize: {5}\n" + " totalPackets: {6}", mtu, headerSize, packetFullSize, packetDataSize, fullPacketsCount, lastPacketSize, totalPackets); if (totalPackets > ushort.MaxValue) { throw new TooBigPacketException("Data was split in " + totalPackets + " fragments, which exceeds " + ushort.MaxValue); } int dataOffset = headerSize + NetConstants.FragmentHeaderSize; lock (_sendLock) { for (ushort i = 0; i < fullPacketsCount; i++) { NetPacket p = _packetPool.Get(property, packetFullSize); p.FragmentId = _fragmentId; p.FragmentPart = i; p.FragmentsTotal = (ushort)totalPackets; p.IsFragmented = true; Buffer.BlockCopy(data, i * packetDataSize, p.RawData, dataOffset, packetDataSize); SendPacket(p); } if (lastPacketSize > 0) { NetPacket p = _packetPool.Get(property, lastPacketSize + NetConstants.FragmentHeaderSize); p.FragmentId = _fragmentId; p.FragmentPart = (ushort)fullPacketsCount; //last p.FragmentsTotal = (ushort)totalPackets; p.IsFragmented = true; Buffer.BlockCopy(data, fullPacketsCount * packetDataSize, p.RawData, dataOffset, lastPacketSize); SendPacket(p); } _fragmentId++; } return; } //Else just send NetPacket packet = _packetPool.GetWithData(property, data, start, length); SendPacket(packet); }
public SendResult TryRouteMessage <TMessageType>([NotNull] TMessageType message, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0) where TMessageType : INetworkMessage, IRoutableMessage, IOperationTypeMappable { if (message == null) { throw new ArgumentNullException(nameof(message)); } //TODO: Deal with additional parameters switch (message.OperationTypeMappedValue) { case OperationType.Request: return(requestEnqueueStrat.EnqueueRequest(message as RequestMessage)); //TODO: use IRequestMessage case OperationType.Event: case OperationType.Response: default: throw new InvalidProgramException($"ASP client cannot handle message types other than {nameof(IRequestMessage)}."); } }
/// <summary> /// Gets maximum size of packet that will be not fragmented. /// </summary> /// <param name="options">Type of packet that you want send</param> /// <returns>size in bytes</returns> public int GetMaxSinglePacketSize(DeliveryMethod options) { return(_mtu - NetPacket.GetHeaderSize(SendOptionsToProperty(options))); }
/// <summary> /// Send data to peer /// </summary> /// <param name="dataWriter">DataWriter with data</param> /// <param name="options">Send options (reliable, unreliable, etc.)</param> /// <exception cref="TooBigPacketException"> /// If size exceeds maximum limit:<para/> /// MTU - headerSize bytes for Unreliable<para/> /// Fragment count exceeded ushort.MaxValue<para/> /// </exception> public void Send(NetDataWriter dataWriter, DeliveryMethod options) { Send(dataWriter.Data, 0, dataWriter.Length, options); }
/// <summary> /// Gets MessageType corresponding to the given LiteNetLib DeliveryMethod /// </summary> /// <param name="deliveryMethod">Delivery method</param> /// <returns>Corresponding MessageType to the given LiteNetLib DeliveryMethod</returns> public static MessageType GetDeliveryMethod(DeliveryMethod deliveryMethod) { return((MessageType)deliveryMethod); }
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { if (peer.EndPoint.Port == ClientLogic.GAME_SERVER_PORT && ClientPacketHandler.Instance.GameServer != peer) { ClientPacketHandler.Instance.GameServer = peer; Debug.Log("Peer to game server"); } byte packetType = reader.GetByte(); if (packetType >= NetworkGeneral.PacketTypesCount) { return; } PacketType pt = (PacketType)packetType; ClientPacketHandler.Instance.ProcessManuallySerializedPacket(pt, reader); }
public void SendAsync(MailMessage message, object userToken) { if (disposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (Logging.On) { Logging.Enter(Logging.Web, this, "SendAsync", "DeliveryMethod=" + DeliveryMethod.ToString()); } GlobalLog.Enter("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync Transport#" + ValidationHelper.HashString(transport)); try { if (InCall) { throw new InvalidOperationException(SR.GetString(SR.net_inasync)); } if (message == null) { throw new ArgumentNullException("message"); } if (DeliveryMethod == SmtpDeliveryMethod.Network) { CheckHostAndPort(); } recipients = new MailAddressCollection(); if (message.From == null) { throw new InvalidOperationException(SR.GetString(SR.SmtpFromRequired)); } if (message.To != null) { foreach (MailAddress address in message.To) { recipients.Add(address); } } if (message.Bcc != null) { foreach (MailAddress address in message.Bcc) { recipients.Add(address); } } if (message.CC != null) { foreach (MailAddress address in message.CC) { recipients.Add(address); } } if (recipients.Count == 0) { throw new InvalidOperationException(SR.GetString(SR.SmtpRecipientRequired)); } try { InCall = true; cancelled = false; this.message = message; string pickupDirectory = PickupDirectoryLocation; #if !FEATURE_PAL CredentialCache cache; // Skip token capturing if no credentials are used or they don't include a default one. // Also do capture the token if ICredential is not of CredentialCache type so we don't know what the exact credential response will be. transport.IdentityRequired = Credentials != null && (Credentials is SystemNetworkCredential || (cache = Credentials as CredentialCache) == null || cache.IsDefaultInCache); #endif // !FEATURE_PAL asyncOp = AsyncOperationManager.CreateOperation(userToken); switch (DeliveryMethod) { #if !FEATURE_PAL case SmtpDeliveryMethod.PickupDirectoryFromIis: pickupDirectory = IisPickupDirectory.GetPickupDirectory(); goto case SmtpDeliveryMethod.SpecifiedPickupDirectory; #endif // !FEATURE_PAL case SmtpDeliveryMethod.SpecifiedPickupDirectory: { if (EnableSsl) { throw new SmtpException(SR.GetString(SR.SmtpPickupDirectoryDoesnotSupportSsl)); } writer = GetFileMailWriter(pickupDirectory); bool allowUnicode = IsUnicodeSupported(); ValidateUnicodeRequirement(message, recipients, allowUnicode); message.Send(writer, true, allowUnicode); if (writer != null) { writer.Close(); } transport.ReleaseConnection(); AsyncCompletedEventArgs eventArgs = new AsyncCompletedEventArgs(null, false, asyncOp.UserSuppliedState); InCall = false; asyncOp.PostOperationCompleted(onSendCompletedDelegate, eventArgs); break; } case SmtpDeliveryMethod.Network: default: operationCompletedResult = new ContextAwareResult(transport.IdentityRequired, true, null, this, _ContextSafeCompleteCallback); lock (operationCompletedResult.StartPostingAsyncOp()) { GlobalLog.Print("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync calling BeginConnect. Transport#" + ValidationHelper.HashString(transport)); transport.BeginGetConnection(ServicePoint, operationCompletedResult, ConnectCallback, operationCompletedResult); operationCompletedResult.FinishPostingAsyncOp(); } break; } } catch (Exception e) { InCall = false; if (Logging.On) { Logging.Exception(Logging.Web, this, "Send", e); } if (e is SmtpFailedRecipientException && !((SmtpFailedRecipientException)e).fatal) { throw; } Abort(); if (timedOut) { throw new SmtpException(SR.GetString(SR.net_timeout)); } if (e is SecurityException || e is AuthenticationException || e is SmtpException) { throw; } throw new SmtpException(SR.GetString(SR.SmtpSendMailFailure), e); } } finally { if (Logging.On) { Logging.Exit(Logging.Web, this, "SendAsync", null); } GlobalLog.Leave("SmtpClient#" + ValidationHelper.HashString(this) + "::SendAsync"); } }
/// <summary> /// Sets the DeliveryMethod property /// </summary> /// <param name="deliveryMethod">DeliveryMethod property</param> /// <returns>this instance</returns> public ItemLookupRequest WithDeliveryMethod(DeliveryMethod deliveryMethod) { this.deliveryMethodField = deliveryMethod; return this; }
public SendResult TrySendMessage(OperationType opType, PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0) { return(CanSend(opType) ? SendRequest(payload, deliveryMethod, encrypt, channel) : SendResult.Invalid); }
internal void AddReliablePacket(DeliveryMethod method, NetPacket p) { if (p.IsFragmented) { NetDebug.Write("Fragment. Id: {0}, Part: {1}, Total: {2}", p.FragmentId, p.FragmentPart, p.FragmentsTotal); //Get needed array from dictionary ushort packetFragId = p.FragmentId; IncomingFragments incomingFragments; if (!_holdedFragments.TryGetValue(packetFragId, out incomingFragments)) { incomingFragments = new IncomingFragments { Fragments = new NetPacket[p.FragmentsTotal], ChannelId = p.ChannelId }; _holdedFragments.Add(packetFragId, incomingFragments); } //Cache var fragments = incomingFragments.Fragments; //Error check if (p.FragmentPart >= fragments.Length || fragments[p.FragmentPart] != null || p.ChannelId != incomingFragments.ChannelId) { _packetPool.Recycle(p); NetDebug.WriteError("Invalid fragment packet"); return; } //Fill array fragments[p.FragmentPart] = p; //Increase received fragments count incomingFragments.ReceivedCount++; //Increase total size incomingFragments.TotalSize += p.Size - NetConstants.FragmentedHeaderTotalSize; //Check for finish if (incomingFragments.ReceivedCount != fragments.Length) { return; } //just simple packet NetPacket resultingPacket = _packetPool.GetPacket(incomingFragments.TotalSize); int firstFragmentSize = fragments[0].Size - NetConstants.FragmentedHeaderTotalSize; for (int i = 0; i < incomingFragments.ReceivedCount; i++) { var fragment = fragments[i]; //Create resulting big packet Buffer.BlockCopy( fragment.RawData, NetConstants.FragmentedHeaderTotalSize, resultingPacket.RawData, firstFragmentSize * i, fragment.Size - NetConstants.FragmentedHeaderTotalSize); //Free memory _packetPool.Recycle(fragment); } Array.Clear(fragments, 0, incomingFragments.ReceivedCount); //Send to process NetManager.CreateReceiveEvent(resultingPacket, method, 0, this); //Clear memory _holdedFragments.Remove(packetFragId); } else //Just simple packet { NetManager.CreateReceiveEvent(p, method, NetConstants.ChanneledHeaderSize, this); } }
private void ReceivedNetworkData(NetPeer peer, NetDataReader reader, DeliveryMethod deliveryMethod) { netPacketProcessor.ReadAllPackets(reader, peer); }
public void SendMessage(IOutgoingMessage message, DeliveryMethod method) { Peer.SendMessage(message, method); }
private static void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { PacketID id = (PacketID)reader.GetByte(); switch (id) { case PacketID.PlayerUpdatePacket: break; } }
public void SendMessage(short opCode, string data, DeliveryMethod method) { var msg = MessageHelper.Create(opCode, data); Peer.SendMessage(msg, method); }
public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { }
/// <summary> /// Send data to all connected peers /// </summary> /// <param name="writer">DataWriter with data</param> /// <param name="options">Send options (reliable, unreliable, etc.)</param> public void SendToAll(NetDataWriter writer, DeliveryMethod options) { SendToAll(writer.Data, 0, writer.Length, options); }
void sendToBoth <T> (T packet, DeliveryMethod deliveryMethod) where T : Packet { PacketProcessor.Send(player1Peer, packet, deliveryMethod); PacketProcessor.Send(player2Peer, packet, deliveryMethod); }
public override void SendMessage(INetworkMessage message, IRemote recipient, DeliveryMethod method, int sequenceChannel) { var client = ((Client) recipient).Connection; Peer.SendMessage(PrepareMessage(message), client, (NetDeliveryMethod) method, sequenceChannel); }
protected abstract void SendMsgInternal(NetworkConnection conn, DeliveryMethod deliveryMethod, IWriteMessage msg);
/// <summary> /// Sends to clients. /// </summary> /// <param name="messageToSend">The message to send.</param> /// <param name="deliveryMethod">The delivery method.</param> public void SendToClients(OutgoingMessage messageToSend, DeliveryMethod deliveryMethod) { this.networkServer.Send(messageToSend, deliveryMethod); }
public static void Test_LidgrenDelivery_to_GladNetDelivery(NetDeliveryMethod lidgrenNetDeliveryMethod, DeliveryMethod gladnetDeliveryMethod) { Assert.AreEqual(gladnetDeliveryMethod, lidgrenNetDeliveryMethod.ToGladNet()); }
// Sync network data abstract public void SyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData, Vector3 aPosition, Quaternion aRotation);
void sendToBoth <T> (DeliveryMethod deliveryMethod) where T : SignalPacket { PacketProcessor.Send <T>(player1Peer, deliveryMethod); PacketProcessor.Send <T>(player2Peer, deliveryMethod); }
// Lite Sync netword data abstract public void LiteSyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData);
public abstract void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod);
/// <summary> /// Sends the specified incoming message. /// </summary> /// <param name="incomingMessage">The incoming message.</param> /// <param name="deliveryMethod">The delivery method.</param> public void Send(IncomingMessage incomingMessage, DeliveryMethod deliveryMethod) { for (int index = 0; index < this.server.Connections.Count; index++) { var netConnection = this.server.Connections[index]; if (netConnection != incomingMessage.Message.SenderConnection) { var message = this.server.CreateMessage(incomingMessage.Message.LengthBytes); message.Write(incomingMessage.Message.Data); this.server.SendMessage(message, netConnection, (NetDeliveryMethod)deliveryMethod); } } }
public override void SendMessage(INetworkMessage message, DeliveryMethod method, int sequenceChannel) { if (ConnectionStatus != Networking.ConnectionStatus.Connected) return; _writerStream.Clear(); MessageTable.Serialize(_writerStream, message); var length = (int) _writerStream.Length; var msg = Peer.CreateMessage(length); msg.Write(_writerStream.GetBuffer(), 0, length); Peer.SendMessage(msg, (NetDeliveryMethod) method, sequenceChannel); }
public static void Test_GladNet_to_Lidgren(NetDeliveryMethod lidgrenNetDeliveryMethod, DeliveryMethod gladnetDeliveryMethod) { Assert.AreEqual(gladnetDeliveryMethod.ToLidgren(), lidgrenNetDeliveryMethod); }
/// <summary> /// Send data to peer /// </summary> /// <param name="data">Data</param> /// <param name="start">Start of data</param> /// <param name="length">Length of data</param> /// <param name="channelNumber">Number of channel (from 0 to channelsCount - 1)</param> /// <param name="deliveryMethod">Delivery method (reliable, unreliable, etc.)</param> /// <exception cref="TooBigPacketException"> /// If size exceeds maximum limit:<para/> /// MTU - headerSize bytes for Unreliable<para/> /// Fragment count exceeded ushort.MaxValue<para/> /// </exception> public void Send(byte[] data, int start, int length, byte channelNumber, DeliveryMethod deliveryMethod) { SendInternal(data, start, length, channelNumber, deliveryMethod, null); }
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { }
private void SendInternal( byte[] data, int start, int length, byte channelNumber, DeliveryMethod deliveryMethod, object userData) { if (_connectionState != ConnectionState.Connected || channelNumber >= _channels.Length) { return; } //Select channel PacketProperty property; BaseChannel channel = null; if (deliveryMethod == DeliveryMethod.Unreliable) { property = PacketProperty.Unreliable; } else { property = PacketProperty.Channeled; channel = CreateChannel((byte)(channelNumber * 4 + (byte)deliveryMethod)); } //Prepare NetDebug.Write("[RS]Packet: " + property); //Check fragmentation int headerSize = NetPacket.GetHeaderSize(property); //Save mtu for multithread int mtu = _mtu; if (length + headerSize > mtu) { //if cannot be fragmented if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != DeliveryMethod.ReliableUnordered) { throw new TooBigPacketException("Unreliable packet size exceeded maximum of " + (mtu - headerSize) + " bytes"); } int packetFullSize = mtu - headerSize; int packetDataSize = packetFullSize - NetConstants.FragmentHeaderSize; int totalPackets = length / packetDataSize + (length % packetDataSize == 0 ? 0 : 1); NetDebug.Write("FragmentSend:\n" + " MTU: {0}\n" + " headerSize: {1}\n" + " packetFullSize: {2}\n" + " packetDataSize: {3}\n" + " totalPackets: {4}", mtu, headerSize, packetFullSize, packetDataSize, totalPackets); if (totalPackets > ushort.MaxValue) { throw new TooBigPacketException("Data was split in " + totalPackets + " fragments, which exceeds " + ushort.MaxValue); } ushort currentFramentId; lock (_sendLock) { currentFramentId = _fragmentId; _fragmentId++; } for (ushort partIdx = 0; partIdx < totalPackets; partIdx++) { int sendLength = length > packetDataSize ? packetDataSize : length; NetPacket p = _packetPool.GetPacket(headerSize + sendLength + NetConstants.FragmentHeaderSize); p.Property = property; p.UserData = userData; p.FragmentId = currentFramentId; p.FragmentPart = partIdx; p.FragmentsTotal = (ushort)totalPackets; p.MarkFragmented(); Buffer.BlockCopy(data, partIdx * packetDataSize, p.RawData, NetConstants.FragmentedHeaderTotalSize, sendLength); channel.AddToQueue(p); length -= sendLength; } return; } //Else just send NetPacket packet = _packetPool.GetPacket(headerSize + length); packet.Property = property; Buffer.BlockCopy(data, start, packet.RawData, headerSize, length); packet.UserData = userData; if (channel == null) //unreliable { lock (_unreliableChannel) _unreliableChannel.Enqueue(packet); } else { channel.AddToQueue(packet); } }
/// <summary> /// Sets the DeliveryMethod property /// </summary> /// <param name="deliveryMethod">DeliveryMethod property</param> /// <returns>this instance</returns> public SimilarityLookupRequest WithDeliveryMethod(DeliveryMethod deliveryMethod) { this.deliveryMethodField = deliveryMethod; return this; }
void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) { var isReliable = reader.GetBool(); var data = reader.GetString(); if (isReliable) { ReliableReceived++; } else { UnreliableReceived++; } }