Add warning detection and improve
[src/app-framework-binder.git] / src / http-svc.c
1 /*
2  * Copyright (C) 2015 "IoT.bzh"
3  * Author "Fulup Ar Foll"
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  * 
18  * Handle standard HTTP request
19  *    Features/Restriction:
20     - handle ETAG to limit upload to modified/new files [cache default 3600s]
21     - handles redirect to index.htlm when path is a directory [code 301]
22     - only support GET method
23     - does not follow link.
24
25    References: https://www.gnu.org/software/libmicrohttpd/manual/html_node/index.html#Top
26    http://libmicrohttpd.sourcearchive.com/documentation/0.4.2/microhttpd_8h.html
27    https://gnunet.org/svn/libmicrohttpd/src/examples/fileserver_example_external_select.c
28    https://github.com/json-c/json-c
29    POST https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dpost.html#microhttpd_002dpost
30  */
31
32 #define _GNU_SOURCE
33
34 #include <microhttpd.h>
35
36 #include <poll.h>
37 #include <sys/stat.h>
38 #include "../include/local-def.h"
39
40 // let's compute fixed URL length only once
41 static size_t apiUrlLen=0;
42 static size_t baseUrlLen=0;
43 static size_t rootUrlLen=0;
44
45 // try to open libmagic to handle mime types
46 static AFB_error initLibMagic (AFB_session *session) {
47   
48     /*MAGIC_MIME tells magic to return a mime of the file, but you can specify different things*/
49     if (verbose) printf("Loading mimetype default magic database\n");
50   
51     session->magic = magic_open(MAGIC_MIME_TYPE);
52     if (session->magic == NULL) {
53         fprintf(stderr,"ERROR: unable to initialize magic library\n");
54         return AFB_FAIL;
55     }
56     
57     // Warning: should not use NULL for DB [libmagic bug wont pass efence check]
58     if (magic_load(session->magic, MAGIC_DB) != 0) {
59         fprintf(stderr,"cannot load magic database - %s\n", magic_error(session->magic));
60         magic_close(session->magic);
61         return AFB_FAIL;
62     }
63
64     return AFB_SUCCESS;
65 }
66
67 // Because of POST call multiple time requestApi we need to free POST handle here
68 static void endRequest (void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe) {
69   AFB_PostHandle *posthandle = *con_cls;
70
71   // if post handle was used let's free everything
72   if (posthandle != NULL) endPostRequest (posthandle);
73 }
74
75
76 // Create check etag value
77 STATIC void computeEtag(char *etag, size_t maxlen, struct stat *sbuf) {
78     long time;
79     time = sbuf->st_mtim.tv_sec;
80     snprintf(etag, maxlen, "%ld", time);
81 }
82
83 STATIC int servFile (struct MHD_Connection *connection, AFB_session *session, const char *url, AFB_staticfile *staticfile) {
84     const char *etagCache, *mimetype; 
85     char etagValue[15];
86     struct MHD_Response *response = NULL;
87     struct stat sbuf; 
88
89     if (fstat (staticfile->fd, &sbuf) != 0) {
90         fprintf(stderr, "Fail to stat file: [%s] error:%s\n", staticfile->path, strerror(errno));
91         goto abortRequest;
92     }
93        
94     // if url is a directory let's add index.html and redirect client
95     if (S_ISDIR (sbuf.st_mode)) {
96         close (staticfile->fd); // close directory check for Index
97        
98         // No trailing '/'. Let's add one and redirect for relative paths to work
99         if (url [strlen (url) -1] != '/') {
100             response = MHD_create_response_from_buffer(0,"", MHD_RESPMEM_PERSISTENT);
101             strncpy(staticfile->path, url, sizeof (staticfile->path));
102             strncat(staticfile->path, "/", sizeof (staticfile->path));
103             MHD_add_response_header (response, "Location", staticfile->path);
104             MHD_queue_response (connection, MHD_HTTP_MOVED_PERMANENTLY, response);
105             if (verbose) fprintf (stderr,"Adding trailing '/' [%s]\n",staticfile->path);      
106             goto sendRequest;
107         }
108         
109         strncat (staticfile->path, OPA_INDEX, sizeof (staticfile->path));
110         if (-1 == (staticfile->fd = open(staticfile->path, O_RDONLY)) || (fstat (staticfile->fd, &sbuf) != 0)) {
111            fprintf(stderr, "No Index.html in direcory [%s]\n", staticfile->path);
112            goto abortRequest;  
113         } 
114     } else if (! S_ISREG (sbuf.st_mode)) { // only standard file any other one including symbolic links are refused.
115         close (staticfile->fd); // nothing useful to do with this file
116         fprintf (stderr, "Fail file: [%s] is not a regular file\n", staticfile->path);
117         const char *errorstr = "<html><body>Application Framework Binder Invalid file type</body></html>";
118         response = MHD_create_response_from_buffer (strlen (errorstr),
119                      (void *) errorstr,  MHD_RESPMEM_PERSISTENT);
120         MHD_queue_response (connection, MHD_HTTP_INTERNAL_SERVER_ERROR, response);
121         goto sendRequest;
122     } 
123     
124     // https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/http-caching?hl=fr
125     // ftp://ftp.heanet.ie/disk1/www.gnu.org/software/libmicrohttpd/doxygen/dc/d0c/microhttpd_8h.html
126
127     // Check etag value and load file only when modification date changes
128     etagCache = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_NONE_MATCH);
129     computeEtag(etagValue, sizeof (etagValue), &sbuf);
130
131     if (etagCache != NULL && strcmp(etagValue, etagCache) == 0) {
132         close(staticfile->fd); // file did not change since last upload
133         if (verbose) fprintf(stderr, "Not Modify: [%s]\n", staticfile->path);
134         response = MHD_create_response_from_buffer(0, "", MHD_RESPMEM_PERSISTENT);
135         MHD_add_response_header(response, MHD_HTTP_HEADER_CACHE_CONTROL, session->cacheTimeout); // default one hour cache
136         MHD_add_response_header(response, MHD_HTTP_HEADER_ETAG, etagValue);
137         MHD_queue_response(connection, MHD_HTTP_NOT_MODIFIED, response);
138
139     } else { // it's a new file, we need to upload it to client
140         // if we have magic let's try to guest mime type
141         if (session->magic) {          
142            mimetype= magic_descriptor(session->magic, staticfile->fd);
143            if (mimetype != NULL)  MHD_add_response_header (response, MHD_HTTP_HEADER_CONTENT_TYPE, mimetype);
144         } else mimetype="application/unknown";
145         
146         if (verbose) fprintf(stderr, "Serving: [%s] mime=%s\n", staticfile->path, mimetype);
147         response = MHD_create_response_from_fd(sbuf.st_size, staticfile->fd);
148         MHD_add_response_header(response, MHD_HTTP_HEADER_CACHE_CONTROL, session->cacheTimeout); // default one hour cache
149         MHD_add_response_header(response, MHD_HTTP_HEADER_ETAG, etagValue);
150         MHD_queue_response(connection, MHD_HTTP_OK, response);
151     }
152     
153 sendRequest:    
154     MHD_destroy_response(response);
155     return (MHD_YES);
156
157 abortRequest:
158     return (FAILED);
159 }
160
161
162 // this function return either Index.htlm or a redirect to /#!route to make angular happy
163 STATIC int redirectHTML5(struct MHD_Connection *connection, AFB_session *session, const char* url) {
164
165     struct MHD_Response *response;
166     AFB_staticfile staticfile;
167
168     // Url match /opa/xxxx should redirect to "/opa/#!page" to force index.html reload
169     strncpy(staticfile.path, session->config->rootbase, sizeof (staticfile.path));
170     strncat(staticfile.path, "/#!", sizeof (staticfile.path));
171     strncat(staticfile.path, &url[1], sizeof (staticfile.path));
172     response = MHD_create_response_from_buffer(0,"", MHD_RESPMEM_PERSISTENT);
173     MHD_add_response_header (response, "Location", staticfile.path);
174     MHD_queue_response (connection, MHD_HTTP_MOVED_PERMANENTLY, response);
175     if (verbose) fprintf (stderr,"checkHTML5 redirect to [%s]\n",staticfile.path);
176     return (MHD_YES);
177 }
178
179
180 // minimal httpd file server for static HTML,JS,CSS,etc...
181 STATIC int requestFile(struct MHD_Connection *connection, AFB_session *session, const char* url) {
182     int ret, idx;
183     AFB_staticfile staticfile;
184     char *requestdir, *requesturl;
185    
186     // default search for file is rootdir base
187     requestdir= session->config->rootdir;
188     requesturl=(char*)url;
189     
190     // Check for optional aliases
191     for (idx=0; session->config->aliasdir[idx].url != NULL; idx++) {
192         if (0 == strncmp(url, session->config->aliasdir[idx].url, session->config->aliasdir[idx].len)) {
193              requestdir = session->config->aliasdir[idx].path;
194              requesturl=(char*)&url[session->config->aliasdir[idx].len];
195              break;
196         }
197     }
198     
199     // build full path from rootdir + url
200     strncpy(staticfile.path, requestdir, sizeof (staticfile.path));   
201     strncat(staticfile.path, requesturl, sizeof (staticfile.path));
202
203     // try to open file and get its size
204     if (-1 == (staticfile.fd = open(staticfile.path, O_RDONLY))) {
205         fprintf(stderr, "Fail to open file: [%s] error:%s\n", staticfile.path, strerror(errno));
206         return (FAILED);
207     }
208     // open file is OK let use it
209     ret = servFile (connection, session, url, &staticfile);
210     return ret;
211 }
212
213 // Check and Dispatch HTTP request
214 STATIC int newRequest(void *cls,
215         struct MHD_Connection *connection,
216         const char *url,
217         const char *method,
218         const char *version,
219         const char *upload_data, size_t *upload_data_size, void **con_cls) {
220
221     AFB_session *session = cls;
222     struct MHD_Response *response;
223     int ret;
224     
225     // this is a REST API let's check for plugins
226     if (0 == strncmp(url, session->config->rootapi, apiUrlLen)) {
227         ret = doRestApi(connection, session, &url[apiUrlLen+1], method, upload_data, upload_data_size, con_cls);
228         return ret;
229     }
230     
231     // From here only accept get request
232     if (0 != strcmp(method, MHD_HTTP_METHOD_GET)) return MHD_NO; /* unexpected method */
233    
234     // If a static file exist serve it now
235     ret = requestFile(connection, session, url);
236     if (ret != FAILED) return ret;
237     
238     // no static was served let's try HTML5 OPA redirect
239     if (0 == strncmp(url, session->config->rootbase, baseUrlLen)) {
240         ret = redirectHTML5(connection, session, &url[baseUrlLen]);
241         return ret;
242     }
243
244      // Nothing respond to this request Files, API, Angular Base
245     const char *errorstr = "<html><body>AFB-Daemon File Not Find file</body></html>";
246     response = MHD_create_response_from_buffer(strlen(errorstr), (void*)errorstr, MHD_RESPMEM_PERSISTENT);
247     ret = MHD_queue_response(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, response);
248     return (MHD_YES);
249 }
250
251 STATIC int newClient(void *cls, const struct sockaddr * addr, socklen_t addrlen) {
252     // check if client is coming from an acceptable IP
253     return (MHD_YES); // MHD_NO
254 }
255
256
257 PUBLIC AFB_error httpdStart(AFB_session *session) {
258
259     // compute fixed URL length at startup time
260     apiUrlLen = strlen (session->config->rootapi);
261     baseUrlLen= strlen (session->config->rootbase);
262     rootUrlLen= strlen (session->config->rootdir);
263     
264     // Initialise Client Session Hash Table
265     ctxStoreInit (CTX_NBCLIENTS);
266      
267     //TBD open libmagic cache [fail to pass EFENCE check (allocating 0 bytes)]
268     //initLibMagic (session);
269     
270     
271     if (verbose) {
272         printf("AFB:notice Waiting port=%d rootdir=%s\n", session->config->httpdPort, session->config->rootdir);
273         printf("AFB:notice Browser URL= http://localhost:%d\n", session->config->httpdPort);
274     }
275
276     session->httpd = (void*) MHD_start_daemon(
277                 MHD_USE_EPOLL_LINUX_ONLY
278                 | MHD_USE_TCP_FASTOPEN
279                 | MHD_USE_DEBUG
280               ,
281             (uint16_t)session->config->httpdPort, // port
282             &newClient, NULL, // Tcp Accept call back + extra attribute
283             &newRequest, session, // Http Request Call back + extra attribute
284             MHD_OPTION_NOTIFY_COMPLETED, &endRequest, NULL,
285             MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 15, // 15 seconds
286             MHD_OPTION_END); // options-end
287     // TBD: MHD_OPTION_SOCK_ADDR
288
289     if (session->httpd == NULL) {
290         printf("Error: httpStart invalid httpd port: %d", session->config->httpdPort);
291         return AFB_FATAL;
292     }
293     return AFB_SUCCESS;
294 }
295
296 // infinite loop
297 PUBLIC AFB_error httpdLoop(AFB_session *session) {
298     int count = 0;
299     const union MHD_DaemonInfo *info;
300     struct pollfd pfd;
301
302     info = MHD_get_daemon_info(session->httpd,
303                                MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY);
304     if (info == NULL) {
305         printf("Error: httpLoop no pollfd");
306         goto error;
307     }
308     pfd.fd = info->listen_fd;
309     pfd.events = POLLIN;
310
311     if (verbose) fprintf(stderr, "AFB:notice entering httpd waiting loop\n");
312     while (TRUE) {
313         if (verbose) fprintf(stderr, "AFB:notice httpd alive [%d]\n", count++);
314         poll(&pfd, 1, 15000); // 15 seconds (as above timeout when starting)
315         MHD_run(session->httpd);
316     }
317
318 error:
319     // should never return from here
320     return AFB_FATAL;
321 }
322
323 PUBLIC int httpdStatus(AFB_session *session) {
324     return (MHD_run(session->httpd));
325 }
326
327 PUBLIC void httpdStop(AFB_session *session) {
328     MHD_stop_daemon(session->httpd);
329 }