lvfulong
170 lines
3.4 KiB
C++
170 lines
3.4 KiB
C++
// ----------------------------------------------------------------------------
|
|
// Win32 socket support.
|
|
//
|
|
#include "V8Socket.h"
|
|
#include <memory>
|
|
|
|
#ifdef _WIN32
|
|
#else
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#endif
|
|
|
|
//using namespace v8;
|
|
namespace laya {
|
|
bool Win32Socket::Bind(const int port) {
|
|
if (!IsValid()) {
|
|
return false;
|
|
}
|
|
|
|
sockaddr_in addr;
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
addr.sin_port = htons(port);
|
|
int status = bind(socket_,
|
|
reinterpret_cast<struct sockaddr *>(&addr),
|
|
sizeof(addr));
|
|
return status == 0;
|
|
}
|
|
|
|
bool Win32Socket::Listen(int backlog) const {
|
|
if (!IsValid()) {
|
|
return false;
|
|
}
|
|
|
|
int status = listen(socket_, backlog);
|
|
return status == 0;
|
|
}
|
|
|
|
V8Socket* Win32Socket::Accept() const {
|
|
if (!IsValid()) {
|
|
return NULL;
|
|
}
|
|
|
|
SOCKET socket = accept(socket_, NULL, NULL);
|
|
if (socket == __INVALID_SOCKET) {
|
|
return NULL;
|
|
}
|
|
else {
|
|
return new Win32Socket(socket);
|
|
}
|
|
}
|
|
|
|
bool Win32Socket::Connect(const char* host, const char* port) {
|
|
return false;
|
|
/*
|
|
if (!IsValid()) {
|
|
return false;
|
|
}
|
|
|
|
// Lookup host and port.
|
|
struct addrinfo *result = NULL;
|
|
struct addrinfo hints;
|
|
memset(&hints, 0, sizeof(addrinfo));
|
|
hints.ai_family = AF_INET;
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
hints.ai_protocol = IPPROTO_TCP;
|
|
int status = getaddrinfo(host, port, &hints, &result);
|
|
if (status != 0) {
|
|
return false;
|
|
}
|
|
|
|
// Connect.
|
|
status = connect(socket_,
|
|
result->ai_addr,
|
|
static_cast<int>(result->ai_addrlen));
|
|
freeaddrinfo(result);
|
|
return status == 0;
|
|
*/
|
|
}
|
|
|
|
bool Win32Socket::Shutdown() {
|
|
if (IsValid()) {
|
|
// Shutdown socket for both read and write.
|
|
int status = shutdown(socket_, 2);// SD_BOTH);
|
|
#ifdef _WIN32
|
|
closesocket(socket_);
|
|
#else
|
|
close(socket_);
|
|
#endif
|
|
socket_ = __INVALID_SOCKET;
|
|
return status == -1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int Win32Socket::Send(const char* data, int len) const {
|
|
if (len <= 0) return 0;
|
|
int written = 0;
|
|
while (written < len) {
|
|
int status = send(socket_, data + written, len - written, 0);
|
|
if (status == 0) {
|
|
break;
|
|
}
|
|
else if (status > 0) {
|
|
written += status;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
return written;
|
|
}
|
|
|
|
int Win32Socket::Receive(char* data, int len) const {
|
|
if (len <= 0) return 0;
|
|
int status = recv(socket_, data, len, 0);
|
|
return (status == -1) ? 0 : status;
|
|
}
|
|
|
|
|
|
bool Win32Socket::SetReuseAddress(bool reuse_address) {
|
|
bool on = reuse_address ? true : false;
|
|
int status = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
|
|
reinterpret_cast<char*>(&on), sizeof(on));
|
|
return status == -1;
|
|
}
|
|
|
|
bool V8Socket::SetUp() {
|
|
// Initialize Winsock32
|
|
#ifdef _WIN32
|
|
int err;
|
|
WSADATA winsock_data;
|
|
WORD version_requested = MAKEWORD(1, 0);
|
|
err = WSAStartup(version_requested, &winsock_data);
|
|
if (err != 0) {
|
|
//v8::internal::PrintF("Unable to initialize Winsock, err = %d\n", Socket::LastError());
|
|
}
|
|
|
|
return err == 0;
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
int V8Socket::LastError() {
|
|
#ifdef _WIN32
|
|
return WSAGetLastError();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
uint16_t V8Socket::HToN(uint16_t value) {
|
|
return htons(value);
|
|
}
|
|
|
|
uint16_t V8Socket::NToH(uint16_t value) {
|
|
return ntohs(value);
|
|
}
|
|
|
|
uint32_t V8Socket::HToN(uint32_t value) {
|
|
return htonl(value);
|
|
}
|
|
|
|
uint32_t V8Socket::NToH(uint32_t value) {
|
|
return ntohl(value);
|
|
}
|
|
}
|