ShuriZma
/
melonDS
mirror of https://github.com/melonDS-emu/melonDS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #641 from nadiaholmquist/feature/qt-platform 

Use Qt's file/threading abstractions in Platform.cpp
This commit is contained in:
Arisotura 2020-06-04 02:13:16 +02:00 committed by GitHub
parent 1abcb4e6ac 924975f6db
commit 90cf310e81
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 166 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
src/frontend/qt_sdl/CMakeLists.txt
View File

@ -1,41 +1,41 @@
project(qt_sdl) project(qt_sdl)
SET(SOURCES_QT_SDL SET(SOURCES_QT_SDL
main.cpp main.cpp
main_shaders.h main_shaders.h
EmuSettingsDialog.cpp EmuSettingsDialog.cpp
InputConfigDialog.cpp InputConfigDialog.cpp
VideoSettingsDialog.cpp VideoSettingsDialog.cpp
AudioSettingsDialog.cpp AudioSettingsDialog.cpp
WifiSettingsDialog.cpp WifiSettingsDialog.cpp
Input.cpp Input.cpp
LAN_PCap.cpp LAN_PCap.cpp
LAN_Socket.cpp LAN_Socket.cpp
OSD.cpp OSD.cpp
OSD_shaders.h OSD_shaders.h
font.h font.h
Platform.cpp Platform.cpp
PlatformConfig.cpp PlatformConfig.cpp
../Util_ROM.cpp ../Util_ROM.cpp
../Util_Video.cpp ../Util_Video.cpp
../Util_Audio.cpp ../Util_Audio.cpp
../FrontendUtil.h ../FrontendUtil.h
../mic_blow.h ../mic_blow.h
../../../melon.qrc ../../../melon.qrc
) )
if (WIN32) if (WIN32)
set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -i <SOURCE> -o <OBJECT>") set(CMAKE_RC_COMPILE_OBJECT "<CMAKE_RC_COMPILER> -i <SOURCE> -o <OBJECT>")
endif() endif()
if (BUILD_STATIC AND QT5_STATIC_DIR) if (BUILD_STATIC AND QT5_STATIC_DIR)
set(QT5_STATIC_BASE ${QT5_STATIC_DIR}/lib/cmake/Qt5) set(QT5_STATIC_BASE ${QT5_STATIC_DIR}/lib/cmake/Qt5)
set(Qt5_DIR ${QT5_STATIC_BASE}) set(Qt5_DIR ${QT5_STATIC_BASE})
set(Qt5Core_DIR ${QT5_STATIC_BASE}Core) set(Qt5Core_DIR ${QT5_STATIC_BASE}Core)
set(Qt5Gui_DIR ${QT5_STATIC_BASE}Gui) set(Qt5Gui_DIR ${QT5_STATIC_BASE}Gui)
set(Qt5Widgets_DIR ${QT5_STATIC_BASE}Widgets) set(Qt5Widgets_DIR ${QT5_STATIC_BASE}Widgets)
endif() endif()
find_package(Qt5 COMPONENTS Core Gui Widgets REQUIRED) find_package(Qt5 COMPONENTS Core Gui Widgets REQUIRED)
@ -44,15 +44,18 @@ set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON) set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON) set(CMAKE_AUTORCC ON)
find_package(Threads REQUIRED)
find_package(PkgConfig REQUIRED) find_package(PkgConfig REQUIRED)
pkg_check_modules(SDL2 REQUIRED sdl2) pkg_check_modules(SDL2 REQUIRED sdl2)
if (WIN32 AND (CMAKE_BUILD_TYPE STREQUAL Release)) if (WIN32 AND (CMAKE_BUILD_TYPE STREQUAL Release))
add_executable(melonDS WIN32 ${SOURCES_QT_SDL}) add_executable(melonDS WIN32 ${SOURCES_QT_SDL})
else() else()
add_executable(melonDS ${SOURCES_QT_SDL}) add_executable(melonDS ${SOURCES_QT_SDL})
endif() endif()
target_link_libraries(melonDS ${CMAKE_THREAD_LIBS_INIT})
target_include_directories(melonDS PRIVATE ${SDL2_INCLUDE_DIRS}) target_include_directories(melonDS PRIVATE ${SDL2_INCLUDE_DIRS})
target_include_directories(melonDS PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}") target_include_directories(melonDS PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
target_include_directories(melonDS PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/..") target_include_directories(melonDS PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/..")
@ -60,48 +63,29 @@ target_include_directories(melonDS PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../..")
target_link_libraries(melonDS core) target_link_libraries(melonDS core)
if (BUILD_STATIC) if (BUILD_STATIC)
target_link_libraries(melonDS -static ${SDL2_LIBRARIES}) target_link_libraries(melonDS -static ${SDL2_LIBRARIES})
else() else()
target_link_libraries(melonDS ${SDL2_LIBRARIES}) target_link_libraries(melonDS ${SDL2_LIBRARIES})
endif() endif()
if (UNIX) if (UNIX)
option(UNIX_PORTABLE "Make a portable build that looks for its configuration in the current directory" OFF) option(PORTABLE "Make a portable build that looks for its configuration in the current directory" OFF)
if (UNIX_PORTABLE) target_link_libraries(melonDS dl Qt5::Core Qt5::Gui Qt5::Widgets)
add_definitions(-DUNIX_PORTABLE)
endif()
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
target_include_directories(melonDS PRIVATE ${GTK3_INCLUDE_DIRS})
target_link_libraries(melonDS ${GTK3_LIBRARIES})
ADD_DEFINITIONS(${GTK3_CFLAGS_OTHER})
add_custom_command(OUTPUT melon_grc.c
COMMAND glib-compile-resources --sourcedir=${CMAKE_SOURCE_DIR}
--target=${CMAKE_CURRENT_BINARY_DIR}/melon_grc.c
--generate-source "${CMAKE_SOURCE_DIR}/melon_grc.xml"
COMMAND glib-compile-resources --sourcedir=${CMAKE_SOURCE_DIR}
--target=${CMAKE_CURRENT_BINARY_DIR}/melon_grc.h
--generate-header "${CMAKE_SOURCE_DIR}/melon_grc.xml")
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
target_link_libraries(melonDS dl Qt5::Core Qt5::Gui Qt5::Widgets)
endif ()
target_sources(melonDS PUBLIC melon_grc.c)
elseif (WIN32) elseif (WIN32)
target_sources(melonDS PUBLIC "${CMAKE_SOURCE_DIR}/melon.rc") option(PORTABLE "Make a portable build that looks for its configuration in the current directory" ON)
target_sources(melonDS PUBLIC "${CMAKE_SOURCE_DIR}/melon.rc")
target_link_libraries(melonDS comctl32 d2d1 dwrite uxtheme ws2_32 iphlpapi gdi32)
if (BUILD_STATIC) target_link_libraries(melonDS comctl32 d2d1 dwrite uxtheme ws2_32 iphlpapi gdi32)
target_link_libraries(melonDS imm32 winmm version setupapi -static Qt5::Core Qt5::Gui Qt5::Widgets z zstd) if (BUILD_STATIC)
else() target_link_libraries(melonDS imm32 winmm version setupapi -static Qt5::Core Qt5::Gui Qt5::Widgets z zstd)
target_link_libraries(melonDS Qt5::Core Qt5::Gui Qt5::Widgets) else()
endif() target_link_libraries(melonDS Qt5::Core Qt5::Gui Qt5::Widgets)
endif () endif()
endif()
if (PORTABLE)
add_definitions(-DPORTABLE)
endif()
install(FILES ../../../net.kuribo64.melonDS.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications) install(FILES ../../../net.kuribo64.melonDS.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications)
install(FILES ../../../icon/melon_16x16.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/16x16/apps RENAME net.kuribo64.melonDS.png) install(FILES ../../../icon/melon_16x16.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/icons/hicolor/16x16/apps RENAME net.kuribo64.melonDS.png)

418
src/frontend/qt_sdl/Platform.cpp
View File

@ -19,7 +19,12 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <SDL2/SDL.h> #include <QStandardPaths>
#include <QDir>
#include <QThread>
#include <QSemaphore>
#include <QOpenGLContext>
#include "Platform.h" #include "Platform.h"
#include "PlatformConfig.h" #include "PlatformConfig.h"
#include "LAN_Socket.h" #include "LAN_Socket.h"
@ -27,25 +32,26 @@
#include <string> #include <string>
#ifdef __WIN32__ #ifdef __WIN32__
#define NTDDI_VERSION 0x06000000 // GROSS FUCKING HACK #define NTDDI_VERSION 0x06000000 // GROSS FUCKING HACK
#include <windows.h> #include <windows.h>
//#include <knownfolders.h> // FUCK THAT SHIT //#include <knownfolders.h> // FUCK THAT SHIT
extern "C" const GUID DECLSPEC_SELECTANY FOLDERID_RoamingAppData = {0x3eb685db, 0x65f9, 0x4cf6, {0xa0, 0x3a, 0xe3, 0xef, 0x65, 0x72, 0x9f, 0x3d}}; #include <shlobj.h>
#include <shlobj.h> #include <winsock2.h>
#include <winsock2.h> #include <ws2tcpip.h>
#include <ws2tcpip.h> #include <io.h>
#define socket_t SOCKET #define dup _dup
#define sockaddr_t SOCKADDR #define socket_t SOCKET
#define sockaddr_t SOCKADDR
#else #else
#include <glib.h>
#include <unistd.h> #include <unistd.h>
#include <arpa/inet.h> #include <netinet/in.h>
#include <netinet/in.h> #include <sys/select.h>
#include <sys/select.h> #include <sys/socket.h>
#include <sys/socket.h>
#define socket_t int #define socket_t int
#define sockaddr_t struct sockaddr #define sockaddr_t struct sockaddr
#define closesocket close #define closesocket close
#endif #endif
#ifndef INVALID_SOCKET #ifndef INVALID_SOCKET
@ -62,22 +68,6 @@ void* oglGetProcAddress(const char* proc);
namespace Platform namespace Platform
{ {
typedef struct
{
SDL_Thread* ID;
void (*Func)();
} ThreadData;
int ThreadEntry(void* data)
{
ThreadData* thread = (ThreadData*)data;
thread->Func();
return 0;
}
socket_t MPSocket; socket_t MPSocket;
sockaddr_t MPSendAddr; sockaddr_t MPSendAddr;
u8 PacketBuffer[2048]; u8 PacketBuffer[2048];
@ -115,14 +105,12 @@ void Init(int argc, char** argv)
strcpy(EmuDirectory, "."); strcpy(EmuDirectory, ".");
} }
#else #else
const char* confdir = g_get_user_config_dir(); QString confdir;
const char* confname = "/melonDS"; QDir config(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation));
int cdlen = strlen(confdir); config.mkdir("melonDS");
int cnlen = strlen(confname); confdir = config.absolutePath() + "/melonDS/";
EmuDirectory = new char[cdlen + cnlen + 1]; EmuDirectory = new char[confdir.length() + 1];
strncpy(&EmuDirectory[0], confdir, cdlen); memcpy(EmuDirectory, confdir.toUtf8().data(), confdir.length());
strncpy(&EmuDirectory[cdlen], confname, cnlen);
EmuDirectory[cdlen+cnlen] = '\0';
#endif #endif
} }
@ -140,280 +128,102 @@ void StopEmu()
FILE* OpenFile(const char* path, const char* mode, bool mustexist) FILE* OpenFile(const char* path, const char* mode, bool mustexist)
{ {
FILE* ret; QFile f(path);
#ifdef __WIN32__ if (mustexist && !f.exists())
int len = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
if (len < 1) return NULL;
WCHAR* fatpath = new WCHAR[len];
int res = MultiByteToWideChar(CP_UTF8, 0, path, -1, fatpath, len);
if (res != len) { delete[] fatpath; return NULL; } // checkme?
// this will be more than enough
WCHAR fatmode[4];
fatmode[0] = mode[0];
fatmode[1] = mode[1];
fatmode[2] = mode[2];
fatmode[3] = 0;
if (mustexist)
{ {
ret = _wfopen(fatpath, L"rb"); return nullptr;
if (ret) ret = _wfreopen(fatpath, fatmode, ret);
} }
else
ret = _wfopen(fatpath, fatmode);
delete[] fatpath; QIODevice::OpenMode qmode;
if (strlen(mode) > 1 && mode[0] == 'r' && mode[1] == '+') {
#else qmode = QIODevice::OpenModeFlag::ReadWrite;
} else if (strlen(mode) > 1 && mode[0] == 'w' && mode[1] == '+') {
if (mustexist) qmode = QIODevice::OpenModeFlag::Truncate | QIODevice::OpenModeFlag::ReadWrite;
{ } else if (mode[0] == 'w') {
ret = fopen(path, "rb"); qmode = QIODevice::OpenModeFlag::Truncate | QIODevice::OpenModeFlag::WriteOnly;
if (ret) ret = freopen(path, mode, ret); } else {
qmode = QIODevice::OpenModeFlag::ReadOnly;
} }
else
ret = fopen(path, mode);
#endif f.open(qmode);
FILE* file = fdopen(dup(f.handle()), mode);
f.close();
return ret; return file;
} }
#if !defined(UNIX_PORTABLE) && !defined(__WIN32__)
FILE* OpenLocalFile(const char* path, const char* mode) FILE* OpenLocalFile(const char* path, const char* mode)
{ {
std::string fullpath; QDir dir(path);
if (path[0] == '/') QString fullpath;
if (dir.isAbsolute())
{ {
// If it's an absolute path, just open that. // If it's an absolute path, just open that.
fullpath = std::string(path); fullpath = path;
} }
else else
{ {
#ifdef PORTABLE
fullpath = path;
#else
// Check user configuration directory // Check user configuration directory
std::string confpath = std::string(g_get_user_config_dir()) + "/melonDS/"; QDir config(QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation));
g_mkdir_with_parents(confpath.c_str(), 0755); config.mkdir("melonDS");
fullpath = confpath + path; fullpath = config.absolutePath() + "/melonDS/";
} fullpath.append(path);
return OpenFile(fullpath.c_str(), mode, mode[0] != 'w');
}
FILE* OpenDataFile(const char* path)
{
const char* melondir = "melonDS";
const char* const* sys_dirs = g_get_system_data_dirs();
const char* user_dir = g_get_user_data_dir();
// First check the user's data directory
char* fullpath = g_build_path("/", user_dir, melondir, path, NULL);
if (access(fullpath, R_OK) == 0)
{
FILE* f = fopen(fullpath, "r");
g_free(fullpath);
return f;
}
free(fullpath);
// Then check the system data directories
for (size_t i = 0; sys_dirs[i] != NULL; i++)
{
const char* dir = sys_dirs[i];
char* fullpath = g_build_path("/", dir, melondir, path, NULL);
if (access(fullpath, R_OK) == 0)
{
FILE* f = fopen(fullpath, "r");
g_free(fullpath);
return f;
}
free(fullpath);
}
FILE* f = fopen(path, "rb");
if (f) return f;
return NULL;
}
#else
FILE* OpenLocalFile(const char* path, const char* mode)
{
bool relpath = false;
int pathlen = strlen(path);
#ifdef __WIN32__
if (pathlen > 3)
{
if (path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
return OpenFile(path, mode);
}
#else
if (pathlen > 1)
{
if (path[0] == '/')
return OpenFile(path, mode);
}
#endif #endif
if (pathlen >= 3)
{
if (path[0] == '.' && path[1] == '.' && (path[2] == '/' || path[2] == '\\'))
relpath = true;
} }
int emudirlen = strlen(EmuDirectory); return OpenFile(fullpath.toUtf8(), mode, mode[0] != 'w');
char* emudirpath;
if (emudirlen)
{
int len = emudirlen + 1 + pathlen + 1;
emudirpath = new char[len];
strncpy(&emudirpath[0], EmuDirectory, emudirlen);
emudirpath[emudirlen] = '/';
strncpy(&emudirpath[emudirlen+1], path, pathlen);
emudirpath[emudirlen+1+pathlen] = '\0';
}
else
{
emudirpath = new char[pathlen+1];
strncpy(&emudirpath[0], path, pathlen);
emudirpath[pathlen] = '\0';
}
// Locations are application directory, and AppData/melonDS on Windows or XDG_CONFIG_HOME/melonDS on Linux
FILE* f;
// First check current working directory
f = OpenFile(path, mode, true);
if (f) { delete[] emudirpath; return f; }
// then emu directory
f = OpenFile(emudirpath, mode, true);
if (f) { delete[] emudirpath; return f; }
#ifdef __WIN32__
// a path relative to AppData wouldn't make much sense
if (!relpath)
{
// Now check AppData
PWSTR appDataPath = NULL;
SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, NULL, &appDataPath);
if (!appDataPath)
{
delete[] emudirpath;
return NULL;
}
// this will be more than enough
WCHAR fatperm[4];
fatperm[0] = mode[0];
fatperm[1] = mode[1];
fatperm[2] = mode[2];
fatperm[3] = 0;
int fnlen = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
if (fnlen < 1) { delete[] emudirpath; return NULL; }
WCHAR* wfileName = new WCHAR[fnlen];
int res = MultiByteToWideChar(CP_UTF8, 0, path, -1, wfileName, fnlen);
if (res != fnlen) { delete[] wfileName; delete[] emudirpath; return NULL; } // checkme?
const WCHAR* appdir = L"\\melonDS\\";
int pos = wcslen(appDataPath);
void* ptr = CoTaskMemRealloc(appDataPath, (pos+wcslen(appdir)+fnlen+1)*sizeof(WCHAR));
if (!ptr) { delete[] wfileName; delete[] emudirpath; return NULL; } // oh well
appDataPath = (PWSTR)ptr;
wcscpy(&appDataPath[pos], appdir); pos += wcslen(appdir);
wcscpy(&appDataPath[pos], wfileName);
f = _wfopen(appDataPath, L"rb");
if (f) f = _wfreopen(appDataPath, fatperm, f);
CoTaskMemFree(appDataPath);
delete[] wfileName;
if (f) { delete[] emudirpath; return f; }
}
#else
if (!relpath)
{
// Now check XDG_CONFIG_HOME
// TODO: check for memory leak there
std::string fullpath = std::string(g_get_user_config_dir()) + "/melonDS/" + path;
f = OpenFile(fullpath.c_str(), mode, true);
if (f) { delete[] emudirpath; return f; }
}
#endif
if (mode[0] != 'r')
{
f = OpenFile(emudirpath, mode);
if (f) { delete[] emudirpath; return f; }
}
delete[] emudirpath;
return NULL;
} }
FILE* OpenDataFile(const char* path) void* Thread_Create(void (* func)())
{ {
return OpenLocalFile(path, "rb"); QThread* t = QThread::create(func);
} t->start();
return (void*) t;
#endif
void* Thread_Create(void (*func)())
{
ThreadData* data = new ThreadData;
data->Func = func;
data->ID = SDL_CreateThread(ThreadEntry, "melonDS core thread", data);
return data;
} }
void Thread_Free(void* thread) void Thread_Free(void* thread)
{ {
delete (ThreadData*)thread; QThread* t = (QThread*) thread;
t->terminate();
delete t;
} }
void Thread_Wait(void* thread) void Thread_Wait(void* thread)
{ {
SDL_WaitThread((SDL_Thread*)((ThreadData*)thread)->ID, NULL); ((QThread*) thread)->wait();
} }
void* Semaphore_Create() void* Semaphore_Create()
{ {
return SDL_CreateSemaphore(0); return new QSemaphore();
} }
void Semaphore_Free(void* sema) void Semaphore_Free(void* sema)
{ {
SDL_DestroySemaphore((SDL_sem*)sema); delete (QSemaphore*) sema;
} }
void Semaphore_Reset(void* sema) void Semaphore_Reset(void* sema)
{ {
while (SDL_SemTryWait((SDL_sem*)sema) == 0); QSemaphore* s = (QSemaphore*) sema;
s->acquire(s->available());
} }
void Semaphore_Wait(void* sema) void Semaphore_Wait(void* sema)
{ {
SDL_SemWait((SDL_sem*)sema); ((QSemaphore*) sema)->acquire();
} }
void Semaphore_Post(void* sema) void Semaphore_Post(void* sema)
{ {
SDL_SemPost((SDL_sem*)sema); ((QSemaphore*) sema)->release();
} }
@ -437,44 +247,44 @@ bool MP_Init()
#endif // __WIN32__ #endif // __WIN32__
MPSocket = socket(AF_INET, SOCK_DGRAM, 0); MPSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (MPSocket < 0) if (MPSocket < 0)
{ {
return false; return false;
} }
res = setsockopt(MPSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt_true, sizeof(int)); res = setsockopt(MPSocket, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt_true, sizeof(int));
if (res < 0) if (res < 0)
{ {
closesocket(MPSocket); closesocket(MPSocket);
MPSocket = INVALID_SOCKET; MPSocket = INVALID_SOCKET;
return false; return false;
} }
sockaddr_t saddr; sockaddr_t saddr;
saddr.sa_family = AF_INET; saddr.sa_family = AF_INET;
*(u32*)&saddr.sa_data[2] = htonl(Config::SocketBindAnyAddr ? INADDR_ANY : INADDR_LOOPBACK); *(u32*)&saddr.sa_data[2] = htonl(Config::SocketBindAnyAddr ? INADDR_ANY : INADDR_LOOPBACK);
*(u16*)&saddr.sa_data[0] = htons(7064); *(u16*)&saddr.sa_data[0] = htons(7064);
res = bind(MPSocket, &saddr, sizeof(sockaddr_t)); res = bind(MPSocket, &saddr, sizeof(sockaddr_t));
if (res < 0) if (res < 0)
{ {
closesocket(MPSocket); closesocket(MPSocket);
MPSocket = INVALID_SOCKET; MPSocket = INVALID_SOCKET;
return false; return false;
} }
res = setsockopt(MPSocket, SOL_SOCKET, SO_BROADCAST, (const char*)&opt_true, sizeof(int)); res = setsockopt(MPSocket, SOL_SOCKET, SO_BROADCAST, (const char*)&opt_true, sizeof(int));
if (res < 0) if (res < 0)
{ {
closesocket(MPSocket); closesocket(MPSocket);
MPSocket = INVALID_SOCKET; MPSocket = INVALID_SOCKET;
return false; return false;
} }
MPSendAddr.sa_family = AF_INET; MPSendAddr.sa_family = AF_INET;
*(u32*)&MPSendAddr.sa_data[2] = htonl(INADDR_BROADCAST); *(u32*)&MPSendAddr.sa_data[2] = htonl(INADDR_BROADCAST);
*(u16*)&MPSendAddr.sa_data[0] = htons(7064); *(u16*)&MPSendAddr.sa_data[0] = htons(7064);
return true; return true;
} }
void MP_DeInit() void MP_DeInit()
@ -515,14 +325,14 @@ int MP_RecvPacket(u8* data, bool block)
return 0; return 0;
fd_set fd; fd_set fd;
struct timeval tv; struct timeval tv;
FD_ZERO(&fd); FD_ZERO(&fd);
FD_SET(MPSocket, &fd); FD_SET(MPSocket, &fd);
tv.tv_sec = 0; tv.tv_sec = 0;
tv.tv_usec = block ? 5000 : 0; tv.tv_usec = block ? 5000 : 0;
if (!select(MPSocket+1, &fd, 0, 0, &tv)) if (!select(MPSocket+1, &fd, 0, 0, &tv))
{ {
return 0; return 0;
} }