// public method // data initialize public void DataInitialize() { // allocate queue receiveQueue = new PacketQueue(); sendQueue = new PacketQueue(); indexClientQueue = new Queue <Socket>(); // allocate buffer receiveBuffer = new byte[bufferSize]; sendBuffer = new byte[bufferSize]; // set network processor networkProcessor = new NetworkProcessor(); networkProcessor.OnReceived += OnReceivePacketFromClient; // set data processor dataProcessor = new DataProcessor(networkProcessor); // set receive notifier RegisterServerReceivePacket((int)ClientToServerPacket.JoinRequest, ReceiveJoinRequest); RegisterServerReceivePacket((int)ClientToServerPacket.LoginRequest, ReceiveLoginRequest); RegisterServerReceivePacket((int)ClientToServerPacket.GameDataRequest, ReceiveGameDataRequest); RegisterServerReceivePacket((int)ClientToServerPacket.StoreCreateRequest, ReceiveStoreCreateRequest); RegisterServerReceivePacket((int)ClientToServerPacket.ItemCreateRequest, ReceiveItemCreateRequest); RegisterServerReceivePacket((int)ClientToServerPacket.ItemAcquireRequest, ReceiveItemCreateRequest); RegisterServerReceivePacket((int)ClientToServerPacket.ItemSellRequest, ReceiveItemSellRequest); }
/// <summary> /// new /// </summary> /// <param name="connectionID"></param> /// <param name="socket"></param> /// <param name="host"></param> /// <exception cref="ArgumentNullException">socket is null</exception> /// <exception cref="ArgumentNullException">host is null</exception> public DefaultConnection(long connectionID, Socket socket, BaseHost host) { if (socket == null) { throw new ArgumentNullException("socket"); } if (host == null) { throw new ArgumentNullException("host"); } this.ConnectionID = connectionID; this._socket = socket; this._messageBufferSize = host.MessageBufferSize; this._host = host; try { this.LocalEndPoint = (IPEndPoint)socket.LocalEndPoint; this.RemoteEndPoint = (IPEndPoint)socket.RemoteEndPoint; } catch (Exception ex) { Log.Trace.Error("get socket endPoint error.", ex); } //init send socketAsyncEventArgs this._saeSend = new SocketAsyncEventArgs(); this._saeSend.SetBuffer(new byte[host.MessageBufferSize], 0, host.MessageBufferSize); this._saeSend.Completed += new EventHandler <SocketAsyncEventArgs>(this.SendAsyncCompleted); this._packetQueue = new PacketQueue(this.SendPacketInternal); //init receive socketAsyncEventArgs this._saeReceive = new SocketAsyncEventArgs(); this._saeReceive.SetBuffer(new byte[host.MessageBufferSize], 0, host.MessageBufferSize); this._saeReceive.Completed += new EventHandler <SocketAsyncEventArgs>(this.ReceiveAsyncCompleted); }
void ProcessPackets() { while (IsConnected) { try { MCForge.Networking.Packet packet = PacketQueue.InQueue.Dequeue(); // PacketEventArgs args = new PacketEventArgs(packet.WritePacket(), true, ) switch (packet.PacketID) { case PacketIDs.Identification: ProcessLogin(packet as PacketIdentification); break; case PacketIDs.PlayerSetBlock: ProcessBlockChange(packet as PacketPlayerSetBlock); break; case PacketIDs.PosAndRot: ProcessPosAndRot(packet as PacketPositionAndOrientation); break; case PacketIDs.Message: ProcessMessage(packet as PacketMessage); break; } } catch { break; } } PacketQueue.CloseConnection(); }
// Use this for initialization void Start() { // 송수신 버퍼를 만듭니다. m_sendQueue = new PacketQueue(); m_recvQueue = new PacketQueue(); DontDestroyOnLoad(this); }
public void OnData() { try { PacketReader packet = null; if (PacketQueue.Count > 0) { packet = (PacketReader)PacketQueue.Dequeue(); } else { packet = new PacketReader(ReceiveBuffer); } PacketLog.WritePacket(clientSocket.RemoteEndPoint.ToString(), null, packet); if (Enum.IsDefined(typeof(Opcodes), packet.Opcode)) { PacketManager.InvokeHandler(ref packet, this, (Opcodes)packet.Opcode); } else { Log.outDebug("Received unknown opcode 0x{0:X} ({0}) from AcountId:{1}", (ushort)packet.Opcode, GetAccountId()); } } catch (Exception ex) { Log.outException(ex); } }
public void TestGetRequestPacketExists() { PacketQueue queue = new PacketQueue(); IPacketWrapper packetRequest = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper packetResponse = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Response, RequestId = 1 } }; queue.PacketSend(packetRequest); Assert.AreEqual(1, queue.OutgoingPackets.Count); IPacketWrapper fetchedRequestPacket = queue.GetRequestPacket(packetResponse); Assert.AreEqual(packetRequest, fetchedRequestPacket); }
/// <summary> /// //Tells a client where all the other players are in the world so they can be spawned in before they can enter the world /// </summary> /// <param name="ClientID">NetworkID for target client</param> public static void SendActivePlayerList(int ClientID) { CommunicationLog.LogOut(ClientID + " active player list"); //Create a new NetworkPacket object to store the data for this active player list NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the other active game clients List <ClientConnection> OtherClients = ClientSubsetFinder.GetInGameClientsExceptFor(ClientID); //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.ActivePlayerList); Packet.WriteInt(OtherClients.Count); //Loop through the list of other clients and write each of their information into the packet data foreach (ClientConnection OtherClient in OtherClients) { //Write each characters name, and current location and rotation values Packet.WriteString(OtherClient.Character.Name); Packet.WriteBool(OtherClient.Character.IsAlive); Packet.WriteVector3(OtherClient.Character.Position); Packet.WriteQuaternion(OtherClient.Character.Rotation); Packet.WriteInt(OtherClient.Character.CurrentHealth); Packet.WriteInt(OtherClient.Character.MaxHealth); } //Add this packet to the target clients outgoing packet queue PacketQueue.QueuePacket(ClientID, Packet); }
/// <summary> /// //Tells a client all the items currently socketed into their ability bar to be loaded in before they can enter into the game world /// </summary> /// <param name="ClientID">NetworkID of target client</param> /// <param name="CharacterName">Name of character who's socketed abilities are being sent</param> public static void SendSocketedAbilities(int ClientID, string CharacterName) { CommunicationLog.LogOut(ClientID + " socketed abilities"); //Create a new NetworkPacket object to store the data for this socketed abilities request NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the items currently socketed into the characters action bar List <ItemData> SocketedAbilities = ActionBarsDatabase.GetEveryActionBarItem(CharacterName); //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.SocketedAbilities); Packet.WriteInt(0); PacketQueue.QueuePacket(ClientID, Packet); //Packet.WriteInt(SocketedAbilities.Count); ////Loop through the list and write in each items information into the packet data //foreach(ItemData Ability in SocketedAbilities) //{ // Packet.WriteInt(Ability.ItemNumber); // Packet.WriteInt(Ability.ItemID); //} ////Add this packet to the target clients outgoing packet queue //PacketQueue.QueuePacket(ClientID, Packet); }
/// <summary> /// //Tells a client where all the active entities are in the world to have them spawned in before they can enter the game world /// </summary> /// <param name="ClientID">NetworkID for target client</param> public static void SendActiveEntityList(int ClientID) { CommunicationLog.LogOut(ClientID + " active entity list"); //Create a new NetworkPacket object to store the data for this active entity list NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the entities currently active in the game world List <BaseEntity> ActiveEntities = EntityManager.ActiveEntities; //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.ActiveEntityList); Packet.WriteInt(ActiveEntities.Count); //Loop through the list of active entities and write each of their information into the packet data foreach (BaseEntity ActiveEntity in ActiveEntities) { Packet.WriteString(ActiveEntity.Type); Packet.WriteString(ActiveEntity.ID); Packet.WriteVector3(VectorTranslate.ConvertVector(ActiveEntity.Location)); Packet.WriteInt(ActiveEntity.HealthPoints); } //Add this packet to the target clients outgoing packet queue PacketQueue.QueuePacket(ClientID, Packet); }
/// <summary> /// //Tells a client where all the active items are in the world to have them spawned in before they can start playing /// </summary> /// <param name="ClientID">NetworkID for target client</param> public static void SendActiveItemList(int ClientID) { CommunicationLog.LogOut(ClientID + " active item list"); //Create a new NetworkPacket object to store the data for this active item list NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the active item pickups currently in the game world List <GameItem> ItemPickups = ItemManager.GetActiveItemList(); //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.ActiveItemList); Packet.WriteInt(ItemPickups.Count); //Loop through the list of item pickups and write each of their information into the packet data foreach (GameItem ItemPickup in ItemPickups) { Packet.WriteInt(ItemPickup.ItemNumber); Packet.WriteInt(ItemPickup.ItemID); Packet.WriteVector3(VectorTranslate.ConvertVector(ItemPickup.ItemPosition)); } //Add this packet to the target clients outgoing packet queue PacketQueue.QueuePacket(ClientID, Packet); }
static int packet_queue_put_private(PacketQueue q, Native <AV.AVPacket> pkt) { MyAVPacketList pkt1 = new MyAVPacketList(); if (q.abort_request != 0) { return(-1); } pkt1.pkt = pkt; pkt1.next = null; if (pkt.P == flush_pkt.P) { q.serial++; } pkt1.serial = q.serial; if (q.last_pkt == null) { q.first_pkt = pkt1; } else { q.last_pkt.next = pkt1; } q.last_pkt = pkt1; q.nb_packets++; q.size += pkt1.pkt.O.size + Marshal.SizeOf(pkt.O) + 12; /* XXX: should duplicate packet data in DV case */ SDL.SDL_CondSignal(q.cond); return(0); }
/// <summary> /// //Tells a client all the items currently equipped on their chosen character to be loaded in before they enter into the game world /// </summary> /// <param name="ClientID">NetworkID of target client</param> /// <param name="CharacterName">Name of character who's equipped items are being sent</param> public static void SendEquippedItems(int ClientID, string CharacterName) { CommunicationLog.LogOut(ClientID + " equipped items"); //Create a new NetworkPacket object to store the data for this equipped items request NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the items currently equipped on the character List <ItemData> EquippedItems = EquipmentsDatabase.GetAllEquipmentSlots(CharacterName); //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.EquippedItems); Packet.WriteInt(0); PacketQueue.QueuePacket(ClientID, Packet); //Packet.WriteInt(EquippedItems.Count); ////Loop through the list and write in each items information into the packet data //foreach(ItemData Item in EquippedItems) //{ // Packet.WriteInt((int)Item.ItemEquipmentSlot); // Packet.WriteInt(Item.ItemNumber); // Packet.WriteInt(Item.ItemID); //} ////Add this packet to the target clients outgoing packet queue //PacketQueue.QueuePacket(ClientID, Packet); }
/// <summary> /// //Sends a message to a client (immediately) letting them know they have been kicked from the game /// </summary> /// <param name="ClientID">NetworkID of the target client</param> /// <param name="Reason">Reason this client is being kicked from the server</param> public static void SendKickedFromServer(int ClientID, string Reason = "No reason given") { //Get the client who we are kicking from the server ClientConnection TargetClient = ConnectionManager.GetClient(ClientID); //Make sure we were actually able to find this client if (TargetClient == null) { MessageLog.Print("ERROR: Cant kick client #" + ClientID + " as they could not be found in the connections"); return; } //Log what is happening here MessageLog.Print("Kicking " + TargetClient.ClientID + " from the server..."); //Create a new packet to send letting them know they have been kicked NetworkPacket Packet = new NetworkPacket(); //Give it the next packet number they are expecting, then write the identifying packet type Packet.WriteInt(TargetClient.GetNextOrderNumber()); Packet.WriteType(ServerPacketType.KickedFromServer); Packet.WriteString(Reason); //Send this packet off to them immediately to ensure its sent to them before we clean up their network connection ourselves PacketQueue.QueuePacket(ClientID, Packet); }
// Use this for initialization void Start () { // 송수신 버퍼를 만듭니다. m_sendQueue = new PacketQueue(); m_recvQueue = new PacketQueue(); }
static void packet_queue_start(PacketQueue q) { SDL.SDL_LockMutex(q.mutex); q.abort_request = 0; packet_queue_put_private(q, flush_pkt); SDL.SDL_UnlockMutex(q.mutex); }
void Update() { // 서버로부터 받기 if (m_pcFromServer.GetPacketCount() > 0) { PacketQueue queue = m_pcFromServer.GetBuffer(); Socket sock; int count = queue.Count; for (int i = 0; i < count; i++) { queue.Dequeue(out sock, ref m_recvBuffer, m_recvBuffer.Length); ReceivePacket(m_notiServer, sock, m_recvBuffer); } } // 게스트(또는 호스트)로부터 받기 if (m_pcFromP2P.GetPacketCount() > 0) { PacketQueue queue = m_pcFromP2P.GetBuffer(); Socket sock; int count = queue.Count; for (int i = 0; i < count; i++) { queue.Dequeue(out sock, ref m_recvBuffer, m_recvBuffer.Length); ReceivePacket(m_notiP2P, sock, m_recvBuffer); } } }
public void EnqueueSend(params ServerPacket[] packets) { foreach (var packet in packets) { PacketQueue.Enqueue(packet); } }
private void Send() { try { while (Socket.Connected) { if (this.clientAbort.WaitOne(10) || Worker.Singleton.ServerShutdown.WaitOne(10)) { return; } while (PacketQueue.Count > 0) { var p = PacketQueue.Dequeue(); using (var ms = new MemoryStream()) { using (var bw = new BinaryWriter(ms)) { p.WriteTo(bw); Logging.Debug(ms.ToArray().Hexdump()); Socket.Send(ms.ToArray()); } } } } } catch { // nevermind } this.clientAbort.Set(); }
void Awake() { DontDestroyOnLoad(this.gameObject); m_sendQueue = new PacketQueue(); m_recvQueue = new PacketQueue(); }
public void UpdateWorld(float DeltaTime) { //Poll User Input from the server window ProcessInput(ApplicationWindow.Focused, DeltaTime); //Manage all client connections and their player characters ConnectionManager.CheckClients(DeltaTime); ConnectionManager.CleanDeadClients(World); ConnectionManager.AddNewClients(World); ConnectionManager.UpdateClientPositions(World); ConnectionManager.RespawnDeadPlayers(World); //Track current inhabitants of the PVP Battle Arena, then process the players PVP attacks List <CharacterData> InGameCharacters = ClientSubsetFinder.GetInGameCharacters(); PVPBattleArena.UpdateArenaInhabitants(InGameCharacters); PVPBattleArena.AlertTravellers(); ConnectionManager.PerformPlayerAttacks(World); //Update the packet queue, transmitting all messages to the client connections PacketQueue.UpdateQueue(DeltaTime, TransmitPackets); //Update the physics simulation World.Timestep(DeltaTime, ThreadDispatcher); TimeSamples.RecordFrame(World); }
public byte[] CharaWorkExp(Socket sender) { if (PacketQueue == null || PacketQueue.Count == 0) { Inventory.Update(sender); Queue <short> jobLevel = new Queue <short>(); Queue <short> jobLevelCap = new Queue <short>(); int count = 0; foreach (var item in Jobs) { count++; if (count > 52) { break; } Job job = item.Value; jobLevel.Enqueue(job.Level); jobLevelCap.Enqueue(job.LevelCap); } WorkProperties property = new WorkProperties(sender, Id, @"charaWork/exp"); property.Add("charaWork.battleSave.skillLevel", jobLevel); property.Add("charaWork.battleSave.skillLevelCap", jobLevelCap, true); PacketQueue = property.PacketQueue; } return(PacketQueue.Dequeue()); }
public void TestPackagingOneTypeMessages() { var packetQueue = new PacketQueue(100, ConsoleLogger); packetQueue.Count.Should().Be(0); packetQueue.Enqueue(new DeliveryOptions(false, false), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(1); packetQueue.Enqueue(new DeliveryOptions(false, false), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(1); packetQueue.Enqueue(new DeliveryOptions(false, false), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(1); packetQueue.Enqueue(new DeliveryOptions(true, false), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(2); packetQueue.Enqueue(new DeliveryOptions(true, false), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(2); packetQueue.Enqueue(new DeliveryOptions(true, true), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(3); packetQueue.Enqueue(new DeliveryOptions(true, true), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(3); packetQueue.Enqueue(new DeliveryOptions(false, true), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(4); packetQueue.Enqueue(new DeliveryOptions(false, true), new Payload(new byte[] { 1 }, 0, 1)); packetQueue.Count.Should().Be(4); foreach (var packet in packetQueue) { packet.Length.Should().BeGreaterThan(1); } foreach (var packet in (IEnumerable)packetQueue) { packet.Should().BeOfType <PacketInfo>(); } }
// Use this for initialization void Start() { // 송수신 버퍼를 작성합니다. _sendQueue = new PacketQueue(); _recvQueue = new PacketQueue(); _garbagecollector = new Thread(new ThreadStart(Observing)); }
public void PacketProcess(Packet iPacket) { lock (PacketQueue) { PacketQueue.Enqueue(iPacket); } }
/// <summary> /// //Tells a clients all the contents of their chosen characters inventory to be loaded in before they enter into the game world /// </summary> /// <param name="ClientID">NetworkID of target client</param> /// <param name="CharacterName">Name of character who's inventory contents are being sent</param> public static void SendInventoryContents(int ClientID, string CharacterName) { CommunicationLog.LogOut(ClientID + " inventory contents"); //Create a new NetworkPacket object to store the data for this inventory contents request NetworkPacket Packet = new NetworkPacket(); //Grab the list of all the items currently in the characters inventory List <ItemData> InventoryContents = InventoriesDatabase.GetAllInventorySlots(CharacterName); //Write the relevant data values into the packet data Packet.WriteType(ServerPacketType.InventoryContents); Packet.WriteInt(0); PacketQueue.QueuePacket(ClientID, Packet); //Packet.WriteInt(InventoryContents.Count); ////Loop through the list of items in the players inventory and write all of their information into the packet data //foreach(ItemData Item in InventoryContents) //{ // Packet.WriteInt(Item.ItemNumber); // Packet.WriteInt(Item.ItemID); //} ////Add this packet to the target clients outgoing packet queue //PacketQueue.QueuePacket(ClientID, Packet); }
/// <summary> /// new /// </summary> /// <param name="connectionID"></param> /// <param name="socket"></param> /// <param name="host"></param> /// <exception cref="ArgumentNullException">socket is null</exception> /// <exception cref="ArgumentNullException">host is null</exception> public DefaultConnection(long connectionID, Socket socket, BaseHost host) { if (socket == null) { throw new ArgumentNullException("socket"); } if (host == null) { throw new ArgumentNullException("host"); } this.ConnectionID = connectionID; this._socket = socket; this._messageBufferSize = host.MessageBufferSize; this._host = host; try { this.LocalEndPoint = (IPEndPoint)socket.LocalEndPoint; this.RemoteEndPoint = (IPEndPoint)socket.RemoteEndPoint; } catch (Exception ex) { Log.Trace.Error("get socket endPoint error.", ex); } //init send this._saeSend = host._saePool.Acquire(); this._saeSend.Completed += this.SendAsyncCompleted; this._packetQueue = new PacketQueue(this.SendPacketInternal); //init receive this._saeReceive = host._saePool.Acquire(); this._saeReceive.Completed += this.ReceiveAsyncCompleted; }
private void FlushPackets() { while (PacketQueue.Count > 0) { ServerPacket packet; if (PacketQueue.TryDequeue(out packet)) { if (packet.Header.HasFlag(PacketHeaderFlags.EncryptedChecksum) && ConnectionData.PacketSequence < 2) { ConnectionData.PacketSequence = 2; } packet.Header.Sequence = ConnectionData.PacketSequence++; packet.Header.Id = 0x0B; // This value is currently the hard coded Server ID. It can be something different... packet.Header.Table = 0x14; packet.Header.Time = (ushort)ConnectionData.ServerTime; if (packet.Header.Sequence >= 2u) { CachedPackets.TryAdd(packet.Header.Sequence, packet); } SendPacket(packet); } } }
private void FlushPackets() { while (PacketQueue.Count > 0) { ServerPacket packet; if (PacketQueue.TryDequeue(out packet)) { if (packet.Header.HasFlag(PacketHeaderFlags.EncryptedChecksum) && ConnectionData.PacketSequence < 2) { ConnectionData.PacketSequence = 2; } packet.Header.Sequence = ConnectionData.PacketSequence++; packet.Header.Id = (ushort)(connectionType == ConnectionType.Login ? 0x0B : 0x18); packet.Header.Table = 0x14; packet.Header.Time = (ushort)ConnectionData.ServerTime; if (packet.Header.Sequence >= 2u) { CachedPackets.TryAdd(packet.Header.Sequence, packet); } SendPacket(packet); } } }
/// <summary> /// //Asks a client if they are still connected, requesting for them to immediately reply to us letting us know /// </summary> /// <param name="ClientID">NetworkID of the target client</param> public static void SendStillConnectedCheck(int ClientID) { CommunicationLog.LogOut(ClientID + " still alive request"); NetworkPacket Packet = new NetworkPacket(); Packet.WriteType(ServerPacketType.StillConnectedCheck); PacketQueue.QueuePacket(ClientID, Packet); }
public WebSocketProtocol(WebSocket socket) { this.socket = socket; pinnedForSending = new PacketQueue(async(data, end) => await socket.SendAsync(new ArraySegment <byte>(data), WebSocketMessageType.Binary, end, CancellationToken.None)); }
public int InsertPacketQueue(PacketQueue packetqueue) { int rs = 0; ctx.PacketQueues.Add(packetqueue); rs = ctx.SaveChanges(); return(rs); }
public void CreateRyu() { mServerIPAddress = "192.168.0.21"; mPort = 50765; mSendQueue = new PacketQueue(); mRecvQueue = new PacketQueue(); }
static void packet_queue_destroy(PacketQueue q) { packet_queue_flush(q); SDL.SDL_DestroyMutex(q.mutex); SDL.SDL_DestroyCond(q.cond); }
public void TestPacketReceivedRemoveFromOutgoing() { PacketQueue queue = new PacketQueue(); IPacketWrapper sentPacket = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper recievedPacket = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Response, RequestId = 1 } }; IPacketWrapper poppedPacket = queue.PacketSend(sentPacket); // Client would send to the server. Assert.AreEqual(sentPacket, poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.AreEqual(0, queue.QueuedPackets.Count); poppedPacket = queue.PacketReceived(recievedPacket); Assert.IsNull(poppedPacket); Assert.AreEqual(0, queue.OutgoingPackets.Count); Assert.AreEqual(0, queue.QueuedPackets.Count); }
public void TestPacketSendImmediate() { PacketQueue queue = new PacketQueue(); IPacketWrapper packet = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper poppedPacket = queue.PacketSend(packet); // Client would send to the server. Assert.AreEqual(packet, poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.AreEqual(0, queue.QueuedPackets.Count); }
public void TestRestartConnectionOnQueueFailureFalsey() { PacketQueue queue = new PacketQueue(); IPacketWrapper packet = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper poppedPacket = queue.PacketSend(packet); Assert.AreEqual(packet, poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.IsFalse(queue.RestartConnectionOnQueueFailure()); }
public void TestPacketSendQueued() { PacketQueue queue = new PacketQueue(); IPacketWrapper firstPacket = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper poppedPacket = queue.PacketSend(firstPacket); // Client would send to the server. Assert.AreEqual(firstPacket, poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); IPacketWrapper secondPacket = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; poppedPacket = queue.PacketSend(secondPacket); // Popped packet is null, client would essentially ignore it until later. Assert.IsNull(poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.AreEqual(1, queue.QueuedPackets.Count); }
public void TestPacketReceivedRemovedAndPopped() { PacketQueue queue = new PacketQueue(); IPacketWrapper firstPacketRequest = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1 } }; IPacketWrapper secondPacketRequest = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 2 } }; IPacketWrapper firstPacketResponse = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Response, RequestId = 1 } }; queue.PacketSend(firstPacketRequest); queue.PacketSend(secondPacketRequest); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.AreEqual(1, queue.QueuedPackets.Count); IPacketWrapper poppedPacket = queue.PacketReceived(firstPacketResponse); Assert.AreEqual(secondPacketRequest, poppedPacket); queue.PacketSend(poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.AreEqual(0, queue.QueuedPackets.Count); }
public void TestRestartConnectionOnQueueFailureTruey() { PacketQueue queue = new PacketQueue(); IPacketWrapper packet = new MockPacket() { Packet = { Origin = PacketOrigin.Client, Type = PacketType.Request, RequestId = 1, Stamp = DateTime.Now.AddMinutes(-5) } }; IPacketWrapper poppedPacket = queue.PacketSend(packet); Assert.AreEqual(packet, poppedPacket); Assert.AreEqual(1, queue.OutgoingPackets.Count); Assert.IsTrue(queue.RestartConnectionOnQueueFailure()); }
static int packet_queue_put(PacketQueue q, Native<AV.AVPacket> pkt) { int ret; /* duplicate the packet */ if (pkt.P != flush_pkt.P && AV.av_dup_packet(pkt.P) < 0) return -1; SDL.SDL_LockMutex(q.mutex); ret = packet_queue_put_private(q, pkt); SDL.SDL_UnlockMutex(q.mutex); if (pkt.P != flush_pkt.P && ret < 0) AV.av_free_packet(pkt.P); return ret; }
static int packet_queue_put_private(PacketQueue q, Native<AV.AVPacket> pkt) { MyAVPacketList pkt1 = new MyAVPacketList(); if (q.abort_request != 0) return -1; pkt1.pkt = pkt; pkt1.next = null; if (pkt.P == flush_pkt.P) q.serial++; pkt1.serial = q.serial; if (q.last_pkt == null) q.first_pkt = pkt1; else q.last_pkt.next = pkt1; q.last_pkt = pkt1; q.nb_packets++; q.size += pkt1.pkt.O.size + Marshal.SizeOf(pkt.O) + 12; /* XXX: should duplicate packet data in DV case */ SDL.SDL_CondSignal(q.cond); return 0; }
static int packet_queue_put_nullpacket(PacketQueue q, int stream_index) { Native<AV.AVPacket> pkt1 = new Native<AV.AVPacket>(new AV.AVPacket()); Native<AV.AVPacket> pkt = new Native<AV.AVPacket>(pkt1.P); AV.av_init_packet(pkt.P); var O = pkt.O; O.data = IntPtr.Zero; O.size = 0; O.stream_index = stream_index; pkt.O = O; return packet_queue_put(q, pkt); }
/* packet queue handling */ static void packet_queue_init(PacketQueue q) { q.mutex = SDL.SDL_CreateMutex(); q.cond = SDL.SDL_CreateCond(); q.abort_request = 1; }
//------------------------------- // LifeCycle //------------------------------- void Start() { sendQueue = new PacketQueue(); recvQueue = new PacketQueue(); }
/* return < 0 if aborted, 0 if no packet and > 0 if packet. */ static int packet_queue_get(PacketQueue q, out Native<AV.AVPacket> pkt, int block, out int serial) { MyAVPacketList pkt1; int ret; pkt = null; serial = 0; SDL.SDL_LockMutex(q.mutex); for (; ; ) { if (q.abort_request != 0) { ret = -1; break; } pkt1 = q.first_pkt; if (pkt1 != null) { q.first_pkt = pkt1.next; if (q.first_pkt == null) q.last_pkt = null; q.nb_packets--; q.size -= pkt1.pkt.O.size + Marshal.SizeOf(pkt1.pkt.O) + 12; pkt = pkt1.pkt; //if (serial != 0) serial = pkt1.serial; //AV.av_free(pkt1); ret = 1; break; } else if (block == 0) { ret = 0; break; } else { SDL.SDL_CondWait(q.cond, q.mutex); } } SDL.SDL_UnlockMutex(q.mutex); return ret; }
static void packet_queue_flush(PacketQueue q) { MyAVPacketList pkt, pkt1; SDL.SDL_LockMutex(q.mutex); for (pkt = q.first_pkt; pkt != null; pkt = pkt1) { pkt1 = pkt.next; AV.av_free_packet(pkt.pkt.P); //AV.av_freep(pkt); } q.last_pkt = null; q.first_pkt = null; q.nb_packets = 0; q.size = 0; SDL.SDL_UnlockMutex(q.mutex); }
static void packet_queue_abort(PacketQueue q) { SDL.SDL_LockMutex(q.mutex); q.abort_request = 1; SDL.SDL_CondSignal(q.cond); SDL.SDL_UnlockMutex(q.mutex); }