talksik/easywsclient
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactoring into separate .hpp and .cpp files.

Browse Source
This commit is contained in:
David Baird
2013-04-05 11:38:51 -06:00
parent ad0f214fa9
commit af6d38638d
4 changed files with 320 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files
easywsclient.cpp
+307
View File
@@ -0,0 +1,307 @@
#include "easywsclient.hpp"
#include <fcntl.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdint.h>
#include <vector>
#include <string>
namespace { // private module-only namespace
int hostname_connect(std::string hostname, int port) {
struct addrinfo hints;
struct addrinfo *result;
struct addrinfo *p;
int ret;
int sockfd = -1;
char sport[16];
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
snprintf(sport, 16, "%d", port);
if ((ret = getaddrinfo(hostname.c_str(), sport, &hints, &result)) != 0)
{
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret));
return 1;
}
for(p = result; p != NULL; p = p->ai_next)
{
sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (sockfd == -1) { continue; }
if (connect(sockfd, p->ai_addr, p->ai_addrlen) != -1) {
break;
}
close(sockfd);
sockfd = -1;
}
freeaddrinfo(result);
return sockfd;
}
}
namespace easywsclient {
struct _DummyWebSocket : public WebSocket
{
void poll() { }
void send(std::string message) { }
void _dispatch(Callback & callable) { }
};
struct _RealWebSocket : public WebSocket
{
#if 0
http://tools.ietf.org/html/rfc6455#section-5.2 Base Framing Protocol
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
#endif
struct wsheader_type {
int header_size;
bool fin;
bool mask;
enum opcode_type {
CONTINUATION = 0x0,
TEXT_FRAME = 0x1,
BINARY_FRAME = 0x2,
CLOSE = 8,
PING = 9,
PONG = 0xa,
} opcode;
int N0;
uint64_t N;
uint8_t masking_key[4];
};
std::vector<char> rxbuf;
std::vector<char> txbuf;
int sockfd;
bool closed;
_RealWebSocket(int sockfd) : sockfd(sockfd), closed(false) {
}
void poll() {
if (closed) { return; }
while (true) {
// FD_ISSET(0, &rfds) will be true
int N = rxbuf.size();
ssize_t ret;
rxbuf.resize(N + 1500);
ret = recv(sockfd, &rxbuf[0] + N, 1500, 0);
if (false) { }
else if (ret < 0) {
rxbuf.resize(N);
break;
}
else if (ret == 0) {
rxbuf.resize(N);
closed = true;
close(sockfd);
break;
}
else {
rxbuf.resize(N + ret);
}
}
while (txbuf.size()) {
int ret;
ret = ::send(sockfd, &txbuf[0], txbuf.size(), 0);
if (ret > 0) { txbuf.erase(txbuf.begin(), txbuf.begin() + ret); }
else { break; }
}
}
// Callable must have signature: void(const std::string & message).
// Should work with C functions, C++ functors, and C++11 std::function and
// lambda:
//template<class Callable>
//void dispatch(Callable callable) {
virtual void _dispatch(WebSocket::Callback & callable) {
// TODO: consider acquiring a lock on rxbuf...
while (true) {
wsheader_type ws;
if (rxbuf.size() < 2) { return; /* Need at least 2 */ }
const uint8_t * data = (uint8_t *) &rxbuf[0]; // peek, but don't consume
ws.fin = (data[0] & 0x80) == 0x80;
ws.opcode = (wsheader_type::opcode_type) (data[0] & 0x0f);
ws.mask = (data[1] & 0x80) == 0x80;
ws.N0 = (data[1] & 0x7f);
ws.header_size = 2 + (ws.N0 == 126? 2 : 0) + (ws.N0 == 127? 6 : 0) + (ws.mask? 4 : 0);
if (rxbuf.size() < ws.header_size) { return; /* Need: ws.header_size - rxbuf.size() */ }
int i;
if (ws.N0 < 126) {
ws.N = ws.N0;
i = 2;
}
else if (ws.N0 == 126) {
ws.N = 0;
ws.N |= ((uint64_t) data[2]) << 8;
ws.N |= ((uint64_t) data[3]) << 0;
i = 4;
}
else if (ws.N0 == 127) {
ws.N = 0;
ws.N |= ((uint64_t) data[2]) << 56;
ws.N |= ((uint64_t) data[3]) << 48;
ws.N |= ((uint64_t) data[4]) << 40;
ws.N |= ((uint64_t) data[5]) << 32;
ws.N |= ((uint64_t) data[6]) << 24;
ws.N |= ((uint64_t) data[7]) << 16;
ws.N |= ((uint64_t) data[8]) << 8;
ws.N |= ((uint64_t) data[9]) << 0;
i = 10;
}
if (ws.mask) {
ws.masking_key[0] = ((uint8_t) data[i+0]) << 0;
ws.masking_key[1] = ((uint8_t) data[i+1]) << 0;
ws.masking_key[2] = ((uint8_t) data[i+2]) << 0;
ws.masking_key[3] = ((uint8_t) data[i+3]) << 0;
}
else {
ws.masking_key[0] = 0;
ws.masking_key[1] = 0;
ws.masking_key[2] = 0;
ws.masking_key[3] = 0;
}
if (rxbuf.size() < ws.header_size+ws.N) { return; /* Need: ws.header_size+ws.N - rxbuf.size() */ }
// We got a whole message, now do something with it:
if (false) { }
else if (ws.opcode == wsheader_type::TEXT_FRAME && ws.fin) {
if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i+ws.header_size] ^= ws.masking_key[i&0x3]; } }
std::string data(rxbuf.begin()+ws.header_size, rxbuf.begin()+ws.header_size+ws.N);
callable((const std::string) data);
}
else if (ws.opcode == wsheader_type::PING) { }
else if (ws.opcode == wsheader_type::PONG) { }
else if (ws.opcode == wsheader_type::CLOSE) { closed = true; close(sockfd); }
else { fprintf(stderr, "ERROR: Got unexpected WebSocket message.\n"); closed = true; close(sockfd); }
rxbuf.erase(rxbuf.begin(), rxbuf.begin() + ws.header_size+ws.N);
}
}
void send(std::string message) {
// TODO: consider acquiring a lock on txbuf...
std::vector<uint8_t> header;
header.assign(2 + (message.size() >= 126 ? 2 : 0) + (message.size() >= 65536 ? 6 : 0), 0);
header[0] = 0x80 | wsheader_type::TEXT_FRAME;
if (false) { }
else if (message.size() < 126) {
header[1] = message.size();
}
else if (message.size() < 65536) {
header[1] = 126;
header[2] = (message.size() >> 8) & 0xff;
header[3] = (message.size() >> 0) & 0xff;
}
else { // TODO: run coverage testing here
header[1] = 127;
header[2] = (message.size() >> 56) & 0xff;
header[3] = (message.size() >> 48) & 0xff;
header[4] = (message.size() >> 40) & 0xff;
header[5] = (message.size() >> 32) & 0xff;
header[6] = (message.size() >> 24) & 0xff;
header[7] = (message.size() >> 16) & 0xff;
header[8] = (message.size() >> 8) & 0xff;
header[9] = (message.size() >> 0) & 0xff;
}
txbuf.insert(txbuf.end(), header.begin(), header.end());
txbuf.insert(txbuf.end(), message.begin(), message.end());
}
};
WebSocket::pointer WebSocket::create_dummy() {
static pointer dummy = pointer(new _DummyWebSocket);
return dummy;
}
WebSocket::pointer WebSocket::from_url(std::string url) {
char host[128];
int port;
char path[128];
if (false) { }
else if (sscanf(url.c_str(), "ws://%[^:]:%d/%s", host, &port, path) == 3) {
}
else if (sscanf(url.c_str(), "ws://%[^/]/%s", host, path) == 2) {
port = 80;
}
else {
fprintf(stderr, "ERROR: Could not parse WebSocket url: %s\n", url.c_str());
return NULL;
}
int sockfd = hostname_connect(host, port);
if (sockfd == -1) {
fprintf(stderr, "Unable to connect to %s:%d\n", host, port);
return NULL;
}
{
// XXX: this should be done non-blocking,
char line[256];
int status;
int i;
snprintf(line, 256, "GET /%s HTTP/1.1\r\n", path); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Host: %s:%d\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Upgrade: websocket\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Connection: Upgrade\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Sec-WebSocket-Version: 13\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
for (i = 0; i < 2 || i < 255 && line[i-2] != '\r' && line[i-1] != '\n'; ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
line[i] = 0;
if (i == 255) { fprintf(stderr, "ERROR: Got invalid status line connecting to: %s\n", url.c_str()); return NULL; }
if (sscanf(line, "HTTP/1.1 %d", &status) != 1 || status != 101) { fprintf(stderr, "ERROR: Got bad status connecting to %s: %s", url.c_str(), line); return NULL; }
// TODO: verify response headers,
while (true) {
for (i = 0; i < 2 || i < 255 && line[i-2] != '\r' && line[i-1] != '\n'; ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
if (line[0] == '\r' && line[1] == '\n') { break; }
}
}
int flag = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof(flag)); // Disable Nagle's algorithm
fcntl(sockfd, F_SETFL, O_NONBLOCK);
fprintf(stderr, "Connected to: %s\n", url.c_str());
return pointer(new _RealWebSocket(sockfd));
}
} // namespace easywsclient
easywsclient.hpp
+8 -316
View File
@@ -1,24 +1,13 @@
#ifndef EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD
#define EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD
// This code comes from,
// This code comes from:
// https://github.com/dhbaird/easywsclient
// To get the latest version,
//
// To get the latest version:
// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.hpp
// wget https://raw.github.com/dhbaird/easywsclient/master/easywsclient.cpp
#include <fcntl.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdint.h>
#include <vector>
#include <string>
namespace easywsclient {
@@ -26,21 +15,16 @@ namespace easywsclient {
struct WebSocket {
typedef WebSocket * pointer;
struct Callback { virtual void operator()(const std::string & message) = 0; };
// Factories (in the spirit of PIMPL):
// Factories:
static pointer create_dummy();
static pointer from_url(std::string url);
static int hostname_connect(std::string hostname, int port); // <-- convenience function
// Interfaces:
virtual ~WebSocket() { }
virtual void poll() = 0;
virtual void send(std::string message) = 0;
template<class Callable>
void dispatch(Callable callable) {
// ...don't you just want to love C++, right about here?
// (N.B. this is why the C++11 lambda syntax was invented)
void dispatch(Callable callable) { // N.B. this is compatible with both C++11 lambdas, functors and C function pointers
struct _Callback : public Callback {
Callable & callable;
_Callback(Callable & callable) : callable(callable) { }
@@ -50,303 +34,11 @@ struct WebSocket {
_dispatch(callback);
}
private:
protected:
struct Callback { virtual void operator()(const std::string & message) = 0; };
virtual void _dispatch(Callback & callable) = 0;
};
// Everything in this #if block could be separated out into a .cpp file, if you
// so desired,
#if defined(EASYWSCLIENT_COMPILATION_UNIT)
struct _DummyWebSocket : public WebSocket
{
void poll() { }
void send(std::string message) { }
void _dispatch(Callback & callable) { }
};
struct _RealWebSocket : public WebSocket
{
#if 0
http://tools.ietf.org/html/rfc6455#section-5.2 Base Framing Protocol
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
#endif
struct wsheader_type {
int header_size;
bool fin;
bool mask;
enum opcode_type {
CONTINUATION = 0x0,
TEXT_FRAME = 0x1,
BINARY_FRAME = 0x2,
CLOSE = 8,
PING = 9,
PONG = 0xa,
} opcode;
int N0;
uint64_t N;
uint8_t masking_key[4];
};
std::vector<char> rxbuf;
std::vector<char> txbuf;
int sockfd;
bool closed;
_RealWebSocket(int sockfd) : sockfd(sockfd), closed(false) {
}
void poll() {
if (closed) { return; }
while (true) {
// FD_ISSET(0, &rfds) will be true
int N = rxbuf.size();
ssize_t ret;
rxbuf.resize(N + 1500);
ret = recv(sockfd, &rxbuf[0] + N, 1500, 0);
if (false) { }
else if (ret < 0) {
rxbuf.resize(N);
break;
}
else if (ret == 0) {
rxbuf.resize(N);
closed = true;
close(sockfd);
break;
}
else {
rxbuf.resize(N + ret);
}
}
while (txbuf.size()) {
int ret;
ret = ::send(sockfd, &txbuf[0], txbuf.size(), 0);
if (ret > 0) { txbuf.erase(txbuf.begin(), txbuf.begin() + ret); }
else { break; }
}
}
// Callable must have signature: void(const std::string & message).
// Should work with C functions, C++ functors, and C++11 std::function and
// lambda:
//template<class Callable>
//void dispatch(Callable callable) {
virtual void _dispatch(WebSocket::Callback & callable) {
// TODO: consider acquiring a lock on rxbuf...
while (true) {
wsheader_type ws;
if (rxbuf.size() < 2) { return; /* Need at least 2 */ }
const uint8_t * data = (uint8_t *) &rxbuf[0]; // peek, but don't consume
ws.fin = (data[0] & 0x80) == 0x80;
ws.opcode = (wsheader_type::opcode_type) (data[0] & 0x0f);
ws.mask = (data[1] & 0x80) == 0x80;
ws.N0 = (data[1] & 0x7f);
ws.header_size = 2 + (ws.N0 == 126? 2 : 0) + (ws.N0 == 127? 6 : 0) + (ws.mask? 4 : 0);
if (rxbuf.size() < ws.header_size) { return; /* Need: ws.header_size - rxbuf.size() */ }
int i;
if (ws.N0 < 126) {
ws.N = ws.N0;
i = 2;
}
else if (ws.N0 == 126) {
ws.N = 0;
ws.N |= ((uint64_t) data[2]) << 8;
ws.N |= ((uint64_t) data[3]) << 0;
i = 4;
}
else if (ws.N0 == 127) {
ws.N = 0;
ws.N |= ((uint64_t) data[2]) << 56;
ws.N |= ((uint64_t) data[3]) << 48;
ws.N |= ((uint64_t) data[4]) << 40;
ws.N |= ((uint64_t) data[5]) << 32;
ws.N |= ((uint64_t) data[6]) << 24;
ws.N |= ((uint64_t) data[7]) << 16;
ws.N |= ((uint64_t) data[8]) << 8;
ws.N |= ((uint64_t) data[9]) << 0;
i = 10;
}
if (ws.mask) {
ws.masking_key[0] = ((uint8_t) data[i+0]) << 0;
ws.masking_key[1] = ((uint8_t) data[i+1]) << 0;
ws.masking_key[2] = ((uint8_t) data[i+2]) << 0;
ws.masking_key[3] = ((uint8_t) data[i+3]) << 0;
}
else {
ws.masking_key[0] = 0;
ws.masking_key[1] = 0;
ws.masking_key[2] = 0;
ws.masking_key[3] = 0;
}
if (rxbuf.size() < ws.header_size+ws.N) { return; /* Need: ws.header_size+ws.N - rxbuf.size() */ }
// We got a whole message, now do something with it:
if (false) { }
else if (ws.opcode == wsheader_type::TEXT_FRAME && ws.fin) {
if (ws.mask) { for (size_t i = 0; i != ws.N; ++i) { rxbuf[i+ws.header_size] ^= ws.masking_key[i&0x3]; } }
std::string data(rxbuf.begin()+ws.header_size, rxbuf.begin()+ws.header_size+ws.N);
callable((const std::string) data);
}
else if (ws.opcode == wsheader_type::PING) { }
else if (ws.opcode == wsheader_type::PONG) { }
else if (ws.opcode == wsheader_type::CLOSE) { closed = true; close(sockfd); }
else { fprintf(stderr, "ERROR: Got unexpected WebSocket message.\n"); closed = true; close(sockfd); }
rxbuf.erase(rxbuf.begin(), rxbuf.begin() + ws.header_size+ws.N);
}
}
void send(std::string message) {
// TODO: consider acquiring a lock on txbuf...
std::vector<uint8_t> header;
header.assign(2 + (message.size() >= 126 ? 2 : 0) + (message.size() >= 65536 ? 6 : 0), 0);
header[0] = 0x80 | wsheader_type::TEXT_FRAME;
if (false) { }
else if (message.size() < 126) {
header[1] = message.size();
}
else if (message.size() < 65536) {
header[1] = 126;
header[2] = (message.size() >> 8) & 0xff;
header[3] = (message.size() >> 0) & 0xff;
}
else { // TODO: run coverage testing here
header[1] = 127;
header[2] = (message.size() >> 56) & 0xff;
header[3] = (message.size() >> 48) & 0xff;
header[4] = (message.size() >> 40) & 0xff;
header[5] = (message.size() >> 32) & 0xff;
header[6] = (message.size() >> 24) & 0xff;
header[7] = (message.size() >> 16) & 0xff;
header[8] = (message.size() >> 8) & 0xff;
header[9] = (message.size() >> 0) & 0xff;
}
txbuf.insert(txbuf.end(), header.begin(), header.end());
txbuf.insert(txbuf.end(), message.begin(), message.end());
}
};
int WebSocket::hostname_connect(std::string hostname, int port) {
struct addrinfo hints;
struct addrinfo *result;
struct addrinfo *p;
int ret;
int sockfd = -1;
char sport[16];
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
snprintf(sport, 16, "%d", port);
if ((ret = getaddrinfo(hostname.c_str(), sport, &hints, &result)) != 0)
{
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ret));
return 1;
}
for(p = result; p != NULL; p = p->ai_next)
{
sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
if (sockfd == -1) { continue; }
if (connect(sockfd, p->ai_addr, p->ai_addrlen) != -1) {
break;
}
close(sockfd);
sockfd = -1;
}
freeaddrinfo(result);
return sockfd;
}
WebSocket::pointer WebSocket::create_dummy() {
static pointer dummy = pointer(new _DummyWebSocket);
return dummy;
}
WebSocket::pointer WebSocket::from_url(std::string url) {
char host[128];
int port;
char path[128];
if (false) { }
else if (sscanf(url.c_str(), "ws://%[^:]:%d/%s", host, &port, path) == 3) {
}
else if (sscanf(url.c_str(), "ws://%[^/]/%s", host, path) == 2) {
port = 80;
}
else {
fprintf(stderr, "ERROR: Could not parse WebSocket url: %s\n", url.c_str());
return NULL;
}
int sockfd = hostname_connect(host, port);
if (sockfd == -1) {
fprintf(stderr, "Unable to connect to %s:%d\n", host, port);
return NULL;
}
{
// XXX: this should be done non-blocking,
char line[256];
int status;
int i;
snprintf(line, 256, "GET /%s HTTP/1.1\r\n", path); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Host: %s:%d\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Upgrade: websocket\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Connection: Upgrade\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "Sec-WebSocket-Version: 13\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
snprintf(line, 256, "\r\n", host, port); ::send(sockfd, line, strlen(line), 0);
for (i = 0; i < 2 || i < 255 && line[i-2] != '\r' && line[i-1] != '\n'; ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
line[i] = 0;
if (i == 255) { fprintf(stderr, "ERROR: Got invalid status line connecting to: %s\n", url.c_str()); return NULL; }
if (sscanf(line, "HTTP/1.1 %d", &status) != 1 || status != 101) { fprintf(stderr, "ERROR: Got bad status connecting to %s: %s", url.c_str(), line); return NULL; }
// TODO: verify response headers,
while (true) {
for (i = 0; i < 2 || i < 255 && line[i-2] != '\r' && line[i-1] != '\n'; ++i) { if (recv(sockfd, line+i, 1, 0) == 0) { return NULL; } }
if (line[0] == '\r' && line[1] == '\n') { break; }
}
}
int flag = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof(flag)); // Disable Nagle's algorithm
fcntl(sockfd, F_SETFL, O_NONBLOCK);
fprintf(stderr, "Connected to: %s\n", url.c_str());
return pointer(new _RealWebSocket(sockfd));
}
#endif // defined(EASYWSCLIENT_COMPILATION_UNIT)
} // namespace easywsclient
#endif /* EASYWSCLIENT_HPP_20120819_MIOFVASDTNUASZDQPLFD */
example-client-cpp11.cpp
+3 -6
View File
@@ -1,7 +1,7 @@
// Compile with:
// g++ -std=gnu++0x example-client-cpp11.cpp -o example-client-cpp11
#define EASYWSCLIENT_COMPILATION_UNIT
#include "easywsclient.hpp"
#include "easywsclient.cpp" // <-- include only if you don't want compile separately
#include <assert.h>
#include <stdio.h>
#include <string>
@@ -14,13 +14,10 @@ int main()
ws->send("goodbye");
ws->send("hello");
while (true) {
std::string message;
ws->poll();
ws->dispatch([&message](const std::string & message_) {
printf(">>> %s\n", message_.c_str());
message = message_;
ws->dispatch([](const std::string & message) {
printf(">>> %s\n", message.c_str());
});
if (message == "world") { break; }
}
return 0;
}
example-client.cpp
+2 -7
View File
@@ -1,17 +1,12 @@
#define EASYWSCLIENT_COMPILATION_UNIT
#include "easywsclient.hpp"
#include "easywsclient.cpp" // <-- include only if you don't want compile separately
#include <assert.h>
#include <stdio.h>
#include <string>
// N.B. A real application should abuse a global variable like this...
// (gets messy if threads are involved)
std::string message;
void handle_message(const std::string & message)
{
printf(">>> %s\n", message.c_str());
::message = message;
}
int main()
@@ -21,7 +16,7 @@ int main()
assert(ws);
ws->send("goodbye");
ws->send("hello");
while (message != "world") {
while (true) {
ws->poll();
ws->dispatch(handle_message);
}