support of symbolic links to webfiles
[psensor.git] / src / server / server.c
1 /*
2  * Copyright (C) 2010-2011 jeanfi@gmail.com
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301 USA
18  */
19 #include <locale.h>
20 #include <libintl.h>
21 #define _(str) gettext(str)
22
23 #include "config.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <sys/select.h>
32 #include <sys/socket.h>
33 #include <getopt.h>
34 #include <stdint.h>
35 #include <pthread.h>
36 #include <unistd.h>
37 #include <microhttpd.h>
38
39 #ifdef HAVE_GTOP
40 #include "sysinfo.h"
41 #include "cpu.h"
42 #endif
43
44 #include "psensor_json.h"
45 #include "url.h"
46 #include "p_io.h"
47 #include "server.h"
48
49 static const char *program_name;
50
51 #define DEFAULT_PORT 3131
52
53 #define PAGE_NOT_FOUND (_("<html><body><p>\
54 Page not found - Go to <a href='/'>Main page</a>\
55 </p></body>"))
56
57 static struct option long_options[] = {
58         {"version", no_argument, 0, 'v'},
59         {"help", no_argument, 0, 'h'},
60         {"port", required_argument, 0, 'p'},
61         {"wdir", required_argument, 0, 'w'},
62         {"debug", no_argument, 0, 'd'},
63         {0, 0, 0, 0}
64 };
65
66 static struct server_data server_data;
67
68 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
69
70 static int debug;
71
72 static int server_stop_requested;
73
74 void print_version()
75 {
76         printf("psensor-server %s\n", VERSION);
77         printf(_("Copyright (C) %s jeanfi@gmail.com\n\
78 License GPLv2: GNU GPL version 2 or later \
79 <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>\n\
80 This is free software: you are free to change and redistribute it.\n\
81 There is NO WARRANTY, to the extent permitted by law.\n"),
82                "2010-2011");
83 }
84
85 void print_help()
86 {
87         printf(_("Usage: %s [OPTION]...\n"), program_name);
88
89         puts(_("psensor-server is an HTTP server "
90                "for monitoring hardware sensors remotely."));
91
92         puts("");
93         puts("Options:");
94         puts(_("\
95   -h, --help            display this help and exit\n\
96   -v, --version         display version information and exit"));
97
98         puts("");
99
100         puts(_("\
101   -d,--debug            run in debug mode\n\
102   -p,--port=PORT        webserver port\n\
103   -w,--wdir=DIR         directory containing webserver pages"));
104
105         puts("");
106
107         printf(_("Report bugs to: %s\n"), PACKAGE_BUGREPORT);
108         puts("");
109         printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
110 }
111
112 /*
113   Returns the file path corresponding to a given URL
114 */
115 char *get_path(const char *url, const char *www_dir)
116 {
117         const char *p;
118         char *res;
119
120         if (!strlen(url) || !strcmp(url, ".") || !strcmp(url, "/"))
121                 p = "/index.html";
122         else
123                 p = url;
124
125         res = malloc(strlen(www_dir)+strlen(p)+1);
126
127         strcpy(res, www_dir);
128         strcat(res, p);
129
130         return res;
131 }
132
133 #if MHD_VERSION >= 0x00090200
134 static ssize_t
135 file_reader(void *cls, uint64_t pos, char *buf, size_t max)
136 #else
137 static int
138 file_reader(void *cls, uint64_t pos, char *buf, int max)
139 #endif
140 {
141         FILE *file = cls;
142
143         fseek(file, pos, SEEK_SET);
144         return fread(buf, 1, max, file);
145 }
146
147 struct MHD_Response *
148 create_response_api(const char *nurl,
149                     const char *method,
150                     unsigned int *rp_code)
151 {
152         struct MHD_Response *resp;
153         struct psensor *s;
154         char *page = NULL;
155
156         if (!strcmp(nurl, URL_BASE_API_1_0_SENSORS))  {
157
158                 page = sensors_to_json_string(server_data.sensors);
159
160 #ifdef HAVE_GTOP
161         } else if (!strcmp(nurl, URL_API_1_0_SYSINFO)) {
162
163                 page = sysinfo_to_json_string(&server_data.psysinfo);
164         } else if (!strcmp(nurl, URL_API_1_0_CPU_USAGE)) {
165                 page = sensor_to_json_string(server_data.cpu_usage);
166 #endif
167         } else if (!strncmp(nurl, URL_BASE_API_1_0_SENSORS,
168                             strlen(URL_BASE_API_1_0_SENSORS))
169                    && nurl[strlen(URL_BASE_API_1_0_SENSORS)] == '/') {
170
171                 const char *sid = nurl + strlen(URL_BASE_API_1_0_SENSORS) + 1;
172
173                 s = psensor_list_get_by_id(server_data.sensors, sid);
174
175                 if (s)
176                         page = sensor_to_json_string(s);
177
178         } else if (debug && !strcmp(nurl, URL_API_1_0_SERVER_STOP)) {
179
180                 server_stop_requested = 1;
181                 page = strdup(_("<html><body><p>"
182                                 "Server stop requested</p></body></html>"));
183         }
184
185         if (page) {
186                 *rp_code = MHD_HTTP_OK;
187
188                 resp = MHD_create_response_from_data(strlen(page), page,
189                                                      MHD_YES, MHD_NO);
190
191                 MHD_add_response_header(resp, MHD_HTTP_HEADER_CONTENT_TYPE,
192                                         "application/json");
193
194                 return resp;
195         }
196
197         return NULL;
198 }
199
200 struct MHD_Response *
201 create_response_file(const char *nurl,
202                      const char *method,
203                      unsigned int *rp_code,
204                      const char *fpath)
205 {
206         struct stat st;
207         int ret;
208         FILE *file;
209
210         ret = stat(fpath, &st);
211
212         if (!ret && (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))) {
213                 file = fopen(fpath, "rb");
214
215                 if (file) {
216                         *rp_code = MHD_HTTP_OK;
217
218                         if (!st.st_size) {
219                                 fclose(file);
220                                 return MHD_create_response_from_data
221                                         (0, NULL, MHD_NO, MHD_NO);
222                         }
223
224                         return MHD_create_response_from_callback
225                                 (st.st_size,
226                                  32 * 1024,
227                                  &file_reader,
228                                  file,
229                                  (MHD_ContentReaderFreeCallback)&fclose);
230
231                 } else {
232                         log_printf(LOG_ERR, "Failed to open: %s\n", fpath);
233                 }
234         }
235
236         return NULL;
237 }
238
239 struct MHD_Response *
240 create_response(const char *nurl, const char *method, unsigned int *rp_code)
241 {
242         struct MHD_Response *resp = NULL;
243
244         if (!strncmp(nurl, URL_BASE_API_1_0, strlen(URL_BASE_API_1_0))) {
245                 resp = create_response_api(nurl, method, rp_code);
246         } else {
247                 char *fpath = get_path(nurl, server_data.www_dir);
248
249                 resp = create_response_file(nurl, method, rp_code, fpath);
250
251                 free(fpath);
252         }
253
254         if (resp) {
255                 return resp;
256         } else {
257                 char *page = strdup(PAGE_NOT_FOUND);
258                 *rp_code = MHD_HTTP_NOT_FOUND;
259
260                 return MHD_create_response_from_data
261                         (strlen(page), page, MHD_YES, MHD_NO);
262         }
263 }
264
265 static int
266 cbk_http_request(void *cls,
267                  struct MHD_Connection *connection,
268                  const char *url,
269                  const char *method,
270                  const char *version,
271                  const char *upload_data,
272                  size_t *upload_data_size, void **ptr)
273 {
274         static int dummy;
275         struct MHD_Response *response;
276         int ret;
277         char *nurl;
278         unsigned int resp_code;
279
280         if (strcmp(method, "GET"))
281                 return MHD_NO;
282
283         if (&dummy != *ptr) {
284                 /* The first time only the headers are valid, do not
285                    respond in the first round... */
286                 *ptr = &dummy;
287                 return MHD_YES;
288         }
289
290         if (*upload_data_size)
291                 return MHD_NO;
292
293         *ptr = NULL;            /* clear context pointer */
294
295         if (debug)
296                 printf(_("HTTP Request: %s\n"), url);
297
298         nurl = url_normalize(url);
299
300         pthread_mutex_lock(&mutex);
301         response = create_response(nurl, method, &resp_code);
302         pthread_mutex_unlock(&mutex);
303
304         ret = MHD_queue_response(connection, resp_code, response);
305         MHD_destroy_response(response);
306
307         free(nurl);
308
309         return ret;
310 }
311
312 int main(int argc, char *argv[])
313 {
314         struct MHD_Daemon *d;
315         int port = DEFAULT_PORT;
316         int optc;
317         int cmdok = 1;
318
319         program_name = argv[0];
320
321         setlocale(LC_ALL, "");
322
323 #if ENABLE_NLS
324         bindtextdomain(PACKAGE, LOCALEDIR);
325         textdomain(PACKAGE);
326 #endif
327
328         server_data.www_dir = DEFAULT_WWW_DIR;
329         server_data.psysinfo.interfaces = NULL;
330
331         while ((optc = getopt_long(argc, argv,
332                                    "vhp:w:d", long_options, NULL)) != -1) {
333                 switch (optc) {
334                 case 'w':
335                         if (optarg)
336                                 server_data.www_dir = strdup(optarg);
337                         break;
338                 case 'p':
339                         if (optarg)
340                                 port = atoi(optarg);
341                         break;
342                 case 'h':
343                         print_help();
344                         exit(EXIT_SUCCESS);
345                 case 'v':
346                         print_version();
347                         exit(EXIT_SUCCESS);
348                 case 'd':
349                         debug = 1;
350                         break;
351                 default:
352                         cmdok = 0;
353                         break;
354                 }
355         }
356
357         if (!cmdok || optind != argc) {
358                 fprintf(stderr, _("Try `%s --help' for more information.\n"),
359                         program_name);
360                 exit(EXIT_FAILURE);
361         }
362
363         psensor_init();
364
365         server_data.sensors = get_all_sensors(600);
366
367 #ifdef HAVE_GTOP
368         server_data.cpu_usage = create_cpu_usage_sensor(600);
369 #endif
370
371         if (!*server_data.sensors)
372                 fprintf(stderr, _("ERROR: no sensors detected\n"));
373
374         d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION,
375                              port,
376                              NULL, NULL, &cbk_http_request, server_data.sensors,
377                              MHD_OPTION_END);
378         if (!d) {
379                 fprintf(stderr, _("ERROR: Fail to create web server\n"));
380                 exit(EXIT_FAILURE);
381         }
382
383         log_printf(LOG_INFO, _("Web server started on port: %d"), port);
384         log_printf(LOG_INFO, _("WWW directory: %s"), server_data.www_dir);
385         log_printf(LOG_INFO, _("URL: http://localhost:%d"), port);
386
387         while (!server_stop_requested) {
388                 pthread_mutex_lock(&mutex);
389
390 #ifdef HAVE_GTOP
391                 sysinfo_update(&server_data.psysinfo);
392                 cpu_usage_sensor_update(server_data.cpu_usage);
393 #endif
394                 psensor_list_update_measures(server_data.sensors);
395
396                 pthread_mutex_unlock(&mutex);
397                 sleep(5);
398         }
399
400         MHD_stop_daemon(d);
401
402         /* sanity cleanup for valgrind */
403         psensor_list_free(server_data.sensors);
404 #ifdef HAVE_GTOP
405         psensor_free(server_data.cpu_usage);
406 #endif
407         free(server_data.www_dir);
408         sensors_cleanup();
409
410 #ifdef HAVE_GTOP
411         sysinfo_cleanup();
412         cpu_cleanup();
413 #endif
414
415         return EXIT_SUCCESS;
416 }