Why are there a bunch of ╠ on the front of my packet? - c++

Question

EDIT: The first one answers the question in the title. It was initialized memory from my debugger. I didn't get the program to work however. Just going to go back to boost::asio for my sockets. Sockets are painful.
I'm following this tutorial on how to start sending and receiving packets using sockets. I've followed the tutorial to the best of my ability, but I get a bunch of ╠'s in front of my message. Can someone explain why I'm getting these? Their ASCII code is 204 so not null nor is it 0xFF. If you need anything more, please let me know.
Bonus points: Why is my console outputting this infinitely instead of breaking out of the while loop? I'm new and don't understand. D:
Output:
buffer: ╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠Hello World!
(times infinity)
My main class
#include "common_include.h"
#include "Socket.h"
#include "Address.h"
#include <string>
bool Initialize_Sockets();
void Shutdown_Sockets();
int main()
{
Initialize_Sockets();
constexpr int port = 30000;
Sage::Socket socket(30000);
if (socket.Is_Initialized() == false)
{
printf("Socket failed to initialize\n");
return -1;
}
const char data[] = "Hello World!";
socket.Send(Sage::Address(127, 0, 0, 1, port), data, sizeof(data));
while (true)
{
Sage::Address sender;
unsigned char buffer[256];
int bytes_read = socket.Receive(sender, buffer, sizeof(buffer));
if (!bytes_read)
break;
printf("buffer: %s\n", buffer);
}
Shutdown_Sockets();
}
bool Initialize_Sockets()
{
#if PLATFORM == PLATFORM_WINDOWS
WSADATA Wsa_Data;
return WSAStartup(MAKEWORD(2, 2), &Wsa_Data) == NO_ERROR;
#else
return true;
#endif
}
void Shutdown_Sockets()
{
#if PLATFORM == PLATFORM_WINDOWS
WSACleanup();
#endif
}
My socket class
#include "Socket.h"
Sage::Socket::Socket(unsigned short port)
{
handle = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if PLATFORM == PLATFORM_WINDOWS
if (handle == INVALID_SOCKET)
{
printf("Failed to create socket: %d\n", WSAGetLastError());
}
else
{
is_created = true;
}
#elif
if (handle <= 0)
{
printf("Failed to create socket\n");
is_created = false;
}
else
{
is_created = true;
}
#endif
sockaddr_in address;
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(port);
#if PLATFORM == PLATFORM_WINDOWS
if (bind(handle, (sockaddr*)&address, sizeof(sockaddr_in)) == SOCKET_ERROR)
{
printf("Failed to bind socket: %d\n", WSAGetLastError());
is_bound = false;
}
else
{
is_bound = true;
}
#elif
if (bind(handle, (const sockaddr*)&address, sizeof(sockaddr_in)) < 0)
{
printf("failed to bind socket\n");
is_bound = false;
}
else
{
is_bound = true;
}
#endif
#if PLATFORM == PLATFORM_WINDOWS
DWORD non_blocking = 1;
if (ioctlsocket(handle, FIONBIO, &non_blocking) == SOCKET_ERROR)
{
printf("Failed to set socket non-blocking: %d\n", WSAGetLastError());
is_non_blocking = false;
}
else
{
is_non_blocking = true;
}
#elif
int non_blocking = 1;
if (fcntl(handle, F_SETFL, O_NONBLOCK, non_blocking) == -1)
{
printf("Failed to set socket non-blocking\n");
is_non_blocking = false;
}
else
{
is_non_blocking = true;
}
#endif
is_initialized = is_created && is_bound && is_non_blocking;
if (!is_initialized)
{
printf("Failed to initialize socket\n");
}
}
int Sage::Socket::Send(Sage::Address address, const void* packet_data, int packet_size)
{
sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(address.Get_Address());
addr.sin_port = htons(address.Get_Port());
unsigned int sendto_address = address.Get_Address();
int sent_bytes = sendto(handle, (const char*)packet_data, packet_size, 0, (sockaddr*)&sendto_address, sizeof(sockaddr_in));
#if PLATFORM == PLATFORM_WINDOWS
if (sent_bytes == SOCKET_ERROR)
{
printf("Failed to send packet: %d\n", WSAGetLastError());
return sent_bytes;
}
else if (sent_bytes != packet_size)
{
printf("Failed to send all bytes of packet(%d/%d)\n", sent_bytes, packet_size);
return sent_bytes;
}
#elif PLATFORM == PLATFORM_MAC || PLATFORM == PLATFORM_UNIX
if (sent_bytes != packet_size)
{
printf("Failed to send all bytes of a packet(%d/%d)\n", sent_bytes, packet_size);
return sent_bytes;
}
#endif
return sent_bytes;
}
int Sage::Socket::Receive(Sage::Address& sender, void* data, int size)
{
#if PLATFORM == PLATFORM_WINDOWS
typedef int socklen_t;
#endif
sockaddr_in from;
socklen_t from_length = sizeof(from);
int bytes_received = recvfrom(handle, (char*)data, size, 0, (sockaddr*)&from, &from_length);
sender = Sage::Address(from);
return bytes_received;
}
Sage::Socket::~Socket()
{
#if PLATFORM == PLATFORM_WINDOWS
closesocket(handle);
#elif PLATFORM == PLATFORM_MAC || PLATFORM == PLATFORM_UNIX
close(handle);
#endif
}

Answer 1

0xCCCCCCCC is used by by Microsoft's C++ debugging runtime library to mark uninitialised stack memory.
204 is 0xCC.
Clearly you're missing a 0 in your buffer which would signal the end of the data: your output runs into the uninitialised memory.
Of course, don't rely on any of this behavior - your program behavior is undefined, but these sort of things do help to identify the problem.
Reference: https://en.wikipedia.org/wiki/Magic_number_(programming)#Debug_values