bool Hub::upgrade(uv_os_sock_t fd, const char *secKey, SSL *ssl, const char *extensions, size_t extensionsLength, Group<SERVER> *serverGroup) {
if (!serverGroup) {
serverGroup = &getDefaultGroup<SERVER>();
}
uS::Socket s = uS::Socket::init((uS::NodeData *) serverGroup, fd, ssl);
uS::SocketData *socketData = s.getSocketData();
HTTPSocket<SERVER>::Data *temporaryHttpData = new HTTPSocket<SERVER>::Data(socketData);
delete socketData;
s.enterState<HTTPSocket<SERVER>>(temporaryHttpData);
// todo: move this into upgrade call
bool perMessageDeflate = false;
std::string extensionsResponse;
if (extensionsLength) {
ExtensionsNegotiator<uWS::SERVER> extensionsNegotiator(serverGroup->extensionOptions);
extensionsNegotiator.readOffer(std::string(extensions, extensionsLength));
extensionsResponse = extensionsNegotiator.generateOffer();
if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {
perMessageDeflate = true;
}
}
if (HTTPSocket<SERVER>(s).upgrade(secKey, extensionsResponse.data(), extensionsResponse.length())) {
s.enterState<WebSocket<SERVER>>(new WebSocket<SERVER>::Data(perMessageDeflate, s.getSocketData()));
serverGroup->addWebSocket(s);
serverGroup->connectionHandler(WebSocket<SERVER>(s), {nullptr, nullptr, 0, 0});
delete temporaryHttpData;
return true;
}
return false;
}
void HttpSocket<isServer>::upgrade(const char *secKey, const char *extensions, size_t extensionsLength,
const char *subprotocol, size_t subprotocolLength, bool *perMessageDeflate) {
uS::SocketData::Queue::Message *messagePtr;
if (isServer) {
*perMessageDeflate = false;
std::string extensionsResponse;
if (extensionsLength) {
Group<isServer> *group = getGroup<isServer>(*this);
ExtensionsNegotiator<uWS::SERVER> extensionsNegotiator(group->extensionOptions);
extensionsNegotiator.readOffer(std::string(extensions, extensionsLength));
extensionsResponse = extensionsNegotiator.generateOffer();
if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {
*perMessageDeflate = true;
}
}
unsigned char shaInput[] = "XXXXXXXXXXXXXXXXXXXXXXXX258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
memcpy(shaInput, secKey, 24);
unsigned char shaDigest[SHA_DIGEST_LENGTH];
SHA1(shaInput, sizeof(shaInput) - 1, shaDigest);
char upgradeBuffer[1024];
memcpy(upgradeBuffer, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ", 97);
base64(shaDigest, upgradeBuffer + 97);
memcpy(upgradeBuffer + 125, "\r\n", 2);
size_t upgradeResponseLength = 127;
if (extensionsResponse.length()) {
memcpy(upgradeBuffer + upgradeResponseLength, "Sec-WebSocket-Extensions: ", 26);
memcpy(upgradeBuffer + upgradeResponseLength + 26, extensionsResponse.data(), extensionsResponse.length());
memcpy(upgradeBuffer + upgradeResponseLength + 26 + extensionsResponse.length(), "\r\n", 2);
upgradeResponseLength += 26 + extensionsResponse.length() + 2;
}
if (subprotocolLength) {
memcpy(upgradeBuffer + upgradeResponseLength, "Sec-WebSocket-Protocol: ", 24);
memcpy(upgradeBuffer + upgradeResponseLength + 24, subprotocol, subprotocolLength);
memcpy(upgradeBuffer + upgradeResponseLength + 24 + subprotocolLength, "\r\n", 2);
upgradeResponseLength += 24 + subprotocolLength + 2;
}
static char stamp[] = "Sec-WebSocket-Version: 13\r\nWebSocket-Server: uWebSockets\r\n\r\n";
memcpy(upgradeBuffer + upgradeResponseLength, stamp, sizeof(stamp) - 1);
upgradeResponseLength += sizeof(stamp) - 1;
messagePtr = allocMessage(upgradeResponseLength, upgradeBuffer);
} else {
messagePtr = allocMessage(getData()->httpBuffer.length(), getData()->httpBuffer.data());
getData()->httpBuffer.clear();
}
bool wasTransferred;
if (write(messagePtr, wasTransferred)) {
if (!wasTransferred) {
freeMessage(messagePtr);
} else {
messagePtr->callback = nullptr;
}
} else {
freeMessage(messagePtr);
}
}
void HTTPSocket<isServer>::onData(uS::Socket s, char *data, int length) {
HTTPSocket httpSocket(s);
HTTPSocket::Data *httpData = httpSocket.getData();
// 5k = force close!
if (httpData->httpBuffer.length() + length > 1024 * 5) {
httpSocket.onEnd(s);
return;
}
httpData->httpBuffer.append(data, length);
size_t endOfHTTPBuffer = httpData->httpBuffer.find("\r\n\r\n");
if (endOfHTTPBuffer != std::string::npos) {
if (isServer) {
HTTPParser httpParser = (char *) httpData->httpBuffer.data();
std::pair<char *, size_t> secKey = {}, extensions = {}, subprotocol = {}, path = httpParser.value;
for (httpParser++; httpParser.key.second; httpParser++) {
if (httpParser.key.second == 17 || httpParser.key.second == 24 || httpParser.key.second == 22) {
// lowercase the key
for (size_t i = 0; i < httpParser.key.second; i++) {
httpParser.key.first[i] = tolower(httpParser.key.first[i]);
}
if (!strncmp(httpParser.key.first, "sec-websocket-key", httpParser.key.second)) {
secKey = httpParser.value;
} else if (!strncmp(httpParser.key.first, "sec-websocket-extensions", httpParser.key.second)) {
extensions = httpParser.value;
} else if (!strncmp(httpParser.key.first, "sec-websocket-protocol", httpParser.key.second)) {
subprotocol = httpParser.value;
}
}
}
if (secKey.first && secKey.second == 24) {
// this needs to be part of upgrade itself, and shared with Hub::upgrade!
bool perMessageDeflate = false;
std::string extensionsResponse;
if (extensions.first) {
Group<isServer> *group = (Group<isServer> *) s.getNodeData(s.getSocketData());
ExtensionsNegotiator<uWS::SERVER> extensionsNegotiator(group->extensionOptions);
extensionsNegotiator.readOffer(std::string(extensions.first, extensions.second));
extensionsResponse = extensionsNegotiator.generateOffer();
if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {
perMessageDeflate = true;
}
}
if (httpSocket.upgrade(secKey.first, extensionsResponse.data(), extensionsResponse.length(), subprotocol.first, subprotocol.second)) {
s.cancelTimeout();
s.enterState<WebSocket<SERVER>>(new WebSocket<SERVER>::Data(perMessageDeflate, httpData));
((Group<SERVER> *) s.getSocketData()->nodeData)->addWebSocket(s);
//s.cork(true);
((Group<SERVER> *) s.getSocketData()->nodeData)->connectionHandler(WebSocket<SERVER>(s), {path.first, subprotocol.first,
path.second, subprotocol.second});
//s.cork(false);
delete httpData;
}
} else {
httpSocket.onEnd(s);
}
} else {
httpData->httpBuffer.resize(httpData->httpBuffer.length() + WebSocketProtocol<uWS::CLIENT>::CONSUME_POST_PADDING);
bool isUpgrade = false;
HTTPParser httpParser = (char *) httpData->httpBuffer.data();
//std::pair<char *, size_t> secKey = {}, extensions = {};
for (httpParser++; httpParser.key.second; httpParser++) {
if (httpParser.key.second == 7) {
// lowercase the key
for (size_t i = 0; i < httpParser.key.second; i++) {
httpParser.key.first[i] = tolower(httpParser.key.first[i]);
}
// lowercase the value
for (size_t i = 0; i < httpParser.value.second; i++) {
httpParser.value.first[i] = tolower(httpParser.value.first[i]);
}
if (!strncmp(httpParser.key.first, "upgrade", httpParser.key.second)) {
if (!strncmp(httpParser.value.first, "websocket", 9)) {
isUpgrade = true;
}
break;
}
}
}
if (isUpgrade) {
s.enterState<WebSocket<CLIENT>>(new WebSocket<CLIENT>::Data(false, httpData));
//s.cork(true);
httpSocket.cancelTimeout();
httpSocket.setUserData(httpData->httpUser);
((Group<CLIENT> *) s.getSocketData()->nodeData)->addWebSocket(s);
((Group<CLIENT> *) s.getSocketData()->nodeData)->connectionHandler(WebSocket<CLIENT>(s), {nullptr, nullptr, 0, 0});
//s.cork(false);
if (!(s.isClosed() || s.isShuttingDown())) {
WebSocketProtocol<CLIENT> *kws = (WebSocketProtocol<CLIENT> *) ((WebSocket<CLIENT>::Data *) s.getSocketData());
kws->consume((char *) httpData->httpBuffer.data() + endOfHTTPBuffer + 4, httpData->httpBuffer.length() - endOfHTTPBuffer - 4 - WebSocketProtocol<uWS::CLIENT>::CONSUME_POST_PADDING, s);
}
delete httpData;
} else {
httpSocket.onEnd(s);
}
}
}
}
