util/travis

/*
Minetest
Copyright (C) 2013-2017 celeron55, Perttu Ahola <celeron55@gmail.com>
Copyright (C) 2017 celeron55, Loic Blot <loic.blot@unix-experience.fr>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#pragma once

#include <cassert>
#include "threading/thread.h"
#include "connection.h"

namespace con
{

class Connection;

class ConnectionSendThread : public Thread
{

public:
	friend class UDPPeer;

	ConnectionSendThread(unsigned int max_packet_size, float timeout);

	void *run();

	void Trigger();

	void setParent(Connection *parent)
	{
		assert(parent != NULL); // Pre-condition
		m_connection = parent;
	}

	void setPeerTimeout(float peer_timeout) { m_timeout = peer_timeout; }

private:
	void runTimeouts(float dtime);
	void rawSend(const BufferedPacket &packet);
	bool rawSendAsPacket(session_t peer_id, u8 channelnum, SharedBuffer<u8> data,
			bool reliable);

	void processReliableCommand(ConnectionCommand &c);
	void processNonReliableCommand(ConnectionCommand &c);
	void serve(Address bind_address);
	void connect(Address address);
	void disconnect();
	void disconnect_peer(session_t peer_id);
	void send(session_t peer_id, u8 channelnum, SharedBuffer<u8> data);
	void sendReliable(ConnectionCommand &c);
	void sendToAll(u8 channelnum, SharedBuffer<u8> data);
	void sendToAllReliable(ConnectionCommand &c);

	void sendPackets(float dtime);

	void sendAsPacket(session_t peer_id, u8 channelnum, SharedBuffer<u8> data,
			bool ack = false);

	void sendAsPacketReliable(BufferedPacket &p, Channel *channel);

	bool packetsQueued();

	Connection *m_connection = nullptr;
	unsigned int m_max_packet_size;
	float m_timeout;
	std::queue<OutgoingPacket> m_outgoing_queue;
	Semaphore m_send_sleep_semaphore;

	unsigned int m_iteration_packets_avaialble;
	unsigned int m_max_commands_per_iteration = 1;
	unsigned int m_max_data_packets_per_iteration;
	unsigned int m_max_packets_requeued = 256;
};

class ConnectionReceiveThread : public Thread
{
public:
	ConnectionReceiveThread(unsigned int max_packet_size);

	void *run();

	void setParent(Connection *parent)
	{
		assert(parent); // Pre-condition
		m_connection = parent;
	}

private:
	void receive();
Mode	Name	Size
-rwxr-xr-x	before_install.sh	1459	log plain
-rwxr-xr-x	script.sh	1364	log plain
-rw-r--r--	toolchain_mingw.cmake.in	571	log plain