#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include "system.h"

#if defined(CONF_FAMILY_UNIX)

#include <sys/time.h>

#include <unistd.h>

/* unix net includes */

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <errno.h>

#include <netdb.h>

#include <netinet/in.h>

#include <fcntl.h>

#include <pthread.h>

#include <arpa/inet.h>

#include <dirent.h>

#if defined(CONF_PLATFORM_MACOSX)

#include <Carbon/Carbon.h>

#endif

#elif defined(CONF_FAMILY_WINDOWS)

#define WIN32_LEAN_AND_MEAN

#define _WIN32_WINNT 0x0501 /* required for mingw to get getaddrinfo to work */

#include <windows.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#include <fcntl.h>

#include <direct.h>

#include <errno.h>

#error NOT IMPLEMENTED

#if defined(CONF_PLATFORM_SOLARIS)

#include <sys/filio.h>

#if defined(__cplusplus)

extern "C" {

IOHANDLE io_stdin() { return (IOHANDLE)stdin; }

IOHANDLE io_stdout() { return (IOHANDLE)stdout; }

IOHANDLE io_stderr() { return (IOHANDLE)stderr; }

static DBG_LOGGER loggers[16];

static int num_loggers = 0;

static NETSTATS network_stats = {0};

static MEMSTATS memory_stats = {0};

static NETSOCKET invalid_socket = {NETTYPE_INVALID, -1, -1};

void dbg_logger(DBG_LOGGER logger)

{

loggers[num_loggers++] = logger;

}

void dbg_assert_imp(const char *filename, int line, int test, const char *msg)

{

if(!test)

{

dbg_msg("assert", "%s(%d): %s", filename, line, msg);

dbg_break();

}

}

void dbg_break()

{

*((volatile unsigned*)0) = 0x0;

}

void dbg_msg(const char *sys, const char *fmt, ...)

{

va_list args;

char str[1024*8];

char *msg;

int i, len;

str_format(str, sizeof(str), "[%s]: ", sys);

len = strlen(str);

msg = (char *)str + len;

va_start(args, fmt);

#if defined(CONF_FAMILY_WINDOWS)

_vsnprintf(msg, sizeof(str)-len, fmt, args);

vsnprintf(msg, sizeof(str)-len, fmt, args);

va_end(args);

for(i = 0; i < num_loggers; i++)

loggers[i](str);

}

static void logger_stdout(const char *line)

{

printf("%s\n", line);

fflush(stdout);

}

static void logger_debugger(const char *line)

{

#if defined(CONF_FAMILY_WINDOWS)

OutputDebugString(line);

OutputDebugString("\n");

}

static IOHANDLE logfile = 0;

static void logger_file(const char *line)

{

io_write(logfile, line, strlen(line));

io_write_newline(logfile);

io_flush(logfile);

}

void dbg_logger_stdout() { dbg_logger(logger_stdout); }

void dbg_logger_debugger() { dbg_logger(logger_debugger); }

void dbg_logger_file(const char *filename)

{

logfile = io_open(filename, IOFLAG_WRITE);

if(logfile)

dbg_logger(logger_file);

else

dbg_msg("dbg/logger", "failed to open '%s' for logging", filename);

}

typedef struct MEMHEADER

} MEMHEADER;

typedef struct MEMTAIL

{

int guard;

} MEMTAIL;

static struct MEMHEADER *first = 0;

static const int MEM_GUARD_VAL = 0xbaadc0de;

void *mem_alloc_debug(const char *filename, int line, unsigned size, unsigned alignment)

{

/* TODO: fix alignment */

/* TODO: add debugging */

MEMTAIL *tail;

MEMHEADER *header = (struct MEMHEADER *)malloc(size+sizeof(MEMHEADER)+sizeof(MEMTAIL));

dbg_assert(header != 0, "mem_alloc failure");

if(!header)

return NULL;

tail = (struct MEMTAIL *)(((char*)(header+1))+size);

header->size = size;

header->filename = filename;

header->line = line;

memory_stats.allocated += header->size;

memory_stats.total_allocations++;

memory_stats.active_allocations++;

tail->guard = MEM_GUARD_VAL;

header->prev = (MEMHEADER *)0;

header->next = first;

if(first)

first->prev = header;

first = header;

/*dbg_msg("mem", "++ %p", header+1); */

return header+1;

}

void mem_free(void *p)

{

if(p)

{

MEMHEADER *header = (MEMHEADER *)p - 1;

MEMTAIL *tail = (MEMTAIL *)(((char*)(header+1))+header->size);

if(tail->guard != MEM_GUARD_VAL)

dbg_msg("mem", "!! %p", p);

/* dbg_msg("mem", "-- %p", p); */

memory_stats.allocated -= header->size;

memory_stats.active_allocations--;

if(header->prev)

header->prev->next = header->next;

else

first = header->next;

if(header->next)

header->next->prev = header->prev;

free(header);

}

}

void mem_debug_dump(IOHANDLE file)

{

char buf[1024];

MEMHEADER *header = first;

if(!file)

file = io_open("memory.txt", IOFLAG_WRITE);

if(file)

{

while(header)

{

str_format(buf, sizeof(buf), "%s(%d): %d", header->filename, header->line, header->size);

io_write(file, buf, strlen(buf));

io_write_newline(file);

header = header->next;

}

io_close(file);

}

}

void mem_copy(void *dest, const void *source, unsigned size)

{

memcpy(dest, source, size);

}

void mem_move(void *dest, const void *source, unsigned size)

{

memmove(dest, source, size);

}

void mem_zero(void *block, unsigned size)

{

memset(block, 0, size);

}

int mem_check_imp()

{

MEMHEADER *header = first;

while(header)

{

MEMTAIL *tail = (MEMTAIL *)(((char*)(header+1))+header->size);

if(tail->guard != MEM_GUARD_VAL)

{

dbg_msg("mem", "Memory check failed at %s(%d): %d", header->filename, header->line, header->size);

return 0;

}

header = header->next;

}

return 1;

}

IOHANDLE io_open(const char *filename, int flags)

{

if(flags == IOFLAG_READ)

{

#if defined(CONF_FAMILY_WINDOWS)

// check for filename case sensitive

WIN32_FIND_DATA finddata;

HANDLE handle;

int length;

length = str_length(filename);

if(!filename || !length || filename[length-1] == '\\')

return 0x0;

handle = FindFirstFile(filename, &finddata);

if(handle == INVALID_HANDLE_VALUE)

return 0x0;

else if(str_comp(filename+length-str_length(finddata.cFileName), finddata.cFileName) != 0)

{

FindClose(handle);

return 0x0;

}

FindClose(handle);

#endif

return (IOHANDLE)fopen(filename, "rb");

}

if(flags == IOFLAG_WRITE)

return (IOHANDLE)fopen(filename, "wb");

return 0x0;

}

unsigned io_read(IOHANDLE io, void *buffer, unsigned size)

{

return fread(buffer, 1, size, (FILE*)io);

}

unsigned io_skip(IOHANDLE io, int size)

{

fseek((FILE*)io, size, SEEK_CUR);

return size;

}

int io_seek(IOHANDLE io, int offset, int origin)

{

int real_origin;

switch(origin)

{

case IOSEEK_START:

real_origin = SEEK_SET;

break;

case IOSEEK_CUR:

real_origin = SEEK_CUR;

break;

case IOSEEK_END:

real_origin = SEEK_END;

break;

default:

return -1;

}

return fseek((FILE*)io, offset, real_origin);

}

long int io_tell(IOHANDLE io)

{

return ftell((FILE*)io);

}

long int io_length(IOHANDLE io)

{

long int length;

io_seek(io, 0, IOSEEK_END);

length = io_tell(io);

io_seek(io, 0, IOSEEK_START);

return length;

}

unsigned io_write(IOHANDLE io, const void *buffer, unsigned size)

{

return fwrite(buffer, 1, size, (FILE*)io);

}

unsigned io_write_newline(IOHANDLE io)

{

#if defined(CONF_FAMILY_WINDOWS)

return fwrite("\r\n", 1, 2, (FILE*)io);

return fwrite("\n", 1, 1, (FILE*)io);

}

int io_close(IOHANDLE io)

{

fclose((FILE*)io);

return 1;

}

int io_flush(IOHANDLE io)

{

fflush((FILE*)io);

return 0;

}

void *thread_create(void (*threadfunc)(void *), void *u)

{

#if defined(CONF_FAMILY_UNIX)

pthread_t id;

pthread_create(&id, NULL, (void *(*)(void*))threadfunc, u);

return (void*)id;

#elif defined(CONF_FAMILY_WINDOWS)

return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)threadfunc, u, 0, NULL);

#error not implemented

}

void thread_wait(void *thread)

{

#if defined(CONF_FAMILY_UNIX)

pthread_join((pthread_t)thread, NULL);

#elif defined(CONF_FAMILY_WINDOWS)

WaitForSingleObject((HANDLE)thread, INFINITE);

#error not implemented

}

void thread_destroy(void *thread)

{

#if defined(CONF_FAMILY_UNIX)

void *r = 0;

pthread_join((pthread_t)thread, &r);

/*#error not implemented*/

}

void thread_yield()

{

#if defined(CONF_FAMILY_UNIX)

sched_yield();

#elif defined(CONF_FAMILY_WINDOWS)

Sleep(0);

#error not implemented

}

void thread_sleep(int milliseconds)

{

#if defined(CONF_FAMILY_UNIX)

usleep(milliseconds*1000);

#elif defined(CONF_FAMILY_WINDOWS)

Sleep(milliseconds);

#error not implemented

}

void thread_detach(void *thread)

{

#if defined(CONF_FAMILY_UNIX)

pthread_detach((pthread_t)(thread));

#elif defined(CONF_FAMILY_WINDOWS)

CloseHandle(thread);

#error not implemented

}

#if defined(CONF_FAMILY_UNIX)

typedef pthread_mutex_t LOCKINTERNAL;

#elif defined(CONF_FAMILY_WINDOWS)

typedef CRITICAL_SECTION LOCKINTERNAL;

#error not implemented on this platform

LOCK lock_create()

{

LOCKINTERNAL *lock = (LOCKINTERNAL*)mem_alloc(sizeof(LOCKINTERNAL), 4);

#if defined(CONF_FAMILY_UNIX)

pthread_mutex_init(lock, 0x0);

#elif defined(CONF_FAMILY_WINDOWS)

InitializeCriticalSection((LPCRITICAL_SECTION)lock);

#error not implemented on this platform

return (LOCK)lock;

}

void lock_destroy(LOCK lock)

{

#if defined(CONF_FAMILY_UNIX)

pthread_mutex_destroy((LOCKINTERNAL *)lock);

#elif defined(CONF_FAMILY_WINDOWS)

DeleteCriticalSection((LPCRITICAL_SECTION)lock);

#error not implemented on this platform

mem_free(lock);

}

int lock_try(LOCK lock)

{

#if defined(CONF_FAMILY_UNIX)

return pthread_mutex_trylock((LOCKINTERNAL *)lock);

#elif defined(CONF_FAMILY_WINDOWS)

return !TryEnterCriticalSection((LPCRITICAL_SECTION)lock);

#error not implemented on this platform

}

void lock_wait(LOCK lock)

{

#if defined(CONF_FAMILY_UNIX)

pthread_mutex_lock((LOCKINTERNAL *)lock);

#elif defined(CONF_FAMILY_WINDOWS)

EnterCriticalSection((LPCRITICAL_SECTION)lock);

#error not implemented on this platform

}

void lock_release(LOCK lock)

{

#if defined(CONF_FAMILY_UNIX)

pthread_mutex_unlock((LOCKINTERNAL *)lock);

#elif defined(CONF_FAMILY_WINDOWS)

LeaveCriticalSection((LPCRITICAL_SECTION)lock);

#error not implemented on this platform

}

#if !defined(CONF_PLATFORM_MACOSX)

#if defined(CONF_FAMILY_UNIX)

void semaphore_init(SEMAPHORE *sem) { sem_init(sem, 0, 0); }

void semaphore_wait(SEMAPHORE *sem) { sem_wait(sem); }

void semaphore_signal(SEMAPHORE *sem) { sem_post(sem); }

void semaphore_destroy(SEMAPHORE *sem) { sem_destroy(sem); }

#elif defined(CONF_FAMILY_WINDOWS)

void semaphore_init(SEMAPHORE *sem) { *sem = CreateSemaphore(0, 0, 10000, 0); }

void semaphore_wait(SEMAPHORE *sem) { WaitForSingleObject((HANDLE)*sem, INFINITE); }

void semaphore_signal(SEMAPHORE *sem) { ReleaseSemaphore((HANDLE)*sem, 1, NULL); }

void semaphore_destroy(SEMAPHORE *sem) { CloseHandle((HANDLE)*sem); }

#else

#error not implemented on this platform

#endif

int64 time_get()

{

#if defined(CONF_FAMILY_UNIX)

struct timeval val;

gettimeofday(&val, NULL);

return (int64)val.tv_sec*(int64)1000000+(int64)val.tv_usec;

#elif defined(CONF_FAMILY_WINDOWS)

static int64 last = 0;

int64 t;

QueryPerformanceCounter((PLARGE_INTEGER)&t);

if(t<last) /* for some reason, QPC can return values in the past */

return last;

last = t;

return t;

#error not implemented

}

int64 time_freq()

{

#if defined(CONF_FAMILY_UNIX)

return 1000000;

#elif defined(CONF_FAMILY_WINDOWS)

int64 t;

QueryPerformanceFrequency((PLARGE_INTEGER)&t);

return t;

#error not implemented

}

static void netaddr_to_sockaddr_in(const NETADDR *src, struct sockaddr_in *dest)

{

mem_zero(dest, sizeof(struct sockaddr_in));

if(src->type != NETTYPE_IPV4)

{

dbg_msg("system", "couldn't convert NETADDR of type %d to ipv4", src->type);

return;

}

dest->sin_family = AF_INET;

dest->sin_port = htons(src->port);

mem_copy(&dest->sin_addr.s_addr, src->ip, 4);

}

static void netaddr_to_sockaddr_in6(const NETADDR *src, struct sockaddr_in6 *dest)

{

mem_zero(dest, sizeof(struct sockaddr_in6));

if(src->type != NETTYPE_IPV6)

{

dbg_msg("system", "couldn't not convert NETADDR of type %d to ipv6", src->type);

return;

}

dest->sin6_family = AF_INET6;

dest->sin6_port = htons(src->port);

mem_copy(&dest->sin6_addr.s6_addr, src->ip, 16);

}

static void sockaddr_to_netaddr(const struct sockaddr *src, NETADDR *dst)

{

if(src->sa_family == AF_INET)

{

mem_zero(dst, sizeof(NETADDR));

dst->type = NETTYPE_IPV4;

dst->port = htons(((struct sockaddr_in*)src)->sin_port);

mem_copy(dst->ip, &((struct sockaddr_in*)src)->sin_addr.s_addr, 4);

}

else if(src->sa_family == AF_INET6)

{

mem_zero(dst, sizeof(NETADDR));

dst->type = NETTYPE_IPV6;

dst->port = htons(((struct sockaddr_in6*)src)->sin6_port);

mem_copy(dst->ip, &((struct sockaddr_in6*)src)->sin6_addr.s6_addr, 16);

}

else

{

mem_zero(dst, sizeof(struct sockaddr));

dbg_msg("system", "couldn't convert sockaddr of family %d", src->sa_family);

}

}

int net_addr_comp(const NETADDR *a, const NETADDR *b)

{

return mem_comp(a, b, sizeof(NETADDR));

}

void net_addr_str(const NETADDR *addr, char *string, int max_length, int add_port)

{

if(addr->type == NETTYPE_IPV4)

{

if(add_port != 0)

str_format(string, max_length, "%d.%d.%d.%d:%d", addr->ip[0], addr->ip[1], addr->ip[2], addr->ip[3], addr->port);

else

str_format(string, max_length, "%d.%d.%d.%d", addr->ip[0], addr->ip[1], addr->ip[2], addr->ip[3]);

}

else if(addr->type == NETTYPE_IPV6)

{

if(add_port != 0)

str_format(string, max_length, "[%x:%x:%x:%x:%x:%x:%x:%x]:%d",

(addr->ip[0]<<8)|addr->ip[1], (addr->ip[2]<<8)|addr->ip[3], (addr->ip[4]<<8)|addr->ip[5], (addr->ip[6]<<8)|addr->ip[7],

(addr->ip[8]<<8)|addr->ip[9], (addr->ip[10]<<8)|addr->ip[11], (addr->ip[12]<<8)|addr->ip[13], (addr->ip[14]<<8)|addr->ip[15],

addr->port);

else

str_format(string, max_length, "[%x:%x:%x:%x:%x:%x:%x:%x]",

(addr->ip[0]<<8)|addr->ip[1], (addr->ip[2]<<8)|addr->ip[3], (addr->ip[4]<<8)|addr->ip[5], (addr->ip[6]<<8)|addr->ip[7],

(addr->ip[8]<<8)|addr->ip[9], (addr->ip[10]<<8)|addr->ip[11], (addr->ip[12]<<8)|addr->ip[13], (addr->ip[14]<<8)|addr->ip[15]);

}

else

str_format(string, max_length, "unknown type %d", addr->type);

}

static int priv_net_extract(const char *hostname, char *host, int max_host, int *port)

{

int i;

*port = 0;

host[0] = 0;

if(hostname[0] == '[')

{

// ipv6 mode

for(i = 1; i < max_host && hostname[i] && hostname[i] != ']'; i++)

host[i-1] = hostname[i];

host[i-1] = 0;

if(hostname[i] != ']') // malformatted

return -1;

i++;

if(hostname[i] == ':')

*port = atol(hostname+i+1);

}

else

{

// generic mode (ipv4, hostname etc)

for(i = 0; i < max_host-1 && hostname[i] && hostname[i] != ':'; i++)

host[i] = hostname[i];

host[i] = 0;

if(hostname[i] == ':')

*port = atol(hostname+i+1);

}

return 0;

}

int net_host_lookup(const char *hostname, NETADDR *addr, int types)

{

struct addrinfo hints;

struct addrinfo *result;

int e;

char host[256];

int port = 0;

if(priv_net_extract(hostname, host, sizeof(host), &port))

return -1;

/*

mem_zero(&hints, sizeof(hints));

hints.ai_family = AF_UNSPEC;

if(types == NETTYPE_IPV4)

hints.ai_family = AF_INET;

else if(types == NETTYPE_IPV6)

hints.ai_family = AF_INET6;

e = getaddrinfo(host, NULL, &hints, &result);

if(e != 0 || !result)

return -1;

sockaddr_to_netaddr(result->ai_addr, addr);

freeaddrinfo(result);

addr->port = port;

return 0;

}

static int parse_int(int *out, const char **str)

{

int i = 0;

*out = 0;

if(**str < '0' || **str > '9')

return -1;

i = **str - '0';

(*str)++;

while(1)

{

if(**str < '0' || **str > '9')

{

*out = i;

return 0;

}

i = (i*10) + (**str - '0');

(*str)++;

}

return 0;

}

static int parse_char(char c, const char **str)

{

if(**str != c) return -1;

(*str)++;

return 0;

}

static int parse_uint8(unsigned char *out, const char **str)

{

int i;

if(parse_int(&i, str) != 0) return -1;

if(i < 0 || i > 0xff) return -1;

*out = i;

return 0;

}

static int parse_uint16(unsigned short *out, const char **str)

{

int i;

if(parse_int(&i, str) != 0) return -1;

if(i < 0 || i > 0xffff) return -1;

*out = i;

return 0;

}

int net_addr_from_str(NETADDR *addr, const char *string)

{

const char *str = string;

mem_zero(addr, sizeof(NETADDR));

if(str[0] == '[')

{

/* ipv6 */

struct sockaddr_in6 sa6;

char buf[128];

int i;

str++;

for(i = 0; i < 127 && str[i] && str[i] != ']'; i++)

buf[i] = str[i];

buf[i] = 0;

str += i;

#if defined(CONF_FAMILY_WINDOWS)

{

int size;

sa6.sin6_family = AF_INET6;

size = (int)sizeof(sa6);

if(WSAStringToAddress(buf, AF_INET6, NULL, (struct sockaddr *)&sa6, &size) != 0)

return -1;

}

if(inet_pton(AF_INET6, buf, &sa6) != 1)

return -1;

sockaddr_to_netaddr((struct sockaddr *)&sa6, addr);

if(*str == ']')

{

str++;

if(*str == ':')

{

str++;

if(parse_uint16(&addr->port, &str))

return -1;

}

}

else

return -1;

return 0;

}

else

{

/* ipv4 */

if(parse_uint8(&addr->ip[0], &str)) return -1;

if(parse_char('.', &str)) return -1;

if(parse_uint8(&addr->ip[1], &str)) return -1;

if(parse_char('.', &str)) return -1;

if(parse_uint8(&addr->ip[2], &str)) return -1;

if(parse_char('.', &str)) return -1;

if(parse_uint8(&addr->ip[3], &str)) return -1;

if(*str == ':')

{

str++;

if(parse_uint16(&addr->port, &str)) return -1;

}

addr->type = NETTYPE_IPV4;

}

return 0;

}

static void priv_net_close_socket(int sock)

{

#if defined(CONF_FAMILY_WINDOWS)

closesocket(sock);

close(sock);

}

static int priv_net_close_all_sockets(NETSOCKET sock)

{

/* close down ipv4 */

if(sock.ipv4sock >= 0)

{

priv_net_close_socket(sock.ipv4sock);

sock.ipv4sock = -1;

sock.type &= ~NETTYPE_IPV4;

}

/* close down ipv6 */

if(sock.ipv6sock >= 0)

{

priv_net_close_socket(sock.ipv6sock);

sock.ipv6sock = -1;

sock.type &= ~NETTYPE_IPV6;

}

return 0;

}

static int priv_net_create_socket(int domain, int type, struct sockaddr *addr, int sockaddrlen)

{

int sock, e;

/* create socket */

sock = socket(domain, type, 0);

if(sock < 0)

{

#if defined(CONF_FAMILY_WINDOWS)

char buf[128];

int error = WSAGetLastError();

if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 0, error, 0, buf, sizeof(buf), 0) == 0)

buf[0] = 0;

dbg_msg("net", "failed to create socket with domain %d and type %d (%d '%s')", domain, type, error, buf);

dbg_msg("net", "failed to create socket with domain %d and type %d (%d '%s')", domain, type, errno, strerror(errno));

return -1;

}

/* set to IPv6 only if thats what we are creating */

#if defined(IPV6_V6ONLY) /* windows sdk 6.1 and higher */

if(domain == AF_INET6)

{

int ipv6only = 1;

setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&ipv6only, sizeof(ipv6only));

}

if(type == SOCK_STREAM)

{

int tmp = 1;

setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(tmp));

}

/* bind the socket */

e = bind(sock, addr, sockaddrlen);

if(e != 0)

{

#if defined(CONF_FAMILY_WINDOWS)

char buf[128];

int error = WSAGetLastError();

if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 0, error, 0, buf, sizeof(buf), 0) == 0)

buf[0] = 0;

dbg_msg("net", "failed to bind socket with domain %d and type %d (%d '%s')", domain, type, error, buf);

dbg_msg("net", "failed to bind socket with domain %d and type %d (%d '%s')", domain, type, errno, strerror(errno));

priv_net_close_socket(sock);

return -1;

}

/* return the newly created socket */

return sock;

}

NETSOCKET net_udp_create(NETADDR bindaddr)

{

NETSOCKET sock = invalid_socket;

NETADDR tmpbindaddr = bindaddr;

int broadcast = 1;

int recvsize = 65536;

if(bindaddr.type&NETTYPE_IPV4)

{

struct sockaddr_in addr;

int socket = -1;

/* bind, we should check for error */

tmpbindaddr.type = NETTYPE_IPV4;

netaddr_to_sockaddr_in(&tmpbindaddr, &addr);

socket = priv_net_create_socket(AF_INET, SOCK_DGRAM, (struct sockaddr *)&addr, sizeof(addr));

if(socket >= 0)

{

sock.type |= NETTYPE_IPV4;

sock.ipv4sock = socket;

/* set broadcast */

setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof(broadcast));

/* set receive buffer size */

setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char*)&recvsize, sizeof(recvsize));

}

}

if(bindaddr.type&NETTYPE_IPV6)

{

struct sockaddr_in6 addr;

int socket = -1;

/* bind, we should check for error */

tmpbindaddr.type = NETTYPE_IPV6;

netaddr_to_sockaddr_in6(&tmpbindaddr, &addr);

socket = priv_net_create_socket(AF_INET6, SOCK_DGRAM, (struct sockaddr *)&addr, sizeof(addr));

if(socket >= 0)

{

sock.type |= NETTYPE_IPV6;

sock.ipv6sock = socket;

/* set broadcast */

setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof(broadcast));

/* set receive buffer size */

setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char*)&recvsize, sizeof(recvsize));

}

}

/* set non-blocking */

net_set_non_blocking(sock);

/* return */

return sock;

}

int net_udp_send(NETSOCKET sock, const NETADDR *addr, const void *data, int size)

{

int d = -1;

if(addr->type&NETTYPE_IPV4)

{

if(sock.ipv4sock >= 0)

{

struct sockaddr_in sa;

if(addr->type&NETTYPE_LINK_BROADCAST)

{

mem_zero(&sa, sizeof(sa));

sa.sin_port = htons(addr->port);

sa.sin_family = AF_INET;

sa.sin_addr.s_addr = INADDR_BROADCAST;

}

else

netaddr_to_sockaddr_in(addr, &sa);

d = sendto((int)sock.ipv4sock, (const char*)data, size, 0, (struct sockaddr *)&sa, sizeof(sa));

}

else

dbg_msg("net", "can't sent ipv4 traffic to this socket");

}

if(addr->type&NETTYPE_IPV6)

{

if(sock.ipv6sock >= 0)

{

struct sockaddr_in6 sa;

if(addr->type&NETTYPE_LINK_BROADCAST)

{