QuickIO  0.2
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
protocols_raw.h
Go to the documentation of this file.
1 
13 #pragma once
14 #include "quickio.h"
15 
24 
31 };
32 
37  protocol_raw_hb_none,
38  protocol_raw_hb_heartbeat,
39  protocol_raw_hb_challenge,
40 };
41 
46 
50 void protocol_raw_init();
51 
56 
61 
65 enum protocol_status protocol_raw_route(struct client *client, gsize *used);
66 
71  struct client *client,
72  const struct protocol_heartbeat *hb);
73 
81  const gchar *ev_path,
82  const gchar *ev_extra,
83  const evs_cb_t server_cb,
84  const gchar *json);
85 
101 GString* protocol_raw_format(
102  const gchar *ev_path,
103  const gchar *ev_extra,
104  const evs_cb_t server_cb,
105  const gchar *json);
106 
110 gboolean protocol_raw_check_handshake(struct client *client);
111 
116  struct client *client,
117  const struct protocol_heartbeat *hb,
118  const gchar *heartbeat,
119  const gsize heartbeat_len);
120 
guint64 evs_cb_t
Callbacks are just gigantic integers, 0 meaning "no callback".
Definition: evs.h:23
Useful information about heartbeat timings.
Definition: protocols.h:64
Heartbeating the client failed, and he's now dead.
Definition: protocols_raw.h:30
struct protocol_frames protocol_raw_frame(const gchar *ev_path, const gchar *ev_extra, const evs_cb_t server_cb, const gchar *json)
Frames data to send out to a client.
Events are stored in a prefix tree for fast, nice lookups.
Definition: evs.h:184
enum protocol_status protocol_raw_route(struct client *client, gsize *used)
Routes the data received from a client.
protocol_handles
If a protocol can handle a client.
Definition: protocols.h:23
void protocol_raw_heartbeat(struct client *client, const struct protocol_heartbeat *hb)
Sends a heartbeat to a client.
GString * protocol_raw_format(const gchar *ev_path, const gchar *ev_extra, const evs_cb_t server_cb, const gchar *json)
Formats an event into the QIO protocol.
enum protocol_status protocol_raw_handle(struct client *client, gchar *event)
Handles a raw frame from a client.
struct protocol * protocol_raw
This protocol's functions.
Definition: protocols_raw.h:45
Everything that a client needs to function.
Definition: client.h:100
gboolean protocol_raw_check_handshake(struct client *client)
Checks that the data received is indeed a valid QIO handshake.
enum protocol_status protocol_raw_handshake(struct client *client)
To complete the single, simple flash handshake.
raw_close_reasons
Extends the reasons for closing a client.
Definition: protocols_raw.h:19
What a protocol needs to route messages around.
Definition: protocols.h:114
void protocol_raw_do_heartbeat(struct client *client, const struct protocol_heartbeat *hb, const gchar *heartbeat, const gsize heartbeat_len)
Checks that the data received is indeed a valid QIO handshake.
Every header, definition, and whatnot QuickIO needs to run.
enum protocol_handles protocol_raw_handles(struct client *client)
If flash can handle this client.
protocol_status
Responses from the route() functions.
Definition: protocols.h:43
The event was improperly formatted.
Definition: protocols_raw.h:23
protocol_raw_hb
The type of heartbeat to send.
Definition: protocols_raw.h:36
void protocol_raw_init()
Sets up everything to run.
Some protocols (HTTP, looking at you) need a few frames types depending on the type of client they're...
Definition: protocols.h:99