Bubblegumdrop/handmade
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge UDPpacketVBuffer and SafeUDPpacketV.

Browse Source 
The tests seem to work:

	./test/test_FileIO ./test/test_FileIO

	./test/test_FileIO ./test/test_FileIO | \
		./test/test_SafeUDPpacket -f -

	./test/test_SafeUDPpacket -f ./test/test_SafeUDPpacket
This commit is contained in:
Bubblegumdrop 2022-01-16 17:47:04 -05:00
parent 60e282929f
commit 603515dd3e
14 changed files with 301 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@ -33,7 +33,7 @@ COMMON_OBJS := \
$(OBJDIR)/src/lib_SDL_Log.o \
$(OBJDIR)/src/signal_common.o \
$(OBJDIR)/src/UDPbase.o \
$(OBJDIR)/src/UDPpacketVBuffer.o \
$(OBJDIR)/src/SafeUDPpacket.o \
$(OBJDIR)/src/util.o
SERVER_OBJS := \
@ -60,7 +60,7 @@ TEST_OBJ_COMMON := \
$(COMMON_OBJS)
TESTS := test_FileIO test_lua test_UDPpacketBufferV
TESTS := test_FileIO test_lua test_SafeUDPpacket
TEST_PROGS := $(addprefix $(TEST_BINDIR)/,$(TESTS))
$(shell $(MKDIR) $(dir $(OBJS)) >/dev/null)
@ -160,7 +160,7 @@ $(TEST_BINDIR)/test_FileIO: $(OBJDIR)/test/test_FileIO.o $(TEST_OBJ_COMMON) $(OB
$(TEST_BINDIR)/test_lua: $(OBJDIR)/test/test_lua.o $(TEST_OBJ_COMMON) $(OBJDIR)/src/lib_lua_common.o
$(LINK.o) $^ $(LDLIBS)
$(TEST_BINDIR)/test_UDPpacketBufferV: $(OBJDIR)/test/test_UDPpacketBufferV.o $(TEST_OBJ_COMMON) $(OBJDIR)/src/UDPbase.o $(OBJDIR)/src/lib_SDL_common.o
$(TEST_BINDIR)/test_SafeUDPpacket: $(OBJDIR)/test/test_SafeUDPpacket.o $(TEST_OBJ_COMMON) $(OBJDIR)/src/UDPbase.o $(OBJDIR)/src/lib_SDL_common.o
$(LINK.o) $^ $(LDLIBS)
$(OBJDIR)/%.o: %.c

29
glsl/new.f.glsl
View File

@ -1,21 +1,40 @@
/* vim: set ft=c: */
# define M_PI (3.141592653589793238462643383279502884) /* pi */
# define M_PI_2 (1.570796326794896619231321691639751442) /* pi/2 */
# define M_PI_4 (0.785398163397448309615660845819875721) /* pi/4 */
/* <https://www.shadertoy.com/new> */
void
mainImage (out vec4 fragColor, in vec2 fragCoord)
{
// Normalized pixel coordinates (from 0 to 1)
// vec2 uv = fragCoord.xy / iResolution.xy;
const float t = iTime;
const int T = int (3 * (0.5 + 0.5 * cos (t)));
// Texture coordinates
vec2 uv = TexCoords;
// Normalized pixel coordinates (from 0 to 1)
// vec2 uv = fragCoord.xy / iResolution.xy;
// Texture coordinates
vec2 uv = TexCoords;
// float du = 1.0 / iResolution.y;
// vec2 uv = du * (fragCoord.xy - (0.5 * iResolution.xy));
// Time varying pixel color
vec3 col = 0.5 + 0.5 * cos (iTime + uv.xyx + vec3 (0, 2, 4));
vec3 z1 = vec3 (
sin (t) * cos (t)
, sin (t / M_PI) * cos (t / M_PI)
, sin (t / M_PI / 2) * cos (t / M_PI_2)
);
vec3 z2 = uv.xyx;
switch (T)
{
case 0: z2 = uv.xxx; break;
case 1: z2 = uv.yyy; break;
case 2: z2 = uv.xyx; break;
}
vec3 col = 0.5 + 0.5 * cos (iTime + z1 + z2);
// Output to screen
fragColor = vec4 (col, 1.0);

61
include/SafeUDPpacket.h
View File

@ -22,6 +22,19 @@ class SafeUDPpacket
m_packet.reset (p);
}
public:
SafeUDPpacket (const void* buf, int size)
{
UDPpacket* p;
if (NULL == (p = SDLNet_AllocPacket (size)))
{
throw "SDLNet_AllocPacket: " + std::string (SDLNet_GetError ());
}
else
{
SDL_memcpy (p->data, buf, size);
Reset (p);
}
}
SafeUDPpacket (int size)
{
UDPpacket* p;
@ -29,7 +42,10 @@ class SafeUDPpacket
{
throw "SDLNet_AllocPacket: " + std::string (SDLNet_GetError ());
}
Reset (p);
else
{
Reset (p);
}
}
SafeUDPpacket (UDPpacket* p)
{
@ -39,7 +55,19 @@ class SafeUDPpacket
{
return m_packet.get ();
}
void clear (void)
{
SDL_assert (len () > 0);
SDL_memset (data (), 0, len ());
}
void slurp (const void* buf, const size_t size)
{
SDL_memcpy (data (), buf, size);
}
int Send (UDPsocket sock)
{
return SDLNet_UDP_Send (sock, channel(), get ());
}
int channel (int channel) const { return get()->channel = channel; }
int channel (void) const { return get()->channel; }
@ -87,13 +115,30 @@ class SafeUDPpacketV
SDL_free (p);
}
}
const SafeUDPpacket& get (size_t idx)
int Send (UDPsocket sock)
{
return m_packetV.at (idx);
}
size_t size (void) const
{
return m_packetV.size ();
size_t size;
int numsent;
UDPpacket** pV;
size = m_packetV.size ();
if (NULL != (pV = (UDPpacket**)SDL_malloc (sizeof (UDPpacket*) * size)))
{
for (size_t i = 0; i < size; i++)
pV[i] = m_packetV[i].get ();
numsent = SDLNet_UDP_SendV (sock, pV, size);
SDL_free (pV);
}
return numsent;
}
const SafeUDPpacket& get (size_t idx) { return m_packetV.at (idx); }
size_t size (void) const { return m_packetV.size (); }
void channel (int channel) { for (auto& p : m_packetV) { p.channel (channel); } }
void len (int len) { for (auto& p : m_packetV) { p.len (len); } }
void maxlen (int maxlen) { for (auto& p : m_packetV) { p.maxlen (maxlen); } }
void status (int status) { for (auto& p : m_packetV) { p.status (status); } }
void address (IPaddress address) { for (auto& p : m_packetV) { p.address (address); } }
std::string toString (void);
};

2
include/Server.h
View File

@ -49,7 +49,7 @@ class Server : public UDPbase
}
lua_State* getLuaState(void) { return mLuaState; }
UDPsocket getUDPsock (size_t idx) { return UDPsocks.at (idx); }
UDPsocket getUDPsock (size_t idx) { return m_socks.at (idx); }
UDPpacket** getPacketV (void) { return packetV; }
SDLNet_SocketSet getSocketSet (void) { return SocketSet; }
};

59
include/UDPbase.h
View File

@ -10,48 +10,39 @@
class
UDPbase
{
int mChannel;
IPaddress mIPAddress;
void
CloseAllSockets (void);
int m_channel;
IPaddress m_address;
void CloseAllSockets (void);
protected:
std::vector<UDPsocket> UDPsocks;
std::vector<UDPsocket> m_socks;
public:
UDPbase (const char *host, const Uint16 port);
UDPbase (const char *host, const Uint16 port, const int channel);
UDPbase (const char*, const Uint16);
UDPbase (const char*, const Uint16, const int);
~UDPbase (void);
int
ResolveHost (IPaddress *, const char *, const Uint16);
int ResolveHost (IPaddress*, const char*, const Uint16);
UDPsocket
UDP_Open (void);
UDPsocket
UDP_Open (const Uint16 port);
void
UDP_Close (UDPsocket sock);
int
UDP_Bind (UDPsocket sock, const int channel);
void
UDP_Unbind (UDPsocket sock, const int channel);
IPaddress *
UDP_GetPeerAddress (UDPsocket sock, const int channel);
UDPsocket UDP_Open (void);
UDPsocket UDP_Open (const Uint16 port);
int
getChannel (void) const
void UDP_Close (UDPsocket sock);
int UDP_Bind (UDPsocket sock, const int channel);
void UDP_Unbind (UDPsocket sock, const int channel);
IPaddress* UDP_GetPeerAddress (UDPsocket sock, const int channel);
/* ======================================================= */
int channel (void) const
{
return
mChannel;
}
UDPsocket
getSocket (const size_t idx) const
{
return
UDPsocks.
at (idx);
return m_channel;
}
std::string
toString (void);
UDPsocket get (const size_t idx) const
{
return m_socks.at (idx);
}
std::string toString (void);
};

62
include/UDPpacketVBuffer.h
View File

@ -1,62 +0,0 @@
#pragma once
#include <string>
#include <SDL_net.h>
/**
# UDPpacketVBuffer
Create your `UDPsocket` somewhere:
UDPsocket sock;
...
You have a buffer:
FileIO f (path, "r");
std::string buf = f.ReadToString ();
Allocate a setup packet and set `len` to your MTU, set your destination `address`, and the destination `channel`.
I'm not sure -1 will work as a channel, be sure to set it to your active channel.
UDPpacket* packet = SDL_AllocPacket (buf.length ());
packet->len = DEFAULT_MAX_PACKET_SIZE;
packet->channel = -1;
packet->address = GetPeerAddress (sock, packet->channel);
Use `UDPpacketVBuffer` wrapper to send the data, the destructor will automatically free the `UDPpacket**`:
UDPpacketVBuffer packetV (&buf[0], buf.length ());
packetV.Send (sock);
Then free the leftover setup packet:
SDLNet_FreePacket (packet);
*/
class UDPpacketVBuffer
{
int m_howmany;
UDPpacket** m_packetV;
public:
UDPpacketVBuffer (UDPpacket* src, const void* buf, const size_t size);
~UDPpacketVBuffer (void)
{
if (m_packetV)
{
SDLNet_FreePacketV (m_packetV);
m_packetV = NULL;
}
}
int Send (UDPsocket sock)
{
int numsent = 0;
if ((NULL != m_packetV) && (m_howmany > 0))
{
numsent = SDLNet_UDP_SendV (sock, m_packetV, m_howmany);
}
return numsent;
}
std::string Reassemble (void);
};

12
src/SafeUDPpacket.cpp
View File

@ -26,15 +26,19 @@ SafeUDPpacketV::SafeUDPpacketV (const void* buf, const int size, const int mtu)
if (len < 1)
break;
SDL_memset (p.data (), 0, mtu);
/* Clear the entire data ... TODO */
p.len (mtu);
p.clear ();
/* Set the actual length */
p.len (len);
p.maxlen (size);
/* But only memcpy in the relevant bits */
SDL_memcpy (p.data (), bufPtr, len);
/* only memcpy in the relevant bits */
p.slurp (bufPtr, len);
m_packetV.push_back (std::move (p));
/* But we will want the destination address of this packet */
/* Advance */
bufPtr += len;
numsent += len;

12
src/Server.cpp
View File

@ -80,7 +80,7 @@ Server::AllocateApproximateResources (const int nclients)
total = 0;
for (i = 0; i < nclients; i++)
{
numused = SDLNet_UDP_AddSocket (SocketSet, UDPsocks[i]);
numused = SDLNet_UDP_AddSocket (SocketSet, m_socks[i]);
if (numused < 0)
{
SDL_Log ("SDLNet_AddSocket: %s", SDLNet_GetError ());
@ -89,9 +89,9 @@ Server::AllocateApproximateResources (const int nclients)
total += numused;
}
if (total != (int)UDPsocks.size ())
if (total != (int)m_socks.size ())
{
SDL_Log ("Total clients: %d (%ld?)", total, UDPsocks.size ());
SDL_Log ("Total clients: %d (%ld?)", total, m_socks.size ());
return -1;
}
@ -104,7 +104,7 @@ Server::Start (void)
{
int l;
const int nclients = UDPsocks.size ();
const int nclients = m_socks.size ();
if ((l = AllocateApproximateResources (nclients) < 0))
{
DEBUG_LOG ("Unable to allocate approximate buffer space");
@ -148,10 +148,10 @@ Server::Stop (void)
if (SocketSet)
{
int nclients = UDPsocks.size ();
int nclients = m_socks.size ();
for (i = 0; i < nclients; i++)
{
SDLNet_UDP_DelSocket (SocketSet, UDPsocks[i]);
SDLNet_UDP_DelSocket (SocketSet, m_socks[i]);
}
SDLNet_FreeSocketSet (SocketSet);

50
src/UDPbase.cpp
View File

@ -1,23 +1,25 @@
#include "UDPbase.h"
#include <algorithm> /* std::find */
UDPbase::UDPbase (const char* host, const Uint16 port)
{
if (ResolveHost (&mIPAddress, host, port) < 0)
if (ResolveHost (&m_address, host, port) < 0)
{
throw "ResolveHost failed";
}
mChannel = -1;
m_channel = -1;
}
/*
* Shortcut for clients who want to open a single channel
* The channel will be available in client->getChannel ()
* The channel will be available in client->channel ()
*/
UDPbase::UDPbase (const char* host, const Uint16 port, const int channel)
{
UDPsocket sock;
if (ResolveHost (&mIPAddress, host, port) < 0)
if (ResolveHost (&m_address, host, port) < 0)
{
throw "ResolveHost failed";
}
@ -25,7 +27,7 @@ UDPbase::UDPbase (const char* host, const Uint16 port, const int channel)
{
throw "Unable to open client port";
}
if (-1 == (mChannel = UDP_Bind (sock, channel)))
if (-1 == (m_channel = UDP_Bind (sock, channel)))
{
throw "Unable to bind client port";
}
@ -39,7 +41,7 @@ UDPbase::~UDPbase (void)
int
UDPbase::ResolveHost (IPaddress* addr, const char* host, const Uint16 port)
UDPbase::ResolveHost (IPaddress* addr, const char* host, const Uint16 port)
{
int rc;
if ((rc = SDLNet_ResolveHost (addr, host, port)) < 0)
@ -53,25 +55,24 @@ UDPbase::ResolveHost (IPaddress* addr, const char* host, const Uint16 port)
/*
* Open *our* UDP IPaddress->port
*/
UDPsocket
UDPbase::UDP_Open (void)
UDPsocket UDPbase::UDP_Open (void)
{
return UDP_Open (mIPAddress.port);
return UDP_Open (m_address.port);
}
UDPsocket
UDPbase::UDP_Open (const Uint16 port)
UDPsocket UDPbase::UDP_Open (const Uint16 port)
{
UDPsocket sock = NULL;
UDPsocket
sock = NULL;
if (NULL == (sock = SDLNet_UDP_Open (port)))
{
throw "SDLNet_UDP_Open: " + std::string (SDLNet_GetError ());
}
if (NULL != UDP_GetPeerAddress (sock, -1))
{
SDL_Log ("Opened UDP port %d", SDLNet_Read16 (&mIPAddress.port));
UDPsocks.push_back (sock);
SDL_Log ("Opened UDP port %d", SDLNet_Read16 (&m_address.port));
m_socks.push_back (sock);
}
return sock;
}
@ -81,6 +82,11 @@ void
UDPbase::UDP_Close (UDPsocket sock)
{
SDL_assert (NULL != sock);
const auto& ref = std::find (m_socks.begin (), m_socks.end (), sock);
if (ref != m_socks.end ())
{
m_socks.erase (ref);
}
SDLNet_UDP_Close (sock);
sock = NULL;
}
@ -91,7 +97,7 @@ UDPbase::UDP_Bind (UDPsocket sock, const int channel)
{
int binding;
SDL_assert (NULL != sock);
if (-1 == (binding = SDLNet_UDP_Bind (sock, channel, &mIPAddress)))
if (-1 == (binding = SDLNet_UDP_Bind (sock, channel, &m_address)))
{
throw "SDLNet_UDP_Bind: " + std::string (SDLNet_GetError ());
}
@ -123,17 +129,17 @@ void
UDPbase::CloseAllSockets (void)
{
size_t i, n;
n = UDPsocks.size ();
n = m_socks.size ();
for (i = 0; i < n; i++)
UDP_Close (UDPsocks.at (i));
UDPsocks.clear ();
{
UDP_Close (m_socks.at (i));
}
m_socks.clear ();
}
std::string UDPbase::toString (void)
{
return std::string (SDLNet_ResolveIP (&mIPAddress)) + ":" +
std::to_string (SDLNet_Read16 (&mIPAddress.port));
return std::string (SDLNet_ResolveIP (&m_address)) + ":" +
std::to_string (SDLNet_Read16 (&m_address.port));
}

87
src/UDPpacketVBuffer.cpp
View File

@ -1,87 +0,0 @@
#include "UDPpacketVBuffer.h"
#include <string>
UDPpacketVBuffer::UDPpacketVBuffer (UDPpacket* src, const void* buf, const size_t size)
{
int i, len, mtu, nsent;
const uint8_t* bufPtr;
const uint8_t* bufPtrEnd;
SDL_assert (NULL != buf);
SDL_assert (NULL != src);
mtu = src->len;
SDL_assert (mtu > 0);
m_howmany = (int) ceil ((double) size / (double) mtu);
// SDL_Log ("%d", m_howmany);
if (NULL == (m_packetV = SDLNet_AllocPacketV (m_howmany, mtu)))
{
throw "SDLNet_AllocPacketV: " + std::string (SDLNet_GetError ());
}
i = 0;
nsent = size;
bufPtr = (const uint8_t*) buf;
bufPtrEnd = bufPtr + size;
while ((i < m_howmany) && (bufPtr < bufPtrEnd) && (nsent > 0))
{
len = nsent;
if (len > mtu)
len = mtu;
/* Use SDLNet_UDP_Send to send an empty packet instead... it's probably simpler than all this machinery. */
if (len < 1)
break;
/* SDLNet_UDP_Send sets the channel in the argument,
* this one takes it implicitly from the source UDPpacket.
* Set it for all packets in the vector. */
m_packetV[i]->channel = src->channel;
/* Always zero out the entire data */
SDL_memset (m_packetV[i]->data, 0, mtu);
/* But only memcpy in the relevant bits */
SDL_memcpy (m_packetV[i]->data, bufPtr, len);
m_packetV[i]->len = len;
/* probably don't need maxlen or status set after this */
m_packetV[i]->maxlen = size;
m_packetV[i]->status = 0;
/* But we will want the destination address of this packet */
m_packetV[i]->address = src->address;
/* Advance */
bufPtr += len;
nsent -= len;
i++;
}
}
std::string
UDPpacketVBuffer::Reassemble (void)
{
int i, maxlen, mtu, numrecv;
char* bufPtr;
char* bufPtrEnd;
std::string buf;
SDL_assert (NULL != m_packetV);
SDL_assert (NULL != m_packetV[0]);
maxlen = m_packetV[0]->maxlen;
SDL_assert (maxlen > 0);
buf.reserve (maxlen);
bufPtr = &buf[0];
bufPtrEnd = bufPtr + maxlen;
for (numrecv = 0; (numrecv < m_howmany) && m_packetV[numrecv] && (bufPtr < bufPtrEnd); numrecv++)
{
mtu = m_packetV[numrecv]->len;
SDL_assert (mtu > 0);
memcpy (bufPtr, m_packetV[numrecv]->data, mtu);
bufPtr += mtu;
}
SDL_assert (numrecv == m_howmany);
return buf;
}

27
src/client_main.cpp
View File

@ -9,7 +9,7 @@
#include "signal_common.h"
#include "unused.h"
#include "UDPbase.h"
#include "UDPpacketVBuffer.h"
#include "SafeUDPpacket.h"
#include "events_common.h"
#include "lib_GetOpt.h"
@ -126,12 +126,12 @@ main (int argc, char** argv)
state.channel = state.init_opts.channel;
state.port = state.init_opts.port;
client = std::make_unique<UDPbase> (state.host, state.port, state.channel);
if (NULL == (state.udpsock = client->getSocket (0)))
if (NULL == (state.udpsock = client->get (0)))
{
SDL_Log ("Unable to open client port");
goto _out;
}
if (-1 == (state.channel = client->getChannel ()))
if (-1 == (state.channel = client->channel ()))
{
SDL_Log ("Unable to bind client port");
goto _out;
@ -442,20 +442,15 @@ my_Input_Key (SDL_Event* event)
{
DEBUG_LOG ("Physical %s key acting as %s key", SDL_GetScancodeName (event->key.keysym.scancode), SDL_GetKeyName (event->key.keysym.sym));
}
UDPpacket* packet = SDLNet_AllocPacket (sizeof (SDL_Event));
if (packet)
IPaddress* addr = SDLNet_UDP_GetPeerAddress (state.udpsock, state.channel);
if (addr)
{
packet->len = sizeof (SDL_Event);
packet->channel = state.channel;
IPaddress* addr = SDLNet_UDP_GetPeerAddress (state.udpsock, state.channel);
if (addr)
{
// SDL_Log ("%s:%d", SDLNet_ResolveIP (addr), SDLNet_Read16(&addr->port));
packet->address = *addr;
UDPpacketVBuffer packetV (packet, (const void*)event, sizeof (SDL_Event));
packetV.Send (state.udpsock);
}
SDLNet_FreePacket (packet);
SafeUDPpacket p ((const void*)event, sizeof (SDL_Event));
p.len (sizeof (SDL_Event));
p.maxlen (sizeof (SDL_Event));
p.channel (state.channel);
p.address (*addr);
p.Send (state.udpsock);
}
}
}

7
src/lib_GetOpt.cpp
View File

@ -1,4 +1,5 @@
#include "lib_GetOpt.h"
#include "UDPbase.h"
#include <getopt.h>
#include <stdio.h>
@ -16,10 +17,12 @@ void
common_GetOpt (int argc, char** argv, Init_CommonOpts* state)
{
int opt;
state->host = "localhost";
state->channel = -1;
state->mtu = 1450;
state->mtu = DEFAULT_MAX_PACKET_SIZE;
state->port = 6666;
while ((opt = getopt (argc, argv, "hm:p:s:")) != -1)
{
switch (opt)
@ -33,8 +36,8 @@ common_GetOpt (int argc, char** argv, Init_CommonOpts* state)
case 's':
state->host = optarg;
break;
case 'h':
default:
case 'h':
common_Usage (argv[0]);
exit (EXIT_FAILURE);
break;

143
test/test_SafeUDPpacket.cpp
View File

@ -1,11 +1,142 @@
#include "debug.h"
#include "glCheckErrors.h"
#include "lib_GL_common.h"
#include "lib_SDL_common.h"
#include "quad.h"
#include "shader.h"
#include "signal_common.h"
#include "unused.h"
#include "UDPbase.h"
#include "FileIO.h"
#include "SafeUDPpacket.h"
#include "lib_GetOpt.h"
int main(void)
#include <iostream>
#include <fstream>
#include <memory>
#include <vector>
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <unistd.h> /* getopt */
#include <getopt.h> /* getopt */
#define MIN_FRAME_MS 7 /* 144 Hz */
static const char* host = "localhost";
static Uint16 port = 6666;
static int channel = -1;
static std::unique_ptr<UDPbase> client;
struct Test_CommonOpts : public Init_CommonOpts
{
int size;
size = 1;
UDPpacket* p_ptr;
SafeUDPpacket p (size);
p_ptr = p.get ();
std::string path;
};
static void my_GetOpt (int argc, char** argv, Test_CommonOpts*);
static void my_Usage (const char*);
int
main (int argc, char **argv)
{
{
Test_CommonOpts init_opts;
UDPsocket udpsock;
common_Signal_Init ();
my_GetOpt (argc, argv, &init_opts);
common_SDL_Init ();
client = std::make_unique<UDPbase> (host, port);
if (NULL == (udpsock = client->UDP_Open (0)))
{
SDL_Log ("Unable to open client port");
return -1;
}
if (-1 == (channel = client->UDP_Bind (udpsock, -1)))
{
SDL_Log ("Unable to bind client port");
return -1;
}
std::string buf;
if (init_opts.path == "-")
{
try
{
std::string line;
while (getline (std::cin, line))
{
buf += line + "\n";
}
}
catch (std::ifstream::failure& e)
{
// std::cout << e << std::endl;
}
}
else
{
FileIO f (init_opts.path, "r");
buf = f.ReadToString ();
}
IPaddress* addr = SDLNet_UDP_GetPeerAddress (udpsock, channel);
SafeUDPpacketV pV (&buf[0], buf.length (), DEFAULT_MAX_PACKET_SIZE);
pV.len (DEFAULT_MAX_PACKET_SIZE);
pV.address (*addr);
pV.channel (channel);
pV.Send (udpsock);
}
common_SDL_Quit ();
return 0;
}
static void
my_Usage (const char* argv0)
{
fprintf (stderr, "Usage: %s [-h] [-f [-|path]] [-s server] [-p port]\n", argv0);
}
void
my_GetOpt (int argc, char** argv, Test_CommonOpts* state)
{
int opt;
state->host = "localhost";
state->channel = -1;
state->mtu = DEFAULT_MAX_PACKET_SIZE;
state->port = 6666;
state->path = "test/test_SafeUDPpacket.cpp";
while ((opt = getopt (argc, argv, "f:hm:p:s:")) != -1)
{
switch (opt)
{
case 'f':
state->path = optarg;
break;
case 'm':
state->mtu = strtol (optarg, NULL, 0);
break;
case 'p':
state->port = strtol (optarg, NULL, 0);
break;
case 's':
state->host = optarg;
break;
default:
case 'h':
my_Usage (argv[0]);
exit (EXIT_FAILURE);
break;
}
}
}

132
test/test_UDPpacketBufferV.cpp
View File

@ -1,132 +0,0 @@
#include "debug.h"
#include "glCheckErrors.h"
#include "lib_GL_common.h"
#include "lib_SDL_common.h"
#include "quad.h"
#include "shader.h"
#include "signal_common.h"
#include "unused.h"
#include "UDPbase.h"
#include "UDPpacketVBuffer.h"
#include "FileIO.h"
#include <iostream>
#include <fstream>
#include <memory>
#include <vector>
#include <getopt.h> /* getopt */
#include <stdlib.h> /* exit */
#include <string.h> /* memset */
#include <unistd.h> /* getopt */
#include <glm/vec3.hpp>
#include <glm/gtc/type_ptr.hpp>
#define Perf_Diff(a, b) ((double) 1000 * ((double)(((double) (b) - (double) (a)) / (double) SDL_GetPerformanceFrequency ())))
#define MIN_FRAME_MS 7 /* 144 Hz */
static void my_GetOpt (int, char **);
static void my_Usage (const char *);
static const char* host = "localhost";
static Uint16 port = 6666;
static int channel = -1;
static std::string path = "./test/test_UDPpacketVBuffer.cpp";
static std::unique_ptr<UDPbase> client;
int
main (int argc, char **argv)
{
{
UDPsocket udpsock;
common_Signal_Init ();
my_GetOpt (argc, argv);
common_SDL_Init ();
client = std::make_unique<UDPbase> (host, port);
if (NULL == (udpsock = client->UDP_Open (0)))
{
SDL_Log ("Unable to open client port");
return -1;
}
if (-1 == (channel = client->UDP_Bind (udpsock, -1)))
{
SDL_Log ("Unable to bind client port");
return -1;
}
std::string buf;
if (path == "-")
{
try {
std::string line;
while (getline (std::cin, line))
{
buf += line + "\n";
}
}
catch (std::ifstream::failure& e) {
// std::cout << e << std::endl;
}
}
else
{
FileIO f (path, "r");
buf = f.ReadToString ();
}
UDPpacket* packet = SDLNet_AllocPacket (buf.length ());
IPaddress* addr = SDLNet_UDP_GetPeerAddress (udpsock, channel);
packet->len = DEFAULT_MAX_PACKET_SIZE;
packet->address = *addr;
packet->channel = channel;
UDPpacketVBuffer packetV (packet, &buf[0], buf.length ());
packetV.Send (udpsock);
}
common_SDL_Quit ();
return 0;
}
static void
my_Usage (const char *argv0)
{
fprintf (stderr, "Usage: %s [-h] [-s host] [-p port]\n", argv0);
}
static void
my_GetOpt (int argc, char **argv)
{
int opt;
host = "localhost";
port = 6666;
while ((opt = getopt (argc, argv, "f:hp:s:")) != -1)
{
switch (opt)
{
case 'p':
port = strtol (optarg, NULL, 0);
break;
case 's':
host = optarg;
break;
case 'f':
path = std::string (optarg);
break;
case 'h':
default:
my_Usage (argv[0]);
exit (EXIT_FAILURE);
break;
}
}
}