websock.h

// websock.h -- websocket server for O2
//
// Roger Dannenberg
// based on websocketserver.srp by Hongbo Fang and Roger Dannenberg
// Feb 2020
 
#ifndef O2_NO_WEBSOCKETS
class Http_conn;
 
class Http_server: public Proxy_info {
public:
    long page_len;     // string length of page
    const char *root;
    Http_server(int port, const char *root);
    virtual ~Http_server();
 
    // Implement the Net_interface:
    // do nothing, just start receiving messages:
    virtual O2err accepted(Fds_info *conn);
    virtual O2err deliver(O2netmsg_ptr msg) { return O2_FAIL; } // server
};
 
 
class Http_reader;
 
class Http_conn: public Bridge_info {
public:
    const char *root;  // root of web pages
    int port; // server port
    Vec<char> inbuf;
    int inf;
    Http_reader *reader;
    // link used to create protocol's pending_ws_sender list:
    Http_conn *next_pending; // could probably use next instead for this list,
        // but next is an O2node* used for hash table collisions. Right now,
        // Http_conn is unnamed and not hashed, but it seems safer to reserve
        // next for hash table use.
    // websocket info:
    bool is_web_socket;
    bool sent_close_command;  // sent a CLOSE command
    bool confirmed_ensemble; // first message must be /_o2/ws/dy "ensemble"
    int maskx;  // index for masking key
    int payload_offset;  // state to help parse incoming data
    int ws_msg_len;
    O2message_ptr outgoing;  // pending outgoing messages: To send a message,
    // we parse it, and if we're already sending a message, we could already
    // be using the message parsing memory. In that case, we append the
    // message to this outgoing queue (a list). After each message is sent,
    // we sequentially send messages from this outgoing queue. They may end
    // up in another queue associated with the websocket's socket. These
    // will contain "raw" data ready for TCP send.
 
    Http_conn(Fds_info *conn, const char *root, int port);
 
    virtual ~Http_conn();
 
    O2err websocket_upgrade(const char *key, int msg_len);
    O2err process_as_web_socket();
    const char *find_field(const char *name, const char *value, int length);
    
    O2err ws_msg_is_complete(const char **error);
    O2err handle_websocket_msg(const char **error);
    O2err send_msg_later(O2message_ptr msg);
 
    virtual O2err close(); // close the connection
    virtual O2err accepted(Fds_info *conn) { return O2_FAIL; }  // not a server
    virtual O2err deliver(O2netmsg_ptr msg);
    virtual O2err send(bool block);
 
};
 
 
// file reader to asynchronously read web pages
#ifdef WIN32
class Http_reader: public O2obj {
#else
class Http_reader: public Proxy_info {
#endif
public:
    int port; // server port
    O2netmsg_ptr data;
    O2netmsg_ptr *last_ref;  // pointer to last msg in data, could be &data
                             // *last_ref is where async read puts the content
    long data_len;  // how much have we read?
    Fds_info *fds_info;  // file descriptor for file to be read
    Http_conn *conn;
#ifdef WIN32
    HANDLE inf; // handle for the opened file to be read
    Http_reader *next; // used to make a list of active readers
    OVERLAPPED overlapped;
    bool ready_for_read;
    void poll(); // poll method for async reads
#else
    aiocb cb;  // asynchronous read control block
#endif
 
    Http_reader(const char *c_path, Http_conn *connection, int port);
 
    ~Http_reader();
 
    virtual O2err accepted(Fds_info *conn) { return O2_FAIL; } // not a server
    virtual O2err deliver(O2netmsg_ptr msg);
    virtual O2netmsg_ptr prepare_new_read();
    virtual void read_operation_completed(int n);
    virtual O2err read_eof();
 
};
#endif