int server_open(int port, server_context* context)
{
struct libwebsocket_context* lws_context;
struct lws_context_creation_info info;
int opts = 0;
memset(&info, 0, sizeof(struct lws_context_creation_info));
info.port = port;
info.protocols = server_protocols;
info.gid = -1;
info.uid = -1;
info.options = opts;
info.user = context;
lws_context = libwebsocket_create_context(&info);
if (lws_context == NULL)
return -1;
memset(context, 0, sizeof(server_context));
context->lws_context = lws_context;
context->send_buffer = NULL;
context->send_length = 0;
return 0;
}
int idaapi websocket_thread(void *) {
struct libwebsocket_context* context;
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = 3003;
info.iface = NULL;
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
info.gid = -1;
info.uid = -1;
info.options = 0;
// i assume this does the bind?
context = libwebsocket_create_context(&info);
if (context == NULL) {
msg("websocket init failed\n");
return -1;
}
msg("yay websockets\n");
while (websockets_running) {
libwebsocket_service(context, 50);
}
libwebsocket_context_destroy(context);
return 0;
}
void init_websockets() {
struct lws_context_creation_info info;
memset(&info, 0, sizeof(info));
info.port = 7732;
info.protocols = protocols;
context = libwebsocket_create_context(&info);
if (!context) {
puts("unable to create lws context");
exit(1);
}
}
int main( void )
{
int port = 8080;
const char *interface = NULL;
struct libwebsocket_context *context;
struct lws_context_creation_info context_info;
memset( &context_info, 0, sizeof( struct lws_context_creation_info ) );
context_info.port = 8080;
context_info.iface = NULL;
context_info.protocols = protocols;
context_info.extensions = libwebsocket_get_internal_extensions();
context_info.ssl_cert_filepath = NULL;
context_info.ssl_private_key_filepath = NULL;
context_info.ssl_ca_filepath = NULL;
context_info.ssl_cipher_list = NULL;
context_info.http_proxy_address = NULL;
context_info.http_proxy_port = 0;
context_info.gid = -1;
context_info.uid = -1;
context_info.options = 0;
context_info.user = NULL;
context_info.ka_time = 0;
context_info.ka_probes = 0;
context_info.ka_interval = 0;
const char *cert_path = NULL;
const char *key_path = NULL;
int opts = 0;
// context = libwebsocket_create_context( port, interface, protocols,
// libwebsocket_internal_extensions,
// cert_path, key_path, -1, -1, opts );
context = libwebsocket_create_context( &context_info );
if ( context == NULL )
{
fprintf( stderr, "libwebsocket init failed\n" );
return -1;
}
printf( "Starting server ...\n" );
while ( 1 )
{
libwebsocket_service( context, 50 );
}
libwebsocket_context_destroy( context );
return 0;
}
bool FJavascriptWebSocketServer::Init(uint32 Port, FJavascriptWebSocketClientConnectedCallBack CallBack)
{
#if !PLATFORM_HTML5
// setup log level.
#if !UE_BUILD_SHIPPING
lws_set_log_level(LLL_ERR | LLL_WARN | LLL_NOTICE | LLL_DEBUG | LLL_INFO, libwebsocket_debugLog_JS);
#endif
Protocols = new libwebsocket_protocols[3];
FMemory::Memzero(Protocols, sizeof(libwebsocket_protocols) * 3);
Protocols[0].name = "binary";
Protocols[0].callback = FJavascriptWebSocket::unreal_networking_server;
Protocols[0].per_session_data_size = sizeof(PerSessionDataServer);
Protocols[0].rx_buffer_size = 10 * 1024 * 1024;
Protocols[1].name = nullptr;
Protocols[1].callback = nullptr;
Protocols[1].per_session_data_size = 0;
struct lws_context_creation_info Info;
memset(&Info, 0, sizeof(lws_context_creation_info));
// look up libwebsockets.h for details.
Info.port = Port;
// we listen on all available interfaces.
Info.iface = NULL;
Info.protocols = &Protocols[0];
// no extensions
Info.extensions = NULL;
Info.gid = -1;
Info.uid = -1;
Info.options = 0;
// tack on this object.
Info.user = this;
Info.port = Port;
Context = libwebsocket_create_context(&Info);
if (Context == NULL)
{
return false; // couldn't create a server.
}
ConnectedCallBack = CallBack;
//@HACK
Context->user_space = this;
#endif
return true;
}
void WebSocket::onSubThreadStarted()
{
std::lock_guard<std::mutex> lk(_websocketsMutex);
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
/*
* create the websocket context. This tracks open connections and
* knows how to route any traffic and which protocol version to use,
* and if each connection is client or server side.
*
* For this client-only demo, we tell it to not listen on any port.
*/
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = _wsProtocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.gid = -1;
info.uid = -1;
info.user = (void*)this;
_wsContext = libwebsocket_create_context(&info);
if(nullptr != _wsContext)
{
_readyState = State::kStateConnecting;
std::string name;
for (int i = 0; _wsProtocols[i].callback != nullptr; ++i)
{
name += (_wsProtocols[i].name);
if (_wsProtocols[i+1].callback != nullptr) name += ", ";
}
_wsInstance = libwebsocket_client_connect(_wsContext, _host.c_str(), _port, _SSLConnection,
_path.c_str(), _host.c_str(), _host.c_str(),
name.c_str(), -1);
if(NULL == _wsInstance) {
WsMessage* msg = new WsMessage();
msg->what = WS_MSG_TO_UITHREAD_ERROR;
_readyState = State::kStateClosing;
_wsHelper->sendMessageToUIThread(msg);
}
}
}
void WebSocketOpcode_initialiseWebSocket(WebSocketOpcode *self, CSOUND *csound)
{
size_t argumentsCount = self->inputArgumentCount + self->outputArgumentCount;
self->webSocket = csound->Calloc(csound, sizeof(WebSocket));
self->webSocket->protocols =
csound->Calloc(csound, //Last protocol is null
sizeof(struct libwebsocket_protocols) * (argumentsCount + 1));
size_t argumentIndex = 0;
int i;
for (i = 0; i < self->outputArgumentCount; ++i, ++argumentIndex) {
self->webSocket->protocols[argumentIndex].name =
self->outputArguments[i].name;
self->webSocket->protocols[argumentIndex].callback = Websocket_callback;
self->webSocket->protocols[argumentIndex].per_session_data_size =
self->outputArguments[i].bytesCount;
}
for (i = 0; i < self->inputArgumentCount; ++i, ++argumentIndex) {
self->webSocket->protocols[argumentIndex].name = self->inputArguments[i].name;
self->webSocket->protocols[argumentIndex].callback = Websocket_callback;
self->webSocket->protocols[argumentIndex].per_session_data_size =
self->inputArguments[i].bytesCount;
}
self->webSocket->info.port = *self->arguments[self->outputArgumentCount];
self->webSocket->info.protocols = self->webSocket->protocols;
self->webSocket->info.extensions = libwebsocket_get_internal_extensions();
self->webSocket->info.gid = -1;
self->webSocket->info.uid = -1;
self->webSocket->info.user = self;
lws_set_log_level(LLL_ERR, NULL);
self->webSocket->context = libwebsocket_create_context(&self->webSocket->info);
self->webSocket->messageBuffer =
csound->Calloc(csound, LWS_SEND_BUFFER_PRE_PADDING +
(sizeof(char) * writeBufferBytesCount) +
LWS_SEND_BUFFER_POST_PADDING);
if (self->webSocket->context == NULL) {
csound->Die(csound,
Str("websocket: could not initialise websocket, Exiting"));
}
self->isRunning = true;
self->webSocket->processThread =
csound->CreateThread(WebSocketOpcode_processThread, self);
}
IWebSocketServer::IWebSocketServer(int port) {
curWebSocketServer = this;
lws_set_log_level(0, NULL);
// setup websocket context info
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = port;
info.protocols = protocols;
info.gid = -1;
info.uid = -1;
context = libwebsocket_create_context(&info);
if (context == NULL) throw "Websocket context create error";
}
void* HostProcess_WebSocketListener(void* stuff)
{
HostStuff* phoststuff=(HostStuff*)stuff;
struct libwebsocket_context *context;
int opts = 0;
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = WEB_PORT;
info.iface = 0;
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
info.gid = -1;
info.uid = -1;
info.options = opts;
info.user=phoststuff;
context = libwebsocket_create_context(&info);
if (context == NULL)
{
fprintf(stderr, "libwebsocket init failed\n");
return 0;
}
printf("starting server...\n");
// infinite loop, to end this server send SIGTERM. (CTRL+C)
while (1)
{
libwebsocket_service(context, 50);
// libwebsocket_service will process all waiting events with their
// callback functions and then wait 50 ms.
// (this is a single threaded webserver and this will keep our server
// from generating load while there are not requests to process)
}
libwebsocket_context_destroy(context);
return 0;
}
int init()
{
int n = 0;
//struct libwebsocket_context *context;
int opts = 0;
const char *iface = NULL;
int syslog_options = LOG_PID | LOG_PERROR;
unsigned int oldus = 0;
struct lws_context_creation_info info;
int debug_level = 7;
memset(&info, 0, sizeof info);
info.port = 9999;
signal(SIGINT, sighandler);
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
info.iface = iface;
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
closelog();
return 0;
}//main
//==============================================================================
// WsInput
//------------------------------------------------------------------------------
void WsInput::wsConnect(WsInput* wsinput) {
libwebsocket_context *context;
lws_context_creation_info info;
int debug_level = 7;
memset(&info,0,sizeof info);
info.port = 7681;
lws_set_log_level(debug_level,da);
lwsl_notice("libwebsockets chat server -\n");
libwebsocket_protocols protocols[] = {
{
"input",
WsInput::wsCallBackData,
0,
128
},
{NULL,NULL,0,0} /* terminator */
};
info.iface = nullptr;
info.protocols = protocols;
info.ssl_cert_filepath = nullptr;
info.ssl_private_key_filepath = nullptr;
info.gid = -1;
info.uid = -1;
info.options = 0;
info.user = nullptr;
context = libwebsocket_create_context(&info);
for(;;) {
int n = libwebsocket_service(context,10);
if(n >= 0 && wsinput->_isend) {
break;
}
}
libwebsocket_context_destroy(context);
wsinput->_isend = false;
}
int ws_start(short port){
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = port;
lwsl_notice("libwebsockets test server - "
"(C) Copyright 2010-2013 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
/*this is critical. otherwise UTF-8 error in client.*/
info.gid = -1;
info.uid = -1;
info.ka_time=100;
context = libwebsocket_create_context(&info);
if (!context){
lwsl_err("libwebsocket init failed\n");
return -1;
}
return 0;
}
int main(void)
{
// server url will be http://localhost:9000
int port = 9000;
const char *interface = NULL;
struct libwebsocket_context *context;
// we're not using ssl
const char *cert_path = NULL;
const char *key_path = NULL;
// no special options
int opts = 0;
// create libwebsocket context representing this server
context = libwebsocket_create_context(port, interface, protocols,
libwebsocket_internal_extensions,
cert_path, key_path, -1, -1, opts, NULL);
if (context == NULL)
{
fprintf(stderr, "libwebsocket init failed\n");
return -1;
}
printf("starting server...\n");
// infinite loop, to end this server send SIGTERM. (CTRL+C)
while (1)
{
libwebsocket_service(context, 50);
// libwebsocket_service will process all waiting events with their
// callback functions and then wait 50 ms.
// (this is a single threaded webserver and this will keep our server
// from generating load while there are not requests to process)
}
libwebsocket_context_destroy(context);
return 0;
}
void WebSocket::onSubThreadStarted()
{
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
/*
* create the websocket context. This tracks open connections and
* knows how to route any traffic and which protocol version to use,
* and if each connection is client or server side.
*
* For this client-only demo, we tell it to not listen on any port.
*/
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = _wsProtocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.gid = -1;
info.uid = -1;
info.user = (void*)this;
_wsContext = libwebsocket_create_context(&info);
if(NULL != _wsContext){
_readyState = kStateConnecting;
std::string name;
for (int i = 0; _wsProtocols[i].callback != NULL; ++i) {
name += (_wsProtocols[i].name);
if (_wsProtocols[i+1].callback != NULL)
{
name += ", ";
}
}
_wsInstance = libwebsocket_client_connect(_wsContext, _host.c_str(), _port, _SSLConnection,
_path.c_str(), _host.c_str(), _host.c_str(),
name.c_str(), -1);
}
}
WebSocketQueue::WebSocketQueue() :
messageSent_(false),
nextUniqueSessionId_(0),
maxSessionCount_(10)
{
//httpProtocol = &protocols[0];
//webSocketProtocol_ = &protocols_[0];
// server url will be ws://localhost:9000
int port = 9000;
lws_set_log_level(7, lwsl_emit_syslog);
// create connection struct
lws_context_creation_info info = { 0 };
info.port = port;
info.iface = nullptr;
info.protocols = protocols;
info.extensions = nullptr;
info.ssl_cert_filepath = nullptr;
info.ssl_private_key_filepath = nullptr;
info.options = 0;
info.user = this;
// create libwebsocket context representing this server
context_ = libwebsocket_create_context(&info);
// make sure it starts
if (context_ == NULL) {
GATEY_LOG("libwebsocket init failed");
//TODO: throw exception
return;
}
GATEY_LOG("starting server...");
}
int websocket_create(const char *addr, int port)
{
struct lws_context_creation_info info;
memset(&info, 0, sizeof(info));
info.port = port;
info.iface = addr;
info.protocols = protocols;
info.gid = -1;
info.uid = -1;
// find free context
int first_free = -1;
for(int i = 0; i < WS_CONTEXTS; i++)
{
if(contexts[i].context == NULL)
{
first_free = i;
break;
}
}
if(first_free == -1)
return -1;
context_data *ctx_data = &contexts[first_free];
info.user = (void *)ctx_data;
ctx_data->context = libwebsocket_create_context(&info);
if(ctx_data->context == NULL)
{
return -1;
}
memset(ctx_data->port_map, 0, sizeof(ctx_data->port_map));
ctx_data->recv_buffer.Init();
ctx_data->last_used_port = 0;
return first_free;
}
bool FNetworkFileServerHttp::Init()
{
// setup log level.
#if UE_BUILD_DEBUG
lws_set_log_level( LLL_ERR | LLL_WARN | LLL_NOTICE | LLL_DEBUG , libwebsocket_debugLog);
#endif
struct lws_context_creation_info Info;
memset(&Info,0,sizeof(lws_context_creation_info));
// look up libwebsockets.h for details.
Info.port = Port;
// we listen on all available interfaces.
Info.iface = NULL;
// serve only the http protocols.
Info.protocols = Protocols;
// no extensions
Info.extensions = NULL;
Info.gid = -1;
Info.uid = -1;
Info.options = 0;
// tack on this object.
Info.user = this;
Context = libwebsocket_create_context(&Info);
Port = Info.port;
if (Context == NULL) {
UE_LOG(LogFileServer, Fatal, TEXT(" Could not create a libwebsocket content for port : %d"), Port);
return false;
}
Ready.Set(true);
return true;
}
//--------------------------------------------------------------
bool Client::connect ( ClientOptions options ){
ofLog( OF_LOG_VERBOSE, "[ofxLibwebsockets] connect: "+options.host+":"+ofToString(options.port)+options.channel+":"+ofToString(options.bUseSSL) );
address = options.host;
port = options.port;
channel = options.channel;
defaultOptions = options;
bShouldReconnect = defaultOptions.reconnect;
/*
enum lws_log_levels {
LLL_ERR = 1 << 0,
LLL_WARN = 1 << 1,
LLL_NOTICE = 1 << 2,
LLL_INFO = 1 << 3,
LLL_DEBUG = 1 << 4,
LLL_PARSER = 1 << 5,
LLL_HEADER = 1 << 6,
LLL_EXT = 1 << 7,
LLL_CLIENT = 1 << 8,
LLL_LATENCY = 1 << 9,
LLL_COUNT = 10
};
*/
lws_set_log_level(LLL_ERR, NULL);
// set up default protocols
struct libwebsocket_protocols null_protocol = { NULL, NULL, 0 };
// setup the default protocol (the one that works when you do addListener())
registerProtocol( options.protocol, clientProtocol );
lws_protocols.clear();
for (int i=0; i<protocols.size(); ++i)
{
struct libwebsocket_protocols lws_protocol = {
( protocols[i].first == "NULL" ? NULL : protocols[i].first.c_str() ),
lws_client_callback,
protocols[i].second->rx_buffer_size,
protocols[i].second->rx_buffer_size
};
lws_protocols.push_back(lws_protocol);
}
lws_protocols.push_back(null_protocol);
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = &lws_protocols[0];
info.extensions = libwebsocket_get_internal_extensions();
info.gid = -1;
info.uid = -1;
if ( options.ka_time != 0 ){
ofLogVerbose()<<"[ofxLibwebsockets] Setting timeout "<<options.ka_time;
info.ka_time = options.ka_time;
info.ka_probes = options.ka_probes;
info.ka_interval = options.ka_interval;
}
context = libwebsocket_create_context(&info);
//context = libwebsocket_create_context(CONTEXT_PORT_NO_LISTEN, NULL,
// &lws_protocols[0], libwebsocket_internal_extensions,
// NULL, NULL, /*NULL,*/ -1, -1, 0, NULL);
if (context == NULL){
ofLogError() << "[ofxLibwebsockets] libwebsocket init failed";
return false;
} else {
ofLogVerbose() << "[ofxLibwebsockets] libwebsocket init success";
string host = options.host +":"+ ofToString( options.port );
// register with or without a protocol
if ( options.protocol == "NULL"){
lwsconnection = libwebsocket_client_connect( context,
options.host.c_str(), options.port, (options.bUseSSL ? 2 : 0 ),
options.channel.c_str(), host.c_str(), host.c_str(), NULL, options.version);
} else {
lwsconnection = libwebsocket_client_connect( context,
options.host.c_str(), options.port, (options.bUseSSL ? 2 : 0 ),
options.channel.c_str(), host.c_str(), host.c_str(), options.protocol.c_str(), options.version);
}
if ( lwsconnection == NULL ){
ofLogError() << "[ofxLibwebsockets] client connection failed";
return false;
} else {
connection = new Connection( (Reactor*) &context, &clientProtocol );
connection->ws = lwsconnection;
ofLogVerbose() << "[ofxLibwebsockets] Connection successfully created. Connecting.";
startThread();
return true;
}
}
}
FWebSocket::FWebSocket(
const FInternetAddr& ServerAddress
)
:IsServerSide(false)
{
#if !PLATFORM_HTML5_BROWSER
#if !UE_BUILD_SHIPPING
lws_set_log_level(LLL_ERR | LLL_WARN | LLL_NOTICE | LLL_DEBUG | LLL_INFO, libwebsocket_debugLogS);
#endif
Protocols = new libwebsocket_protocols[3];
FMemory::Memzero(Protocols, sizeof(libwebsocket_protocols) * 3);
Protocols[0].name = "binary";
Protocols[0].callback = FWebSocket::unreal_networking_client;
Protocols[0].per_session_data_size = 0;
Protocols[0].rx_buffer_size = 10 * 1024 * 1024;
Protocols[1].name = nullptr;
Protocols[1].callback = nullptr;
Protocols[1].per_session_data_size = 0;
struct lws_context_creation_info Info;
memset(&Info, 0, sizeof Info);
Info.port = CONTEXT_PORT_NO_LISTEN;
Info.protocols = &Protocols[0];
Info.gid = -1;
Info.uid = -1;
Info.user = this;
Context = libwebsocket_create_context(&Info);
check(Context);
Wsi = libwebsocket_client_connect_extended
(Context,
TCHAR_TO_ANSI(*ServerAddress.ToString(false)),
ServerAddress.GetPort(),
false, "/", TCHAR_TO_ANSI(*ServerAddress.ToString(false)), TCHAR_TO_ANSI(*ServerAddress.ToString(false)), Protocols[1].name, -1,this);
check(Wsi);
#endif
#if PLATFORM_HTML5_BROWSER
struct sockaddr_in addr;
int res;
SockFd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (SockFd == -1) {
UE_LOG(LogHTML5Networking, Error, TEXT("Socket creationg failed "));
}
else
{
UE_LOG(LogHTML5Networking, Warning, TEXT(" Socked %d created "), SockFd);
}
fcntl(SockFd, F_SETFL, O_NONBLOCK);
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(ServerAddress.GetPort());
if (inet_pton(AF_INET, TCHAR_TO_ANSI(*ServerAddress.ToString(false)), &addr.sin_addr) != 1) {
UE_LOG(LogHTML5Networking, Warning, TEXT("inet_pton failed "));
return;
}
int Ret = connect(SockFd, (struct sockaddr *)&addr, sizeof(addr));
UE_LOG(LogHTML5Networking, Warning, TEXT(" Connect socket returned %d"), Ret);
#endif
}
/* Transport implementation */
int janus_websockets_init(janus_transport_callbacks *callback, const char *config_path) {
if(g_atomic_int_get(&stopping)) {
/* Still stopping from before */
return -1;
}
if(callback == NULL || config_path == NULL) {
/* Invalid arguments */
return -1;
}
/* This is the callback we'll need to invoke to contact the gateway */
gateway = callback;
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
JANUS_LOG(LOG_INFO, "libwebsockets >= 1.6 available, using new API\n");
#else
JANUS_LOG(LOG_INFO, "libwebsockets < 1.6 available, using old API\n");
#endif
/* Read configuration */
char filename[255];
g_snprintf(filename, 255, "%s/%s.cfg", config_path, JANUS_WEBSOCKETS_PACKAGE);
JANUS_LOG(LOG_VERB, "Configuration file: %s\n", filename);
janus_config *config = janus_config_parse(filename);
if(config != NULL) {
janus_config_print(config);
/* Handle configuration */
janus_config_item *item = janus_config_get_item_drilldown(config, "general", "json");
if(item && item->value) {
/* Check how we need to format/serialize the JSON output */
if(!strcasecmp(item->value, "indented")) {
/* Default: indented, we use three spaces for that */
json_format = JSON_INDENT(3) | JSON_PRESERVE_ORDER;
} else if(!strcasecmp(item->value, "plain")) {
/* Not indented and no new lines, but still readable */
json_format = JSON_INDENT(0) | JSON_PRESERVE_ORDER;
} else if(!strcasecmp(item->value, "compact")) {
/* Compact, so no spaces between separators */
json_format = JSON_COMPACT | JSON_PRESERVE_ORDER;
} else {
JANUS_LOG(LOG_WARN, "Unsupported JSON format option '%s', using default (indented)\n", item->value);
json_format = JSON_INDENT(3) | JSON_PRESERVE_ORDER;
}
}
/* Check if we need to send events to handlers */
janus_config_item *events = janus_config_get_item_drilldown(config, "general", "events");
if(events != NULL && events->value != NULL)
notify_events = janus_is_true(events->value);
if(!notify_events && callback->events_is_enabled()) {
JANUS_LOG(LOG_WARN, "Notification of events to handlers disabled for %s\n", JANUS_WEBSOCKETS_NAME);
}
item = janus_config_get_item_drilldown(config, "general", "ws_logging");
if(item && item->value) {
ws_log_level = atoi(item->value);
if(ws_log_level < 0)
ws_log_level = 0;
}
JANUS_LOG(LOG_VERB, "libwebsockets logging: %d\n", ws_log_level);
lws_set_log_level(ws_log_level, NULL);
old_wss = NULL;
janus_mutex_init(&old_wss_mutex);
/* Any ACL for either the Janus or Admin API? */
item = janus_config_get_item_drilldown(config, "general", "ws_acl");
if(item && item->value) {
gchar **list = g_strsplit(item->value, ",", -1);
gchar *index = list[0];
if(index != NULL) {
int i=0;
while(index != NULL) {
if(strlen(index) > 0) {
JANUS_LOG(LOG_INFO, "Adding '%s' to the Janus API allowed list...\n", index);
janus_websockets_allow_address(g_strdup(index), FALSE);
}
i++;
index = list[i];
}
}
g_strfreev(list);
list = NULL;
}
item = janus_config_get_item_drilldown(config, "admin", "admin_ws_acl");
if(item && item->value) {
gchar **list = g_strsplit(item->value, ",", -1);
gchar *index = list[0];
if(index != NULL) {
int i=0;
while(index != NULL) {
if(strlen(index) > 0) {
JANUS_LOG(LOG_INFO, "Adding '%s' to the Admin/monitor allowed list...\n", index);
janus_websockets_allow_address(g_strdup(index), TRUE);
}
i++;
index = list[i];
}
}
g_strfreev(list);
list = NULL;
}
/* Setup the Janus API WebSockets server(s) */
item = janus_config_get_item_drilldown(config, "general", "ws");
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "WebSockets server disabled\n");
} else {
int wsport = 8188;
item = janus_config_get_item_drilldown(config, "general", "ws_port");
if(item && item->value)
wsport = atoi(item->value);
char *interface = NULL;
item = janus_config_get_item_drilldown(config, "general", "ws_interface");
if(item && item->value)
interface = (char *)item->value;
char *ip = NULL;
item = janus_config_get_item_drilldown(config, "general", "ws_ip");
if(item && item->value) {
ip = (char *)item->value;
char *iface = janus_websockets_get_interface_name(ip);
if(iface == NULL) {
JANUS_LOG(LOG_WARN, "No interface associated with %s? Falling back to no interface...\n", ip);
}
ip = iface;
}
/* Prepare context */
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = wsport;
info.iface = ip ? ip : interface;
info.protocols = wss_protocols;
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
info.extensions = NULL;
#else
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
info.gid = -1;
info.uid = -1;
info.options = 0;
/* Create the WebSocket context */
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
wss = lws_create_context(&info);
#else
wss = libwebsocket_create_context(&info);
#endif
if(wss == NULL) {
JANUS_LOG(LOG_FATAL, "Error initializing libwebsockets...\n");
} else {
JANUS_LOG(LOG_INFO, "WebSockets server started (port %d)...\n", wsport);
}
g_free(ip);
}
item = janus_config_get_item_drilldown(config, "general", "wss");
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "Secure WebSockets server disabled\n");
} else {
int wsport = 8989;
item = janus_config_get_item_drilldown(config, "general", "wss_port");
if(item && item->value)
wsport = atoi(item->value);
char *interface = NULL;
item = janus_config_get_item_drilldown(config, "general", "wss_interface");
if(item && item->value)
interface = (char *)item->value;
char *ip = NULL;
item = janus_config_get_item_drilldown(config, "general", "wss_ip");
if(item && item->value) {
ip = (char *)item->value;
char *iface = janus_websockets_get_interface_name(ip);
if(iface == NULL) {
JANUS_LOG(LOG_WARN, "No interface associated with %s? Falling back to no interface...\n", ip);
}
ip = iface;
}
item = janus_config_get_item_drilldown(config, "certificates", "cert_pem");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing certificate/key path\n");
} else {
char *server_pem = (char *)item->value;
char *server_key = (char *)item->value;
item = janus_config_get_item_drilldown(config, "certificates", "cert_key");
if(item && item->value)
server_key = (char *)item->value;
JANUS_LOG(LOG_VERB, "Using certificates:\n\t%s\n\t%s\n", server_pem, server_key);
/* Prepare secure context */
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = wsport;
info.iface = ip ? ip : interface;
info.protocols = swss_protocols;
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
info.extensions = NULL;
#else
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.ssl_cert_filepath = server_pem;
info.ssl_private_key_filepath = server_key;
info.gid = -1;
info.uid = -1;
#if LWS_LIBRARY_VERSION_MAJOR >= 2
info.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
#else
info.options = 0;
#endif
/* Create the secure WebSocket context */
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
swss = lws_create_context(&info);
#else
swss = libwebsocket_create_context(&info);
#endif
if(swss == NULL) {
JANUS_LOG(LOG_FATAL, "Error initializing libwebsockets...\n");
} else {
JANUS_LOG(LOG_INFO, "Secure WebSockets server started (port %d)...\n", wsport);
}
g_free(ip);
}
}
/* Do the same for the Admin API, if enabled */
item = janus_config_get_item_drilldown(config, "admin", "admin_ws");
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "Admin WebSockets server disabled\n");
} else {
int wsport = 7188;
item = janus_config_get_item_drilldown(config, "admin", "admin_ws_port");
if(item && item->value)
wsport = atoi(item->value);
char *interface = NULL;
item = janus_config_get_item_drilldown(config, "admin", "admin_ws_interface");
if(item && item->value)
interface = (char *)item->value;
char *ip = NULL;
item = janus_config_get_item_drilldown(config, "admin", "admin_ws_ip");
if(item && item->value) {
ip = (char *)item->value;
char *iface = janus_websockets_get_interface_name(ip);
if(iface == NULL) {
JANUS_LOG(LOG_WARN, "No interface associated with %s? Falling back to no interface...\n", ip);
}
ip = iface;
}
/* Prepare context */
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = wsport;
info.iface = ip ? ip : interface;
info.protocols = admin_wss_protocols;
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
info.extensions = NULL;
#else
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
info.gid = -1;
info.uid = -1;
info.options = 0;
/* Create the WebSocket context */
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
admin_wss = lws_create_context(&info);
#else
admin_wss = libwebsocket_create_context(&info);
#endif
if(admin_wss == NULL) {
JANUS_LOG(LOG_FATAL, "Error initializing libwebsockets...\n");
} else {
JANUS_LOG(LOG_INFO, "Admin WebSockets server started (port %d)...\n", wsport);
}
g_free(ip);
}
item = janus_config_get_item_drilldown(config, "admin", "admin_wss");
if(!item || !item->value || !janus_is_true(item->value)) {
JANUS_LOG(LOG_WARN, "Secure Admin WebSockets server disabled\n");
} else {
int wsport = 7989;
item = janus_config_get_item_drilldown(config, "admin", "admin_wss_port");
if(item && item->value)
wsport = atoi(item->value);
char *interface = NULL;
item = janus_config_get_item_drilldown(config, "admin", "admin_wss_interface");
if(item && item->value)
interface = (char *)item->value;
char *ip = NULL;
item = janus_config_get_item_drilldown(config, "admin", "admin_wss_ip");
if(item && item->value) {
ip = (char *)item->value;
char *iface = janus_websockets_get_interface_name(ip);
if(iface == NULL) {
JANUS_LOG(LOG_WARN, "No interface associated with %s? Falling back to no interface...\n", ip);
}
ip = iface;
}
item = janus_config_get_item_drilldown(config, "certificates", "cert_pem");
if(!item || !item->value) {
JANUS_LOG(LOG_FATAL, "Missing certificate/key path\n");
} else {
char *server_pem = (char *)item->value;
char *server_key = (char *)item->value;
item = janus_config_get_item_drilldown(config, "certificates", "cert_key");
if(item && item->value)
server_key = (char *)item->value;
JANUS_LOG(LOG_VERB, "Using certificates:\n\t%s\n\t%s\n", server_pem, server_key);
/* Prepare secure context */
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = wsport;
info.iface = ip ? ip : interface;
info.protocols = admin_swss_protocols;
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
info.extensions = NULL;
#else
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.ssl_cert_filepath = server_pem;
info.ssl_private_key_filepath = server_key;
info.gid = -1;
info.uid = -1;
#if LWS_LIBRARY_VERSION_MAJOR >= 2
info.options = LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
#else
info.options = 0;
#endif
/* Create the secure WebSocket context */
#ifdef HAVE_LIBWEBSOCKETS_NEWAPI
admin_swss = lws_create_context(&info);
#else
admin_swss = libwebsocket_create_context(&info);
#endif
if(admin_swss == NULL) {
JANUS_LOG(LOG_FATAL, "Error initializing libwebsockets...\n");
} else {
JANUS_LOG(LOG_INFO, "Secure Admin WebSockets server started (port %d)...\n", wsport);
}
g_free(ip);
}
}
}
janus_config_destroy(config);
config = NULL;
if(!wss && !swss && !admin_wss && !admin_swss) {
JANUS_LOG(LOG_FATAL, "No WebSockets server started, giving up...\n");
return -1; /* No point in keeping the plugin loaded */
}
wss_janus_api_enabled = wss || swss;
wss_admin_api_enabled = admin_wss || admin_swss;
GError *error = NULL;
/* Start the WebSocket service threads */
if(wss != NULL) {
wss_thread = g_thread_try_new("ws thread", &janus_websockets_thread, wss, &error);
if(!wss_thread) {
g_atomic_int_set(&initialized, 0);
JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the WebSockets thread...\n", error->code, error->message ? error->message : "??");
return -1;
}
}
if(swss != NULL) {
swss_thread = g_thread_try_new("sws thread", &janus_websockets_thread, swss, &error);
if(!swss_thread) {
g_atomic_int_set(&initialized, 0);
JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Secure WebSockets thread...\n", error->code, error->message ? error->message : "??");
return -1;
}
}
if(admin_wss != NULL) {
admin_wss_thread = g_thread_try_new("admin ws thread", &janus_websockets_thread, admin_wss, &error);
if(!admin_wss_thread) {
g_atomic_int_set(&initialized, 0);
JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Admin WebSockets thread...\n", error->code, error->message ? error->message : "??");
return -1;
}
}
if(admin_swss != NULL) {
admin_swss_thread = g_thread_try_new("admin sws thread", &janus_websockets_thread, admin_swss, &error);
if(!admin_swss_thread) {
g_atomic_int_set(&initialized, 0);
JANUS_LOG(LOG_ERR, "Got error %d (%s) trying to launch the Secure Admin WebSockets thread...\n", error->code, error->message ? error->message : "??");
return -1;
}
}
/* Done */
g_atomic_int_set(&initialized, 1);
JANUS_LOG(LOG_INFO, "%s initialized!\n", JANUS_WEBSOCKETS_NAME);
return 0;
}
struct libwebsocket_context * bmx_libwebsockets_create_context(BBObject * handle, struct lws_context_creation_info * info) {
info->user = handle;
info->extensions = libwebsocket_get_internal_extensions();
return libwebsocket_create_context(info);
}
int main(int argc, char **argv)
{
int n, gid = -1, uid = -1;
int option_index = 0;
unsigned int oldus = 0;
struct libwebsocket_context *context;
struct lws_context_creation_info info;
const char *cert_filepath = NULL;
const char *private_key_filepath = NULL;
const char *iface = NULL;
atexit(bye);
memset(&info, 0, sizeof info);
info.port = 8080;
strcpy(mpd_host, "127.0.0.1");
mpd_port = 6600;
lws_set_log_level(LLL_ERR | LLL_WARN, NULL);
static struct option long_options[] = {
{"host", required_argument, 0, 'h'},
{"port", required_argument, 0, 'p'},
{"interface", required_argument, 0, 'i'},
{"webport", required_argument, 0, 'w'},
{"resourcepath", required_argument, 0, 'r'},
{"ssl_cert", required_argument, 0, 'c'},
{"ssl_key", required_argument, 0, 'k'},
{"gid", required_argument, 0, 'g'},
{"uid", required_argument, 0, 'u'},
{"verbose", optional_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 0 },
{0, 0, 0, 0 }
};
while((n = getopt_long(argc, argv, "h:p:i:w:r:c:k:g:u:v::V",
long_options, &option_index)) != -1) {
switch (n) {
case 'h':
strncpy(mpd_host, optarg, sizeof(mpd_host));
break;
case 'p':
mpd_port = atoi(optarg);
case 'i':
iface = optarg;
break;
case 'w':
info.port = atoi(optarg);
break;
case 'r':
resource_path = optarg;
break;
case 'c':
cert_filepath = optarg;
break;
case 'k':
private_key_filepath = optarg;
break;
case 'g':
gid = atoi(optarg);
break;
case 'u':
uid = atoi(optarg);
break;
case 'v':
if(optarg)
lws_set_log_level(strtol(optarg, NULL, 10), NULL);
else
lws_set_log_level(LLL_ERR | LLL_WARN |
LLL_NOTICE | LLL_INFO, NULL);
break;
case 'V':
fprintf(stdout, "ympd %d.%d.%d\n"
"Copyright (C) 2014 Andrew Karpow <*****@*****.**>\n"
"Resource Path: "LOCAL_RESOURCE_PATH"\n"
"built " __DATE__ " "__TIME__ " ("__VERSION__")\n",
YMPD_VERSION_MAJOR, YMPD_VERSION_MINOR, YMPD_VERSION_PATCH);
return EXIT_SUCCESS;
break;
default:
fprintf(stderr, "Usage: %s [OPTION]...\n\n"
"\t-h, --host <host>\t\tconnect to mpd at host [localhost]\n"
"\t-p, --port <port>\t\tconnect to mpd at port [6600]\n"
"\t-i, --interface <interface>\tlisten interface for webserver [all]\n"
"\t-w, --webport <port>\t\tlisten port for webserver [8080]\n"
"\t-r, --resourcepath <path>\tresourcepath for webserver [" LOCAL_RESOURCE_PATH "]\n"
"\t-c, --ssl_cert <filepath>\tssl certificate ssl_private_key_filepath\n"
"\t-k, --ssl_key <filepath>\tssl private key filepath\n"
"\t-u, --uid <id>\t\t\tuser-id after socket bind\n"
"\t-g, --gid <id>\t\t\tgroup-id after socket bind\n"
"\t-v, --verbose[<level>]\t\tverbosity level\n"
"\t-V, --version\t\t\tget version\n"
"\t--help\t\t\t\tthis help\n"
, argv[0]);
return EXIT_FAILURE;
}
}
if(cert_filepath != NULL && private_key_filepath == NULL) {
lwsl_err("private key filepath needed\n");
return EXIT_FAILURE;
}
if(private_key_filepath != NULL && cert_filepath == NULL) {
lwsl_err("public cert filepath needed\n");
return EXIT_FAILURE;
}
info.ssl_cert_filepath = cert_filepath;
info.ssl_private_key_filepath = private_key_filepath;
info.iface = iface;
info.protocols = protocols;
info.extensions = libwebsocket_get_internal_extensions();
info.gid = gid;
info.uid = uid;
info.options = 0;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return EXIT_FAILURE;
}
n = 0;
while (n >= 0 && !force_exit) {
struct timeval tv;
gettimeofday(&tv, NULL);
/*
* This provokes the LWS_CALLBACK_SERVER_WRITEABLE for every
* live websocket connection using the DUMB_INCREMENT protocol,
* as soon as it can take more packets (usually immediately)
*/
if (((unsigned int)tv.tv_usec - oldus) > 1000 * 500) {
mpd_loop();
libwebsocket_callback_on_writable_all_protocol(&protocols[1]);
oldus = tv.tv_usec;
}
n = libwebsocket_service(context, 50);
}
libwebsocket_context_destroy(context);
return 0;
}
int main(int argc, char **argv)
{
int n = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
int opts = 0;
char interface_name[128] = "";
const char *interface = NULL;
int syslog_options = LOG_PID | LOG_PERROR;
int client = 0;
int listen_port;
struct lws_context_creation_info info;
#ifndef LWS_NO_CLIENT
char address[256];
int rate_us = 250000;
unsigned int oldus = 0;
struct libwebsocket *wsi;
#endif
int debug_level = 7;
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
memset(&info, 0, sizeof info);
#ifndef LWS_NO_CLIENT
lwsl_notice("Built to support client operations\n");
#endif
#ifndef LWS_NO_SERVER
lwsl_notice("Built to support server operations\n");
#endif
while (n >= 0) {
n = getopt_long(argc, argv, "i:hsp:d:D"
#ifndef LWS_NO_CLIENT
"c:r:"
#endif
, options, NULL);
if (n < 0)
continue;
switch (n) {
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
syslog_options &= ~LOG_PERROR;
break;
#endif
#ifndef LWS_NO_CLIENT
case 'c':
client = 1;
strcpy(address, optarg);
port = 80;
break;
case 'r':
rate_us = atoi(optarg) * 1000;
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1; /* 1 = take care about cert verification, 2 = allow anything */
break;
case 'p':
port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
interface = interface_name;
break;
case '?':
case 'h':
fprintf(stderr, "Usage: libwebsockets-test-echo "
"[--ssl] "
#ifndef LWS_NO_CLIENT
"[--client <remote ads>] "
"[--ratems <ms>] "
#endif
"[--port=<p>] "
"[-d <log bitfield>]\n");
exit(1);
}
}
#ifndef LWS_NO_DAEMONIZE
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
if (!client && daemonize && lws_daemonize("/tmp/.lwstecho-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets echo test - "
"(C) Copyright 2010-2013 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
#ifndef LWS_NO_CLIENT
if (client) {
lwsl_notice("Running in client mode\n");
listen_port = CONTEXT_PORT_NO_LISTEN;
if (use_ssl)
use_ssl = 2;
} else {
#endif
#ifndef LWS_NO_SERVER
lwsl_notice("Running in server mode\n");
listen_port = port;
#endif
#ifndef LWS_NO_CLIENT
}
#endif
info.port = listen_port;
info.iface = interface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
if (use_ssl && !client) {
info.ssl_cert_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
info.ssl_private_key_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem";
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
#ifndef LWS_NO_CLIENT
if (client) {
lwsl_notice("Client connecting to %s:%u....\n", address, port);
/* we are in client mode */
wsi = libwebsocket_client_connect(context, address,
port, use_ssl, "/", address,
"origin", NULL, -1);
if (!wsi) {
lwsl_err("Client failed to connect to %s:%u\n", address, port);
goto bail;
}
lwsl_notice("Client connected to %s:%u\n", address, port);
}
#endif
signal(SIGINT, sighandler);
n = 0;
while (n >= 0 && !force_exit) {
#ifndef LWS_NO_CLIENT
struct timeval tv;
if (client) {
gettimeofday(&tv, NULL);
if (((unsigned int)tv.tv_usec - oldus) > rate_us) {
libwebsocket_callback_on_writable_all_protocol(&protocols[0]);
oldus = tv.tv_usec;
}
}
#endif
n = libwebsocket_service(context, 10);
}
#ifndef LWS_NO_CLIENT
bail:
#endif
libwebsocket_context_destroy(context);
lwsl_notice("libwebsockets-test-echo exited cleanly\n");
closelog();
return 0;
}
int main(int argc, char **argv)
{
char cert_path[1024];
char key_path[1024];
int n = 0;
int use_ssl = 0;
int opts = 0;
char interface_name[128] = "";
const char *iface = NULL;
#ifndef WIN32
int syslog_options = LOG_PID | LOG_PERROR;
#endif
unsigned int oldus = 0;
struct lws_context_creation_info info;
int debug_level = 7;
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
memset(&info, 0, sizeof info);
info.port = 7681;
while (n >= 0) {
n = getopt_long(argc, argv, "eci:hsap:d:Dr:", options, NULL);
if (n < 0)
continue;
switch (n) {
case 'e':
opts |= LWS_SERVER_OPTION_LIBEV;
break;
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
#ifndef WIN32
syslog_options &= ~LOG_PERROR;
#endif
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1;
break;
case 'a':
opts |= LWS_SERVER_OPTION_ALLOW_NON_SSL_ON_SSL_PORT;
break;
case 'p':
info.port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
iface = interface_name;
break;
case 'c':
close_testing = 1;
fprintf(stderr, " Close testing mode -- closes on "
"client after 50 dumb increments"
"and suppresses lws_mirror spam\n");
break;
case 'r':
resource_path = optarg;
printf("Setting resource path to \"%s\"\n", resource_path);
break;
case 'h':
fprintf(stderr, "Usage: test-server "
"[--port=<p>] [--ssl] "
"[-d <log bitfield>] "
"[--resource_path <path>]\n");
exit(1);
}
}
#if !defined(LWS_NO_DAEMONIZE) && !defined(WIN32)
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
if (daemonize && lws_daemonize("/tmp/.lwsts-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
signal(SIGINT, sighandler);
#ifndef WIN32
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
#endif
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets test server - "
"(C) Copyright 2010-2013 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
#ifdef EXTERNAL_POLL
max_poll_elements = getdtablesize();
pollfds = malloc(max_poll_elements * sizeof (struct pollfd));
fd_lookup = malloc(max_poll_elements * sizeof (int));
if (pollfds == NULL || fd_lookup == NULL) {
lwsl_err("Out of memory pollfds=%d\n", max_poll_elements);
return -1;
}
#endif
info.iface = iface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
if (!use_ssl) {
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
} else {
if (strlen(resource_path) > sizeof(cert_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(cert_path, "%s/libwebsockets-test-server.pem",
resource_path);
if (strlen(resource_path) > sizeof(key_path) - 32) {
lwsl_err("resource path too long\n");
return -1;
}
sprintf(key_path, "%s/libwebsockets-test-server.key.pem",
resource_path);
info.ssl_cert_filepath = cert_path;
info.ssl_private_key_filepath = key_path;
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
n = 0;
while (n >= 0 && !force_exit) {
struct timeval tv;
gettimeofday(&tv, NULL);
/*
* This provokes the LWS_CALLBACK_SERVER_WRITEABLE for every
* live websocket connection using the DUMB_INCREMENT protocol,
* as soon as it can take more packets (usually immediately)
*/
if (((unsigned int)tv.tv_usec - oldus) > 50000) {
libwebsocket_callback_on_writable_all_protocol(&protocols[PROTOCOL_DUMB_INCREMENT]);
oldus = tv.tv_usec;
}
#ifdef EXTERNAL_POLL
/*
* this represents an existing server's single poll action
* which also includes libwebsocket sockets
*/
n = poll(pollfds, count_pollfds, 50);
if (n < 0)
continue;
if (n)
for (n = 0; n < count_pollfds; n++)
if (pollfds[n].revents)
/*
* returns immediately if the fd does not
* match anything under libwebsockets
* control
*/
if (libwebsocket_service_fd(context,
&pollfds[n]) < 0)
goto done;
#else
/*
* If libwebsockets sockets are all we care about,
* you can use this api which takes care of the poll()
* and looping through finding who needed service.
*
* If no socket needs service, it'll return anyway after
* the number of ms in the second argument.
*/
n = libwebsocket_service(context, 50);
#endif
}
#ifdef EXTERNAL_POLL
done:
#endif
libwebsocket_context_destroy(context);
lwsl_notice("libwebsockets-test-server exited cleanly\n");
#ifndef WIN32
closelog();
#endif
return 0;
}
int main(int argc, char **argv)
{
int n = 0;
const char *cert_path =
LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
const char *key_path =
LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem";
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + 1024 +
LWS_SEND_BUFFER_POST_PADDING];
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
int opts = 0;
char interface_name[128] = "";
const char *interface = NULL;
#ifdef LWS_NO_FORK
unsigned int oldus = 0;
#endif
fprintf(stderr, "libwebsockets test server\n"
"(C) Copyright 2010-2011 Andy Green <*****@*****.**> "
"licensed under LGPL2.1\n");
while (n >= 0) {
n = getopt_long(argc, argv, "ci:khsp:", options, NULL);
if (n < 0)
continue;
switch (n) {
case 's':
use_ssl = 1;
break;
case 'k':
opts = LWS_SERVER_OPTION_DEFEAT_CLIENT_MASK;
break;
case 'p':
port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
interface = interface_name;
break;
case 'c':
close_testing = 1;
fprintf(stderr, " Close testing mode -- closes on "
"client after 50 dumb increments"
"and suppresses lws_mirror spam\n");
break;
case 'h':
fprintf(stderr, "Usage: test-server "
"[--port=<p>] [--ssl]\n");
exit(1);
}
}
if (!use_ssl)
cert_path = key_path = NULL;
context = libwebsocket_create_context(port, interface, protocols,
libwebsocket_internal_extensions,
cert_path, key_path, -1, -1, opts);
if (context == NULL) {
fprintf(stderr, "libwebsocket init failed\n");
return -1;
}
buf[LWS_SEND_BUFFER_PRE_PADDING] = 'x';
#ifdef LWS_NO_FORK
/*
* This example shows how to work with no forked service loop
*/
fprintf(stderr, " Using no-fork service loop\n");
n = 0;
while (n >= 0) {
struct timeval tv;
gettimeofday(&tv, NULL);
/*
* This broadcasts to all dumb-increment-protocol connections
* at 20Hz.
*
* We're just sending a character 'x', in these examples the
* callbacks send their own per-connection content.
*
* You have to send something with nonzero length to get the
* callback actions delivered.
*
* We take care of pre-and-post padding allocation.
*/
if (((unsigned int)tv.tv_usec - oldus) > 50000) {
libwebsockets_broadcast(
&protocols[PROTOCOL_DUMB_INCREMENT],
&buf[LWS_SEND_BUFFER_PRE_PADDING], 1);
oldus = tv.tv_usec;
}
/*
* This example server does not fork or create a thread for
* websocket service, it all runs in this single loop. So,
* we have to give the websockets an opportunity to service
* "manually".
*
* If no socket is needing service, the call below returns
* immediately and quickly. Negative return means we are
* in process of closing
*/
n = libwebsocket_service(context, 50);
}
#else
/*
* This example shows how to work with the forked websocket service loop
*/
fprintf(stderr, " Using forked service loop\n");
/*
* This forks the websocket service action into a subprocess so we
* don't have to take care about it.
*/
n = libwebsockets_fork_service_loop(context);
if (n < 0) {
fprintf(stderr, "Unable to fork service loop %d\n", n);
return 1;
}
while (1) {
usleep(50000);
/*
* This broadcasts to all dumb-increment-protocol connections
* at 20Hz.
*
* We're just sending a character 'x', in these examples the
* callbacks send their own per-connection content.
*
* You have to send something with nonzero length to get the
* callback actions delivered.
*
* We take care of pre-and-post padding allocation.
*/
libwebsockets_broadcast(&protocols[PROTOCOL_DUMB_INCREMENT],
&buf[LWS_SEND_BUFFER_PRE_PADDING], 1);
}
#endif
libwebsocket_context_destroy(context);
return 0;
}
int main(int argc, char **argv)
{
int n = 0;
int use_ssl = 0;
struct libwebsocket_context *context;
int opts = 0;
char interface_name[128] = "";
const char *iface = NULL;
#ifndef WIN32
int syslog_options = LOG_PID | LOG_PERROR;
#endif
unsigned int oldus = 0;
struct lws_context_creation_info info;
int debug_level = 7;
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
memset(&info, 0, sizeof info);
info.port = 7681;
while (n >= 0) {
n = getopt_long(argc, argv, "ci:hsp:d:D", options, NULL);
if (n < 0)
continue;
switch (n) {
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
#ifndef WIN32
syslog_options &= ~LOG_PERROR;
#endif
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1;
break;
case 'p':
info.port = atoi(optarg);
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
iface = interface_name;
break;
case 'c':
close_testing = 1;
fprintf(stderr, " Close testing mode -- closes on "
"client after 50 dumb increments"
"and suppresses lws_mirror spam\n");
break;
case 'h':
fprintf(stderr, "Usage: test-server "
"[--port=<p>] [--ssl] "
"[-d <log bitfield>]\n");
exit(1);
}
}
#if !defined(LWS_NO_DAEMONIZE) && !defined(WIN32)
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
if (daemonize && lws_daemonize("/tmp/.lwsts-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
signal(SIGINT, sighandler);
#ifndef WIN32
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
#endif
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets test server - "
"(C) Copyright 2010-2013 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
#ifdef EXTERNAL_POLL
max_poll_elements = getdtablesize();
pollfds = malloc(max_poll_elements * sizeof (struct pollfd));
fd_lookup = malloc(max_poll_elements * sizeof (int));
if (pollfds == NULL || fd_lookup == NULL) {
lwsl_err("Out of memory pollfds=%d\n", max_poll_elements);
return -1;
}
#endif
info.protocols = protocols;
if (!use_ssl) {
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
} else {
// info.ssl_cert_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
// info.ssl_private_key_filepath = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem";
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
n = 0;
while (n >= 0 && !force_exit) {
struct timeval tv;
gettimeofday(&tv, NULL);
n = libwebsocket_service(context, 50);
}
libwebsocket_context_destroy(context);
lwsl_notice("libwebsockets-test-server exited cleanly\n");
closelog();
return 0;
}
int main(int argc, char **argv)
{
int n = 0;
int port = 7681;
int use_ssl = 0;
struct libwebsocket_context *context;
int opts = 0;
char interface_name[128] = "";
const char *_interface = NULL;
char ssl_cert[256] = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.pem";
char ssl_key[256] = LOCAL_RESOURCE_PATH"/libwebsockets-test-server.key.pem";
#ifndef _WIN32
int syslog_options = LOG_PID | LOG_PERROR;
#endif
int client = 0;
int listen_port = 80;
struct lws_context_creation_info info;
char passphrase[256];
char uri[256] = "/";
#ifndef LWS_NO_CLIENT
char address[256], ads_port[256 + 30];
int rate_us = 250000;
unsigned int oldus = 0;
struct libwebsocket *wsi;
int disallow_selfsigned = 0;
#endif
int debug_level = 7;
#ifndef LWS_NO_DAEMONIZE
int daemonize = 0;
#endif
memset(&info, 0, sizeof info);
#ifndef LWS_NO_CLIENT
lwsl_notice("Built to support client operations\n");
#endif
#ifndef LWS_NO_SERVER
lwsl_notice("Built to support server operations\n");
#endif
while (n >= 0) {
n = getopt_long(argc, argv, "i:hsp:d:DC:k:P:vu:"
#ifndef LWS_NO_CLIENT
"c:r:"
#endif
, options, NULL);
if (n < 0)
continue;
switch (n) {
case 'P':
strncpy(passphrase, optarg, sizeof(passphrase));
passphrase[sizeof(passphrase) - 1] = '\0';
info.ssl_private_key_password = passphrase;
break;
case 'C':
strncpy(ssl_cert, optarg, sizeof(ssl_cert));
ssl_cert[sizeof(ssl_cert) - 1] = '\0';
disallow_selfsigned = 1;
break;
case 'k':
strncpy(ssl_key, optarg, sizeof(ssl_key));
ssl_key[sizeof(ssl_key) - 1] = '\0';
break;
case 'u':
strncpy(uri, optarg, sizeof(uri));
uri[sizeof(uri) - 1] = '\0';
break;
#ifndef LWS_NO_DAEMONIZE
case 'D':
daemonize = 1;
#ifndef _WIN32
syslog_options &= ~LOG_PERROR;
#endif
break;
#endif
#ifndef LWS_NO_CLIENT
case 'c':
client = 1;
strncpy(address, optarg, sizeof(address) - 1);
address[sizeof(address) - 1] = '\0';
port = 80;
break;
case 'r':
rate_us = atoi(optarg) * 1000;
break;
#endif
case 'd':
debug_level = atoi(optarg);
break;
case 's':
use_ssl = 1; /* 1 = take care about cert verification, 2 = allow anything */
break;
case 'p':
port = atoi(optarg);
break;
case 'v':
versa = 1;
break;
case 'i':
strncpy(interface_name, optarg, sizeof interface_name);
interface_name[(sizeof interface_name) - 1] = '\0';
_interface = interface_name;
break;
case '?':
case 'h':
fprintf(stderr, "Usage: libwebsockets-test-echo\n"
" --debug / -d <debug bitfield>\n"
" --port / -p <port>\n"
" --ssl-cert / -C <cert path>\n"
" --ssl-key / -k <key path>\n"
#ifndef LWS_NO_CLIENT
" --client / -c <server IP>\n"
" --ratems / -r <rate in ms>\n"
#endif
" --ssl / -s\n"
" --passphrase / -P <passphrase>\n"
" --interface / -i <interface>\n"
#ifndef LWS_NO_DAEMONIZE
" --daemonize / -D\n"
#endif
);
exit(1);
}
}
#ifndef LWS_NO_DAEMONIZE
/*
* normally lock path would be /var/lock/lwsts or similar, to
* simplify getting started without having to take care about
* permissions or running as root, set to /tmp/.lwsts-lock
*/
#if defined(WIN32) || defined(_WIN32)
#else
if (!client && daemonize && lws_daemonize("/tmp/.lwstecho-lock")) {
fprintf(stderr, "Failed to daemonize\n");
return 1;
}
#endif
#endif
#ifndef _WIN32
/* we will only try to log things according to our debug_level */
setlogmask(LOG_UPTO (LOG_DEBUG));
openlog("lwsts", syslog_options, LOG_DAEMON);
#endif
/* tell the library what debug level to emit and to send it to syslog */
lws_set_log_level(debug_level, lwsl_emit_syslog);
lwsl_notice("libwebsockets echo test - "
"(C) Copyright 2010-2015 Andy Green <*****@*****.**> - "
"licensed under LGPL2.1\n");
#ifndef LWS_NO_CLIENT
if (client) {
lwsl_notice("Running in client mode\n");
listen_port = CONTEXT_PORT_NO_LISTEN;
if (use_ssl && !disallow_selfsigned) {
lwsl_info("allowing selfsigned\n");
use_ssl = 2;
} else {
lwsl_info("requiring server cert validation againts %s\n", ssl_cert);
info.ssl_ca_filepath = ssl_cert;
}
} else {
#endif
#ifndef LWS_NO_SERVER
lwsl_notice("Running in server mode\n");
listen_port = port;
#endif
#ifndef LWS_NO_CLIENT
}
#endif
info.port = listen_port;
info.iface = _interface;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
if (use_ssl && !client) {
info.ssl_cert_filepath = ssl_cert;
info.ssl_private_key_filepath = ssl_key;
} else
if (use_ssl && client) {
info.ssl_cert_filepath = NULL;
info.ssl_private_key_filepath = NULL;
}
info.gid = -1;
info.uid = -1;
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL) {
lwsl_err("libwebsocket init failed\n");
return -1;
}
signal(SIGINT, sighandler);
n = 0;
while (n >= 0 && !force_exit) {
#ifndef LWS_NO_CLIENT
struct timeval tv;
if (client && !state) {
state = 1;
lwsl_notice("Client connecting to %s:%u....\n", address, port);
/* we are in client mode */
address[sizeof(address) - 1] = '\0';
sprintf(ads_port, "%s:%u", address, port & 65535);
wsi = libwebsocket_client_connect(context, address,
port, use_ssl, uri, ads_port,
ads_port, NULL, -1);
if (!wsi) {
lwsl_err("Client failed to connect to %s:%u\n", address, port);
goto bail;
}
}
if (client && !versa) {
gettimeofday(&tv, NULL);
if (((unsigned int)tv.tv_usec - oldus) > (unsigned int)rate_us) {
libwebsocket_callback_on_writable_all_protocol(&protocols[0]);
oldus = tv.tv_usec;
}
}
#endif
n = libwebsocket_service(context, 10);
}
#ifndef LWS_NO_CLIENT
bail:
#endif
libwebsocket_context_destroy(context);
lwsl_notice("libwebsockets-test-echo exited cleanly\n");
#ifndef _WIN32
closelog();
#endif
return 0;
}
struct libwebsocket_context *mosq_websockets_init(struct mosquitto__listener *listener, int log_level)
{
struct lws_context_creation_info info;
struct libwebsocket_protocols *p;
int protocol_count;
int i;
struct libws_mqtt_hack *user;
/* Count valid protocols */
for(protocol_count=0; protocols[protocol_count].name; protocol_count++);
p = mosquitto__calloc(protocol_count+1, sizeof(struct libwebsocket_protocols));
if(!p){
log__printf(NULL, MOSQ_LOG_ERR, "Out of memory.");
return NULL;
}
for(i=0; protocols[i].name; i++){
p[i].name = protocols[i].name;
p[i].callback = protocols[i].callback;
p[i].per_session_data_size = protocols[i].per_session_data_size;
p[i].rx_buffer_size = protocols[i].rx_buffer_size;
}
memset(&info, 0, sizeof(info));
info.iface = listener->host;
info.port = listener->port;
info.protocols = p;
info.gid = -1;
info.uid = -1;
#ifdef WITH_TLS
info.ssl_ca_filepath = listener->cafile;
info.ssl_cert_filepath = listener->certfile;
info.ssl_private_key_filepath = listener->keyfile;
info.ssl_cipher_list = listener->ciphers;
if(listener->require_certificate){
info.options |= LWS_SERVER_OPTION_REQUIRE_VALID_OPENSSL_CLIENT_CERT;
}
#endif
#if LWS_LIBRARY_VERSION_MAJOR>1
info.options |= LWS_SERVER_OPTION_DO_SSL_GLOBAL_INIT;
#endif
if(listener->socket_domain == AF_INET){
info.options |= LWS_SERVER_OPTION_DISABLE_IPV6;
}
user = mosquitto__calloc(1, sizeof(struct libws_mqtt_hack));
if(!user){
mosquitto__free(p);
log__printf(NULL, MOSQ_LOG_ERR, "Out of memory.");
return NULL;
}
if(listener->http_dir){
#ifdef WIN32
user->http_dir = _fullpath(NULL, listener->http_dir, 0);
#else
user->http_dir = realpath(listener->http_dir, NULL);
#endif
if(!user->http_dir){
mosquitto__free(user);
mosquitto__free(p);
log__printf(NULL, MOSQ_LOG_ERR, "Error: Unable to open http dir \"%s\".", listener->http_dir);
return NULL;
}
}
info.user = user;
listener->ws_protocol = p;
lws_set_log_level(log_level, log_wrap);
log__printf(NULL, MOSQ_LOG_INFO, "Opening websockets listen socket on port %d.", listener->port);
return libwebsocket_create_context(&info);
}
int main(int argc, char **argv)
{
int n = 0;
int ret = 0;
// int port = 8543;
int port = 9000;
int use_ssl = 0;
struct libwebsocket_context *context;
// const char *address="192.168.6.176";
const char *address="192.168.6.114";
struct libwebsocket *wsi_dumb;
int ietf_version = -1; /* latest */
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
fprintf(stderr, "DTS2B websockets client\n"
"(C) Copyright 2014-2015 Mleaf_HEXI <*****@*****.**> "
"licensed under LGPL2.1\n");
/*
* create the websockets context. This tracks open connections and
* knows how to route any traffic and which protocol version to use,
* and if each connection is client or server side.
*
* For this client-only demo, we tell it to not listen on any port.
*/
info.port = CONTEXT_PORT_NO_LISTEN;
info.protocols = protocols;
#ifndef LWS_NO_EXTENSIONS
info.extensions = libwebsocket_get_internal_extensions();
#endif
info.gid = -1;
info.uid = -1;
context = libwebsocket_create_context(&info);
if (context == NULL) {
fprintf(stderr, "Creating libwebsocket context failed\n");
return 1;
}
/* create a client websocket using dumb increment protocol */
/*
TITLE: libwebsocket_client_connect - Connect to another websocket server
struct libwebsocket * libwebsocket_client_connect (struct libwebsocket_context * context, const char * address, int port, int ssl_connection, const char * path, const char * host, const char * origin, const char * protocol, int ietf_version_or_minus_one)
Arguments
context
Websocket context
address
Remote server address, eg, "myserver.com"
port
Port to connect to on the remote server, eg, 80
ssl_connection
0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self signed certs
path
Websocket path on server
host
Hostname on server
origin
Socket origin name
protocol
Comma-separated list of protocols being asked for from the server, or just one. The server will pick the one it likes best.
ietf_version_or_minus_one
-1 to ask to connect using the default, latest protocol supported, or the specific protocol ordinal
Description
This function creates a connection to a remote server
*/
fprintf(stderr, "Connecting to %s:%u\n", address, port);
wsi_dumb = libwebsocket_client_connect(context, address, port, use_ssl,
"/websocket/uclient/MOCK_DTS2B_ACCESS_CODE_1234567890", address,"origin",
protocols[0].name, ietf_version);
if (wsi_dumb == NULL) {
fprintf(stderr, "libwebsocket connect failed\n");
ret = 1;
goto bail;
}
fprintf(stderr, "Waiting for connect...\n");
sqlite3_test();//sqlite3数据库测试
/*
* sit there servicing the websocket context to handle incoming
* packets, and drawing random circles on the mirror protocol websocket
* nothing happens until the client websocket connection is
* asynchronously established
*/
n = 0;
while (n >= 0 && !was_closed && !force_exit)
{
n = libwebsocket_service(context, 10);
if (n < 0)
continue;
if (wsi_mirror)
continue;
}
bail:
fprintf(stderr, "Exiting\n");
libwebsocket_context_destroy(context);
return 1;
}
//--------------------------------------------------------------
bool Server::setup( ServerOptions options ){
/*
enum lws_log_levels {
LLL_ERR = 1 << 0,
LLL_WARN = 1 << 1,
LLL_NOTICE = 1 << 2,
LLL_INFO = 1 << 3,
LLL_DEBUG = 1 << 4,
LLL_PARSER = 1 << 5,
LLL_HEADER = 1 << 6,
LLL_EXT = 1 << 7,
LLL_CLIENT = 1 << 8,
LLL_LATENCY = 1 << 9,
LLL_COUNT = 10
};
*/
lws_set_log_level(LLL_WARN, NULL);
defaultOptions = options;
port = defaultOptions.port = options.port;
document_root = defaultOptions.documentRoot = options.documentRoot;
// NULL protocol is required by LWS
struct libwebsocket_protocols null_protocol = { NULL, NULL, 0 };
//setup protocols
lws_protocols.clear();
//register main protocol
registerProtocol( options.protocol, serverProtocol );
//register any added protocols
for (int i=0; i<protocols.size(); ++i){
struct libwebsocket_protocols lws_protocol = {
( protocols[i].first == "NULL" ? NULL : protocols[i].first.c_str() ),
lws_callback,
protocols[i].second->rx_buffer_size,
protocols[i].second->rx_buffer_size
};
lws_protocols.push_back(lws_protocol);
}
lws_protocols.push_back(null_protocol);
// make cert paths null if not using ssl
const char * sslCert = NULL;
const char * sslKey = NULL;
if ( defaultOptions.bUseSSL ){
sslCert = defaultOptions.sslCertPath.c_str();
sslKey = defaultOptions.sslKeyPath.c_str();
}
int opts = 0;
struct lws_context_creation_info info;
memset(&info, 0, sizeof info);
info.port = port;
info.protocols = &lws_protocols[0];
info.extensions = libwebsocket_get_internal_extensions();
info.ssl_cert_filepath = sslCert;
info.ssl_private_key_filepath = sslKey;
info.gid = -1;
info.uid = -1;
if ( options.ka_time != 0 ){
info.ka_time = options.ka_time;
info.ka_probes = options.ka_probes;
info.ka_interval = options.ka_interval;
}
info.options = opts;
context = libwebsocket_create_context(&info);
if (context == NULL){
ofLogError() << "[ofxLibwebsockets] libwebsockets init failed";
return false;
} else {
startThread(); // blocking, non-verbose
return true;
}
}