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);
		}
Example #4
0
 /// <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;
        }
Example #7
0
        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);
        }
Example #9
0
 /// <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);
 }
Example #10
0
 internal abstract void SendUpdate(bool isInitial, long connectionId, DeliveryMethod deliveryMethod);
Example #11
0
 /// <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);
 }
Example #12
0
        /// <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);
        }
Example #13
0
        public void SendMessage(short opCode, ISerializablePacket packet, DeliveryMethod method)
        {
            var msg = MessageHelper.Create(opCode, packet.ToBytes());

            Peer.SendMessage(msg, method);
        }
Example #14
0
        /// <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)}.");
            }
        }
Example #16
0
 /// <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)));
 }
Example #17
0
 /// <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);
        }
Example #20
0
        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");
            }
        }
Example #21
0
 /// <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);
 }
Example #23
0
        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);
            }
        }
Example #24
0
 private void ReceivedNetworkData(NetPeer peer, NetDataReader reader, DeliveryMethod deliveryMethod)
 {
     netPacketProcessor.ReadAllPackets(reader, peer);
 }
Example #25
0
 public void SendMessage(IOutgoingMessage message, DeliveryMethod method)
 {
     Peer.SendMessage(message, method);
 }
Example #26
0
        private static void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
        {
            PacketID id = (PacketID)reader.GetByte();

            switch (id)
            {
            case PacketID.PlayerUpdatePacket:

                break;
            }
        }
Example #27
0
        public void SendMessage(short opCode, string data, DeliveryMethod method)
        {
            var msg = MessageHelper.Create(opCode, data);

            Peer.SendMessage(msg, method);
        }
Example #28
0
 public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
 {
 }
Example #29
0
 /// <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);
 }
Example #30
0
 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);
Example #33
0
 /// <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());
		}
Example #35
0
 // Sync network data
 abstract public void SyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData, Vector3 aPosition, Quaternion aRotation);
Example #36
0
 void sendToBoth <T> (DeliveryMethod deliveryMethod) where T : SignalPacket
 {
     PacketProcessor.Send <T>(player1Peer, deliveryMethod);
     PacketProcessor.Send <T>(player2Peer, deliveryMethod);
 }
Example #37
0
 // Lite Sync netword data
 abstract public void LiteSyncNetworkData(int aNetworkId, MessageReceiver aMessageReceiver, DeliveryMethod aDeliveryMethod, byte[] aData);
Example #38
0
 public abstract void Send(IWriteMessage msg, NetworkConnection conn, DeliveryMethod deliveryMethod);
Example #39
0
 /// <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);
		}
Example #42
0
 /// <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);
 }
Example #43
0
 void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
 {
 }
Example #44
0
        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);
            }
        }
Example #45
0
 /// <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;
 }
Example #46
0
            void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod)
            {
                var isReliable = reader.GetBool();
                var data       = reader.GetString();

                if (isReliable)
                {
                    ReliableReceived++;
                }
                else
                {
                    UnreliableReceived++;
                }
            }