git.maemo.org Git - browser-switch/blob - main.c

   1 /*
   2  * main.c -- config file parsing and main loop for browser-switchboard
   3  *
   4  * Copyright (C) 2009 Steven Luo
   5  * Derived from a Python implementation by Jason Simpson and Steven Luo
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <signal.h>
  28 #include <sys/types.h>
  29 #include <sys/wait.h>
  30 #include <regex.h>
  31 #include <dbus/dbus-glib.h>
  32
  33 #include "browser-switchboard.h"
  34 #include "launcher.h"
  35 #include "dbus-server-bindings.h"
  36
  37 #define DEFAULT_HOMEDIR "/home/user"
  38 #define CONFIGFILE_LOC "/.config/browser-switchboard"
  39 #define MAXLINE 1024
  40
  41 struct swb_context ctx;
  42
  43 static void set_config_defaults(struct swb_context *ctx) {
  44         if (!ctx)
  45                 return;
  46         free(ctx->other_browser_cmd);
  47         ctx->continuous_mode = 0;
  48         ctx->default_browser_launcher = NULL;
  49         ctx->other_browser_cmd = NULL;
  50 }
  51
  52 static void waitforzombies(int signalnum) {
  53         while (waitpid(-1, NULL, WNOHANG) > 0)
  54                 printf("Waited for a zombie\n");
  55 }
  56
  57 static void read_config(int signalnum) {
  58         char *homedir, *configfile;
  59         size_t len;
  60         char buf[MAXLINE];
  61         char *key, *value;
  62         char *default_browser = NULL;
  63         FILE *fp;
  64         regex_t re_ignore, re_config1, re_config2;
  65         regmatch_t substrs[3];
  66
  67         set_config_defaults(&ctx);
  68
  69         if (!(homedir = getenv("HOME")))
  70                 homedir = DEFAULT_HOMEDIR;
  71         len = strlen(homedir) + strlen(CONFIGFILE_LOC) + 1;
  72         if (!(configfile = calloc(len, sizeof(char))))
  73                 goto out_noopen;
  74         snprintf(configfile, len, "%s%s", homedir, CONFIGFILE_LOC);
  75
  76         if (!(fp = fopen(configfile, "r")))
  77                 goto out_noopen;
  78
  79         /* compile regex matching blank lines or comments */
  80         if (regcomp(&re_ignore, "^[[:space:]]*(#|$)", REG_EXTENDED|REG_NOSUB))
  81                 goto out_nore;
  82         /* compile regex matching foo = "bar", with arbitrary whitespace at
  83            beginning and end of line and surrounding the = */
  84         if (regcomp(&re_config1,
  85                     "^[[:space:]]*([^=[:space:]]+)[[:space:]]*=[[:space:]]*\"(.*)\"[[:space:]]*$",
  86                     REG_EXTENDED)) {
  87                 regfree(&re_ignore);
  88                 goto out_nore;
  89         }
  90         /* compile regex matching foo = bar, with arbitrary whitespace at
  91            beginning of line and surrounding the = */
  92         if (regcomp(&re_config2,
  93                     "^[[:space:]]*([^=[:space:]]+)[[:space:]]*=[[:space:]]*(.*)$",
  94                     REG_EXTENDED|REG_NEWLINE)) {
  95                 regfree(&re_ignore);
  96                 regfree(&re_config1);
  97                 goto out_nore;
  98         }
  99
 100         /* Read in the config file one line at a time and parse it
 101            XXX doesn't deal with lines longer than MAXLINE */
 102         while (fgets(buf, MAXLINE, fp)) {
 103                 printf("%s", buf);
 104                 /* skip blank lines and comments */
 105                 if (!regexec(&re_ignore, buf, 0, NULL, 0))
 106                         continue;
 107
 108                 /* Find the substrings corresponding to the key and value
 109                    If the line doesn't match our idea of a config file entry,
 110                    skip it */
 111                 if (regexec(&re_config1, buf, 3, substrs, 0) &&
 112                     regexec(&re_config2, buf, 3, substrs, 0))
 113                         continue;
 114                 if (substrs[1].rm_so == -1 || substrs[2].rm_so == -1)
 115                         continue;
 116
 117                 /* copy the config value into a new string */
 118                 len = substrs[2].rm_eo - substrs[2].rm_so;
 119                 if (!(value = calloc(len+1, sizeof(char))))
 120                         goto out;
 121                 strncpy(value, buf+substrs[2].rm_so, len);
 122                 /* calloc() zeroes the memory, so string is automatically
 123                    null terminated */
 124
 125                 /* make key point to a null-terminated string holding the
 126                    config key */
 127                 key = buf + substrs[1].rm_so;
 128                 buf[substrs[1].rm_eo] = '\0';
 129
 130                 if (!strcmp(key, "continuous_mode")) {
 131                         ctx.continuous_mode = atoi(value);
 132                         free(value);
 133                 } else if (!strcmp(key, "default_browser")) {
 134                         if (!default_browser)
 135                                 default_browser = value;
 136                 } else if (!strcmp(key, "other_browser_cmd")) {
 137                         if (!ctx.other_browser_cmd)
 138                                 ctx.other_browser_cmd = value;
 139                 } else {
 140                         /* Don't need this line's contents */
 141                         free(value);
 142                 }
 143                 value = NULL;
 144         }
 145
 146         printf("continuous_mode: %d\n", ctx.continuous_mode);
 147         printf("default_browser: '%s'\n", default_browser?default_browser:"NULL");
 148         printf("other_browser_cmd: '%s'\n", ctx.other_browser_cmd?ctx.other_browser_cmd:"NULL");
 149
 150 out:
 151         regfree(&re_ignore);
 152         regfree(&re_config1);
 153         regfree(&re_config2);
 154 out_nore:
 155         fclose(fp);
 156 out_noopen:
 157         update_default_browser(&ctx, default_browser);
 158         free(configfile);
 159         free(default_browser);
 160         return;
 161 }
 162
 163 int main() {
 164         OssoBrowser *obj;
 165         GMainLoop *mainloop;
 166         GError *error = NULL;
 167
 168         read_config(0);
 169
 170         if (ctx.continuous_mode) {
 171                 struct sigaction act;
 172                 act.sa_flags = SA_RESTART;
 173
 174                 act.sa_handler = waitforzombies;
 175                 if (sigaction(SIGCHLD, &act, NULL) == -1) {
 176                         printf("Installing signal handler failed\n");
 177                         return 1;
 178                 }
 179
 180                 act.sa_handler = read_config;
 181                 if (sigaction(SIGHUP, &act, NULL) == -1) {
 182                         printf("Installing signal handler failed\n");
 183                         return 1;
 184                 }
 185         }
 186
 187         g_type_init();
 188
 189         dbus_g_object_type_install_info(OSSO_BROWSER_TYPE,
 190                         &dbus_glib_osso_browser_object_info);
 191
 192         ctx.session_bus = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
 193         if (!ctx.session_bus) {
 194                 printf("Couldn't get a D-Bus bus connection\n");
 195                 return 1;
 196         }
 197         ctx.dbus_proxy = dbus_g_proxy_new_for_name(ctx.session_bus,
 198                         "org.freedesktop.DBus", "/org/freedesktop/DBus",
 199                         "org.freedesktop.DBus");
 200         if (!ctx.dbus_proxy) {
 201                 printf("Couldn't get an org.freedesktop.DBus proxy\n");
 202                 return 1;
 203         }
 204
 205         dbus_request_osso_browser_name(&ctx);
 206
 207         obj = g_object_new(OSSO_BROWSER_TYPE, NULL);
 208         dbus_g_connection_register_g_object(ctx.session_bus,
 209                         "/com/nokia/osso_browser", G_OBJECT(obj));
 210         dbus_g_connection_register_g_object(ctx.session_bus,
 211                         "/com/nokia/osso_browser/request", G_OBJECT(obj));
 212
 213         mainloop = g_main_loop_new(NULL, FALSE);
 214         printf("Starting main loop\n");
 215         g_main_loop_run(mainloop);
 216         printf("Main loop completed\n");
 217
 218         return 0;
 219 }