Diff: Websocket.cpp
- Revision:
- 0:87e52bb764c5
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Websocket.cpp Thu May 31 16:02:12 2012 +0000
@@ -0,0 +1,432 @@
+#define __DEBUG__ 4 //Maximum verbosity
+#ifndef __MODULE__
+#define __MODULE__ "Websocket.cpp"
+#endif
+
+#include "core/fwk.h"
+
+#include "Websocket.h"
+#include <string>
+
+
+Websocket::Websocket(char * url) : m_sockHandle(-1) {
+ //server_ip = NULL;
+
+ std::memset(&m_sockAddr, 0, sizeof(struct sockaddr_in));
+
+ fillFields(url);
+}
+
+
+void Websocket::fillFields(char * url) {
+ char *res = NULL;
+ char *res1 = NULL;
+
+ char buf[50];
+ strcpy(buf, url);
+
+ res = strtok(buf, ":");
+ if (strcmp(res, "ws")) {
+#ifdef DEBUG
+ printf("\r\nFormat error: please use: \"ws://ip-or-domain[:port]/path\"\r\n\r\n");
+#endif
+ } else {
+ //ip_domain and port
+ res = strtok(NULL, "/");
+
+ //path
+ res1 = strtok(NULL, " ");
+ if (res1 != NULL) {
+ path = res1;
+ }
+
+ //ip_domain
+ res = strtok(res, ":");
+
+ //port
+ res1 = strtok(NULL, " ");
+ //port
+ if (res1 != NULL) {
+ port = res1;
+ } else {
+ port = "80";
+ }
+
+ if (res != NULL) {
+ ip_domain = res;
+
+ //if we use ethernet, we must decode ip address or use dnsresolver
+ strcpy(buf, res);
+
+ //we try to decode the ip address
+ if (buf[0] >= '0' && buf[0] <= '9') {
+ res = strtok(buf, ".");
+ int i = 0;
+ int ip[4];
+ while (res != NULL) {
+ ip[i] = atoi(res);
+ res = strtok(NULL, ".");
+ i++;
+ }
+ //server_ip = new IpAddr(ip[0], ip[1], ip[2], ip[3]);
+ m_sockAddr.sin_addr.s_addr = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3]; //Could do this easier if using inet_pton()
+
+ }
+ }
+ }
+}
+
+
+bool Websocket::connect() {
+ char cmd[192];
+
+ //Resolve DNS if needed
+ if(m_sockAddr.sin_addr.s_addr == 0)
+ {
+ DBG("Resolving DNS socket");
+ struct hostent *server = socket::gethostbyname(ip_domain.c_str());
+ if(server == NULL)
+ {
+ return false;
+ }
+ memcpy((char*)&m_sockAddr.sin_addr.s_addr, (char*)server->h_addr_list[0], server->h_length);
+ }
+
+ m_sockAddr.sin_family = AF_INET;
+ m_sockAddr.sin_port = htons(atoi(port.c_str()));
+
+ //Create socket
+ DBG("Creating socket");
+ m_sockHandle = socket::socket(AF_INET, SOCK_STREAM, 0);
+ if (m_sockHandle < 0)
+ {
+ ERR("Could not create socket");
+ return false;
+ }
+ DBG("Handle is %d",m_sockHandle);
+
+ //Connect
+ DBG("Connecting socket to %s:%d", inet_ntoa(m_sockAddr.sin_addr), ntohs(m_sockAddr.sin_port));
+ int ret = socket::connect(m_sockHandle, (const struct sockaddr *)&m_sockAddr, sizeof(m_sockAddr));
+ if (ret < 0)
+ {
+ socket::close(m_sockHandle);
+ ERR("Could not connect");
+ return false;
+ }
+
+ m_connected = true;
+
+ DBG("Sending HTTP request");
+ //send websocket HTTP header
+ sprintf(cmd, "GET /%s HTTP/1.1\r\n", path.c_str());
+ write((uint8_t*)cmd, strlen(cmd));
+
+ sprintf(cmd, "Host: %s:%s\r\n", ip_domain.c_str(), port.c_str());
+ write((uint8_t*)cmd, strlen(cmd));
+
+ sprintf(cmd, "Upgrade: WebSocket\r\n");
+ write((uint8_t*)cmd, strlen(cmd));
+
+ sprintf(cmd, "Connection: Upgrade\r\n");
+ write((uint8_t*)cmd, strlen(cmd));
+
+// socket::send(m_sockHandle, "Origin: null\r\n", strlen("Origin: null\r\n"), 0);
+
+ sprintf(cmd, "Sec-WebSocket-Key: L159VM0TWUzyDxwJEIEzjw==\r\n");
+ write((uint8_t*)cmd, strlen(cmd));
+
+ sprintf(cmd, "Sec-WebSocket-Version: 13\r\n\r\n");
+ ret = write((uint8_t*)cmd, strlen(cmd));
+ if(ret < 0)
+ {
+ close();
+ ERR("Could not send request");
+ m_connected = false;
+ return false;
+ }
+
+ DBG("Waiting for answer");
+ ret = read((uint8_t*)cmd, 0, 192);
+ if(ret < 0)
+ {
+ close();
+ ERR("Could not receive answer");
+ m_connected = false;
+ return false;
+ }
+ cmd[ret] = '\0';
+
+ DBG("Comparing answer");
+ if( strstr(cmd, "Sec-WebSocket-Accept: DdLWT/1JcX+nQFHebYP+rqEx5xI=") == NULL )
+ {
+ ERR("Wrong answer from server, got \"%s\" instead", cmd);
+ do{
+ ret = read((uint8_t*)cmd, 0, 192);
+ if(ret < 0)
+ {
+ ERR("Could not receive answer");
+ return false;
+ }
+ cmd[ret] = '\0';
+ printf("%s",cmd);
+ } while(ret > 0);
+ close();
+ m_connected = false;
+ return false;
+ }
+ DBG("\r\nip_domain: %s\r\npath: /%s\r\nport: %s\r\n\r\n",this->ip_domain.c_str(), this->path.c_str(), this->port.c_str());
+ return true;
+}
+
+void Websocket::sendLength(uint32_t len) {
+ if (len < 126) {
+ sendChar(len | (1<<7));
+ } else if (len < 65535) {
+ sendChar(126 | (1<<7));
+ sendChar(len & 0xff);
+ sendChar((len >> 8) & 0xff);
+ } else {
+ sendChar(127 | (1<<7));
+ for (int i = 0; i < 8; i++) {
+ sendChar((len >> i*8) & 0xff);
+ }
+ }
+}
+
+void Websocket::sendChar(uint8_t c) {
+ write(&c, 1);
+}
+
+bool Websocket::readChar(uint8_t* pC, bool block)
+{
+ int ret = read(pC, 1, block?36000000:3000);
+ if(ret < 0)
+ {
+ return false;
+ }
+ return true;
+}
+
+void Websocket::sendOpcode(uint8_t opcode) {
+ sendChar(0x80 | (opcode & 0x0f));
+}
+
+void Websocket::sendMask() {
+ for (int i = 0; i < 4; i++) {
+ sendChar(0);
+ }
+}
+
+void Websocket::send(char * str) {
+ sendOpcode(0x01);
+ sendLength(strlen(str));
+ sendMask();
+
+ write((uint8_t*)str, strlen(str));
+}
+
+
+
+bool Websocket::read(char * message) {
+ int i = 0;
+ //int length_buffer = 0;
+ uint32_t len_msg;
+ char opcode = 0;
+ uint8_t c;
+ char mask[4] = {0, 0, 0, 0};
+ Timer tmr;
+
+ //length_buffer = wifi->readable();
+
+ // read the opcode
+ tmr.start();
+ while (true) {
+ if (tmr.read() > 3) {
+ return false;
+ }
+ if(!readChar((uint8_t*)&c, false))
+ {
+ return false;
+ }
+
+ opcode = c;
+ if (opcode == 0x81) {
+ break;
+ }
+ }
+#ifdef DEBUG
+ printf("opcode: 0x%X\r\n", opcode);
+#endif
+ readChar((uint8_t*)&c);
+ len_msg = c & 0x7f;
+ if (len_msg == 126) {
+ readChar((uint8_t*)&c);
+ len_msg = c;
+ readChar((uint8_t*)&c);
+ len_msg += c << 8;
+ } else if (len_msg == 127) {
+ len_msg = 0;
+ for (i = 0; i < 8; i++) {
+ readChar((uint8_t*)&c);
+ len_msg += c << i*8;
+ }
+ }
+ if(len_msg == 0) {
+ return false;
+ }
+#ifdef DEBUG
+ printf("length: %d\r\n", len_msg);
+#endif
+ if ((len_msg & 0x80)) {
+ for (i = 0; i < 4; i++)
+ readChar((uint8_t*)&c);
+ mask[i] = c;
+ }
+
+
+
+ for (i = 0; i < len_msg; i++) {
+ readChar((uint8_t*)&c);
+ message[i] = c ^ mask[i % 4];
+ }
+
+ message[len_msg] = 0;
+ return true;
+}
+
+bool Websocket::close() {
+ if((m_sockHandle < 0) || !m_connected)
+ {
+ return false;
+ }
+ m_connected = false;
+ int ret = socket::close(m_sockHandle);
+ if (ret < 0)
+ {
+ ERR("Could not disconnect");
+ return false;
+ }
+ return true;
+}
+
+
+
+bool Websocket::connected() {
+ return m_connected;
+}
+
+std::string Websocket::getPath() {
+ return path;
+}
+
+int Websocket::waitReadable(uint32_t timeout)
+{
+ //Creating FS set
+ fd_set socksSet;
+ FD_ZERO(&socksSet);
+ FD_SET(m_sockHandle, &socksSet);
+ struct timeval t_val;
+ t_val.tv_sec = timeout / 1000;
+ t_val.tv_usec = (timeout - (t_val.tv_sec * 1000)) * 1000;
+ int ret = socket::select(FD_SETSIZE, &socksSet, NULL, NULL, &t_val);
+ if(ret <= 0 || !FD_ISSET(m_sockHandle, &socksSet))
+ {
+ return -1; //Timeout
+ }
+ return 0;
+}
+
+int Websocket::waitWriteable(uint32_t timeout)
+{
+ //Creating FS set
+ fd_set socksSet;
+ FD_ZERO(&socksSet);
+ FD_SET(m_sockHandle, &socksSet);
+ struct timeval t_val;
+ t_val.tv_sec = timeout / 1000;
+ t_val.tv_usec = (timeout - (t_val.tv_sec * 1000)) * 1000;
+ int ret = socket::select(FD_SETSIZE, NULL, &socksSet, NULL, &t_val);
+ if(ret <= 0 || !FD_ISSET(m_sockHandle, &socksSet))
+ {
+ return -1; //Timeout
+ }
+ return 0;
+}
+
+int Websocket::read(uint8_t* buf, int minLen, int maxLen, uint32_t timeout)
+{
+ if(!m_connected)
+ {
+ return -1;
+ }
+ int readLen = 0;
+ do
+ {
+ int ret = waitReadable(timeout);
+ if(ret == -1)
+ {
+ WARN("Wait readable returned %d",ret);
+ close();
+ return -1;
+ }
+ ret = socket::recv(m_sockHandle, buf + readLen, maxLen - readLen, 0/*MSG_DONTWAIT*/);
+ if(ret > 0)
+ {
+ readLen += ret;
+ }
+ else if(ret==0) //Connection closed
+ {
+ WARN("Recv returned %d",ret);
+ return readLen;
+ }
+ else
+ {
+ WARN("Recv returned %d",ret);
+ close();
+ return -1;
+ }
+ } while(readLen < minLen);
+ return readLen;
+}
+
+int Websocket::write(uint8_t* buf, int len, uint32_t timeout)
+{
+ if(!m_connected)
+ {
+ return -1;
+ }
+ int writtenLen = 0;
+ do
+ {
+ int ret = waitWriteable(timeout);
+ if(ret == -1)
+ {
+ WARN("Wait writeable returned %d",ret);
+ close();
+ return -1;
+ }
+ ret = socket::send(m_sockHandle, buf + writtenLen, len - writtenLen, 0/*MSG_DONTWAIT*/); //FIXME Probably DO WAIT to avoid overflow
+ if(ret > 0)
+ {
+ writtenLen += ret;
+ }
+ else if(ret==0) //Connection closed
+ {
+ WARN("Send returned %d",ret);
+ return writtenLen;
+ }
+ else
+ {
+ WARN("Send returned %d",ret);
+ close(); //Must reset
+ return -1;
+ }
+ } while(writtenLen < len);
+ return writtenLen;
+}
+
+void Websocket::timeoutHandler()
+{
+
+}
Donatien Garnier