Refactoring requests and context handling
[src/app-framework-binder.git] / src / afb-websock.c
1 /*
2  * Copyright 2016 IoT.bzh
3  * Author: José Bollo <jose.bollo@iot.bzh>
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #define _GNU_SOURCE
19
20 #include <stdlib.h>
21 #include <assert.h>
22 #include <errno.h>
23 #include <string.h>
24
25 #include <openssl/sha.h>
26 #include <microhttpd.h>
27
28 #include "afb-ws-json.h"
29
30 #include "afb-method.h"
31 #include "afb-context.h"
32 #include "afb-hreq.h"
33 #include "afb-websock.h"
34
35 /**************** WebSocket connection upgrade ****************************/
36
37 static const char websocket_s[] = "websocket";
38 static const char sec_websocket_key_s[] = "Sec-WebSocket-Key";
39 static const char sec_websocket_version_s[] = "Sec-WebSocket-Version";
40 static const char sec_websocket_accept_s[] = "Sec-WebSocket-Accept";
41 static const char sec_websocket_protocol_s[] = "Sec-WebSocket-Protocol";
42 static const char websocket_guid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
43
44 static void enc64(unsigned char *in, char *out)
45 {
46         static const char tob64[] =
47                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
48                 "abcdefghijklmnopqrstuvwxyz"
49                 "0123456789+/";
50         out[0] = tob64[in[0] >> 2];
51         out[1] = tob64[((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4)];
52         out[2] = tob64[((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6)];
53         out[3] = tob64[in[2] & 0x3f];
54 }
55
56 static void make_accept_value(const char *key, char result[29])
57 {
58         unsigned char md[SHA_DIGEST_LENGTH+1];
59         size_t len = strlen(key);
60         char *buffer = alloca(len + sizeof websocket_guid - 1);
61         memcpy(buffer, key, len);
62         memcpy(buffer + len, websocket_guid, sizeof websocket_guid - 1);
63         SHA1((const unsigned char *)buffer, (unsigned long)(len + sizeof websocket_guid - 1), md);
64         assert(SHA_DIGEST_LENGTH == 20);
65         md[20] = 0;
66         enc64(&md[0], &result[0]);
67         enc64(&md[3], &result[4]);
68         enc64(&md[6], &result[8]);
69         enc64(&md[9], &result[12]);
70         enc64(&md[12], &result[16]);
71         enc64(&md[15], &result[20]);
72         enc64(&md[18], &result[24]);
73         result[27] = '=';
74         result[28] = 0;
75 }
76
77 static const char vseparators[] = " \t,";
78
79 static int headerhas(const char *header, const char *needle)
80 {
81         size_t len, n;
82
83         n = strlen(needle);
84         for(;;) {
85                 header += strspn(header, vseparators);
86                 if (!*header)
87                         return 0;
88                 len = strcspn(header, vseparators);
89                 if (n == len && 0 == strncasecmp(needle, header, n))
90                         return 1;
91                 header += len;
92         }
93 }
94
95 struct protodef
96 {
97         const char *name;
98         void *(*create)(int fd, void *context, void (*cleanup)(void*), void *cleanup_closure);
99 };
100
101 static const struct protodef *search_proto(const struct protodef *protodefs, const char *protocols)
102 {
103         int i;
104         size_t len;
105
106         for(;;) {
107                 protocols += strspn(protocols, vseparators);
108                 if (!*protocols)
109                         return NULL;
110                 len = strcspn(protocols, vseparators);
111                 for (i = 0 ; protodefs[i].name != NULL ; i++)
112                         if (!strncasecmp(protodefs[i].name, protocols, len)
113                          && !protodefs[i].name[len])
114                                 return &protodefs[i];
115                 protocols += len;
116         }
117 }
118
119 static int check_websocket_upgrade(struct MHD_Connection *con, const struct protodef *protodefs, void *context, void **websock)
120 {
121         struct MHD_Response *response;
122         const char *connection, *upgrade, *key, *version, *protocols;
123         char acceptval[29];
124         int vernum;
125         const struct protodef *proto;
126         void *ws;
127
128         /* is an upgrade to websocket ? */
129         upgrade = MHD_lookup_connection_value(con, MHD_HEADER_KIND, MHD_HTTP_HEADER_UPGRADE);
130         if (upgrade == NULL || strcasecmp(upgrade, websocket_s))
131                 return 0;
132
133         /* is a connection for upgrade ? */
134         connection = MHD_lookup_connection_value(con, MHD_HEADER_KIND, MHD_HTTP_HEADER_CONNECTION);
135         if (connection == NULL
136          || !headerhas (connection, MHD_HTTP_HEADER_UPGRADE))
137                 return 0;
138
139         /* has a key and a version ? */
140         key = MHD_lookup_connection_value(con, MHD_HEADER_KIND, sec_websocket_key_s);
141         version = MHD_lookup_connection_value(con, MHD_HEADER_KIND, sec_websocket_version_s);
142         if (key == NULL || version == NULL)
143                 return 0;
144
145         /* is a supported version ? */
146         vernum = atoi(version);
147         if (vernum != 13) {
148                 response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
149                 MHD_add_response_header(response, sec_websocket_version_s, "13");
150                 MHD_queue_response(con, MHD_HTTP_UPGRADE_REQUIRED, response);
151                 MHD_destroy_response(response);
152                 return 1;
153         }
154
155         /* is the protocol supported ? */
156         protocols = MHD_lookup_connection_value(con, MHD_HEADER_KIND, sec_websocket_protocol_s);
157         proto = protocols == NULL ? NULL : search_proto(protodefs, protocols);
158         if (proto == NULL) {
159                 response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
160                 MHD_queue_response(con, MHD_HTTP_PRECONDITION_FAILED, response);
161                 MHD_destroy_response(response);
162                 return 1;
163         }
164
165         /* create the web socket */
166         ws = proto->create(MHD_get_connection_info(con, MHD_CONNECTION_INFO_CONNECTION_FD)->connect_fd,
167                         context,
168                         (void*)MHD_resume_connection,
169                         con);
170         if (ws == NULL) {
171                 response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
172                 MHD_queue_response(con, MHD_HTTP_INTERNAL_SERVER_ERROR, response);
173                 MHD_destroy_response(response);
174                 return 1;
175         }
176
177         /* send the accept connection */
178         make_accept_value(key, acceptval);
179         response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT);
180         MHD_add_response_header(response, sec_websocket_accept_s, acceptval);
181         MHD_add_response_header(response, sec_websocket_protocol_s, proto->name);
182         MHD_add_response_header(response, MHD_HTTP_HEADER_CONNECTION, MHD_HTTP_HEADER_UPGRADE);
183         MHD_add_response_header(response, MHD_HTTP_HEADER_UPGRADE, websocket_s);
184         MHD_queue_response(con, MHD_HTTP_SWITCHING_PROTOCOLS, response);
185         MHD_destroy_response(response);
186
187         *websock = ws;
188         return 1;
189 }
190
191 static const struct protodef protodefs[] = {
192         { "x-afb-ws-json1",     (void*)afb_ws_json_create },
193         { NULL, NULL }
194 };
195
196 int afb_websock_check_upgrade(struct afb_hreq *hreq)
197 {
198         void *ws;
199         int rc;
200
201         /* is a get ? */
202         if (hreq->method != afb_method_get
203          || strcasecmp(hreq->version, MHD_HTTP_VERSION_1_1))
204                 return 0;
205
206         ws = NULL;
207         rc = check_websocket_upgrade(hreq->connection, protodefs, hreq->context.session, &ws);
208         if (rc == 1) {
209                 hreq->replied = 1;
210                 if (ws != NULL)
211                         hreq->upgrade = 1;
212         }
213         return rc;
214 }
215