src/scripting/ruby/hooks.c

   1 /* Ruby scripting hooks */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <ruby.h>
   8
   9 #include "elinks.h"
  10
  11 #include "cache/cache.h"
  12 #include "main/event.h"
  13 #include "protocol/uri.h"
  14 #include "scripting/ruby/core.h"
  15 #include "scripting/ruby/hooks.h"
  16 #include "session/location.h"
  17 #include "session/session.h"
  18 #include "util/string.h"
  19
  20
  21 /* The events that will trigger the functions below and what they are expected
  22  * to do is explained in doc/events.txt */
  23
  24 /* We need to catch and handle errors because, otherwise, Ruby will kill us. */
  25
  26 struct erb_protect_info {
  27         unsigned char *name;
  28         int argc;
  29         VALUE *args;
  30 };
  31
  32 static VALUE
  33 do_erb_protected_method_call(VALUE data)
  34 {
  35         struct erb_protect_info *info = (struct erb_protect_info *) data;
  36         ID method_id;
  37
  38         assert(info);
  39
  40         method_id = rb_intern(info->name);
  41
  42         return rb_funcall3(erb_module, method_id, info->argc, info->args);
  43 }
  44
  45 static VALUE
  46 erb_protected_method_call(unsigned char *name, int argc, VALUE *args, int *error)
  47 {
  48         struct erb_protect_info info = { name, argc, args };
  49
  50         return rb_protect(do_erb_protected_method_call, (VALUE) &info, error);
  51 }
  52
  53
  54
  55 static enum evhook_status
  56 script_hook_goto_url(va_list ap, void *data)
  57 {
  58         unsigned char **url = va_arg(ap, unsigned char **);
  59         struct session *ses = va_arg(ap, struct session *);
  60         int error;
  61         VALUE args[2];
  62         VALUE result;
  63
  64         if (*url == NULL)
  65                 return EVENT_HOOK_STATUS_NEXT;
  66
  67         args[0] = rb_str_new(*url, strlen(*url));
  68
  69         if (!ses || !have_location(ses)) {
  70                 args[1] = Qnil;
  71         } else {
  72                 args[1] = rb_str_new(struri(cur_loc(ses)->vs.uri), strlen(struri(cur_loc(ses)->vs.uri)));
  73         }
  74
  75         result = erb_protected_method_call("goto_url_hook", 2, args, &error);
  76         if (error) {
  77                 erb_report_error(ses, error);
  78                 return EVENT_HOOK_STATUS_NEXT;
  79         }
  80
  81         switch (rb_type(result)) {
  82         case T_STRING:
  83         {
  84                 unsigned char *new_url;
  85
  86                 new_url = memacpy(RSTRING(result)->ptr, RSTRING(result)->len);
  87                 if (new_url) {
  88                         mem_free_set(url, new_url);
  89                 }
  90                 break;
  91         }
  92         case T_NIL:
  93                 break;
  94
  95         default:
  96                 alert_ruby_error(ses, "goto_url_hook must return a string or nil");
  97         }
  98
  99         return EVENT_HOOK_STATUS_NEXT;
 100 }
 101
 102 static enum evhook_status
 103 script_hook_follow_url(va_list ap, void *data)
 104 {
 105         unsigned char **url = va_arg(ap, unsigned char **);
 106         struct session *ses = va_arg(ap, struct session *);
 107         int error;
 108         VALUE args[1];
 109         VALUE result;
 110
 111         evhook_use_params(url && ses);
 112
 113         if (*url == NULL)
 114                 return EVENT_HOOK_STATUS_NEXT;
 115
 116         args[0] = rb_str_new(*url, strlen(*url));
 117
 118         result = erb_protected_method_call("follow_url_hook", 1, args, &error);
 119         if (error) {
 120                 erb_report_error(ses, error);
 121                 return EVENT_HOOK_STATUS_NEXT;
 122         }
 123
 124         switch (rb_type(result)) {
 125         case T_STRING:
 126         {
 127                 unsigned char *new_url;
 128
 129                 new_url = memacpy(RSTRING(result)->ptr, RSTRING(result)->len);
 130                 if (new_url) {
 131                         mem_free_set(url, new_url);
 132                 }
 133                 break;
 134         }
 135         case T_NIL:
 136                 break;
 137
 138         default:
 139                 alert_ruby_error(ses, "follow_url_hook must return a string or nil");
 140         }
 141
 142         return EVENT_HOOK_STATUS_NEXT;
 143 }
 144
 145 static enum evhook_status
 146 script_hook_pre_format_html(va_list ap, void *data)
 147 {
 148         struct session *ses = va_arg(ap, struct session *);
 149         struct cache_entry *cached = va_arg(ap, struct cache_entry *);
 150         struct fragment *fragment = get_cache_fragment(cached);
 151         unsigned char *url = struri(cached->uri);
 152         int error;
 153         VALUE args[2];
 154         VALUE result;
 155
 156         evhook_use_params(ses && cached);
 157
 158         if (!cached->length || !*fragment->data)
 159                 return EVENT_HOOK_STATUS_NEXT;
 160
 161         args[0] = rb_str_new2(url);
 162         args[1] = rb_str_new(fragment->data, fragment->length);
 163
 164         result = erb_protected_method_call("pre_format_html_hook", 2, args, &error);
 165         if (error) {
 166                 erb_report_error(ses, error);
 167                 return EVENT_HOOK_STATUS_NEXT;
 168         }
 169
 170         switch (rb_type(result)) {
 171         case T_STRING:
 172         {
 173                 int len = RSTRING(result)->len;
 174
 175                 add_fragment(cached, 0, RSTRING(result)->ptr, len);
 176                 normalize_cache_entry(cached, len);
 177
 178                 break;
 179         }
 180         case T_NIL:
 181                 break;
 182
 183         default:
 184                 alert_ruby_error(ses, "pre_format_html_hook must return a string or nil");
 185         }
 186
 187         return EVENT_HOOK_STATUS_NEXT;
 188 }
 189
 190 /* The Ruby function can return:
 191  *  - "PROXY:PORT" to use the specified proxy
 192  *  - ""           to not use any proxy
 193  *  - nil          to use the default proxies */
 194 static enum evhook_status
 195 script_hook_get_proxy(va_list ap, void *data)
 196 {
 197         unsigned char **new_proxy_url = va_arg(ap, unsigned char **);
 198         unsigned char *url = va_arg(ap, unsigned char *);
 199         int error;
 200         VALUE args[1];
 201         VALUE result;
 202
 203         if (!new_proxy_url || !url)
 204                 return EVENT_HOOK_STATUS_NEXT;
 205
 206         args[0] = rb_str_new(url, strlen(url));
 207
 208         result = erb_protected_method_call("proxy_hook", 1, args, &error);
 209         if (error) {
 210                 erb_report_error(NULL, error);
 211                 return EVENT_HOOK_STATUS_NEXT;
 212         }
 213
 214         switch (rb_type(result)) {
 215         case T_STRING:
 216         {
 217                 unsigned char *proxy;
 218
 219                 proxy = memacpy(RSTRING(result)->ptr, RSTRING(result)->len);
 220                 if (proxy) {
 221                         mem_free_set(new_proxy_url, proxy);
 222                 }
 223                 break;
 224         }
 225         case T_NIL:
 226                 break;
 227
 228         default:
 229                 alert_ruby_error(NULL, "proxy_hook must return a string or nil");
 230         }
 231
 232         return EVENT_HOOK_STATUS_NEXT;
 233 }
 234
 235 static enum evhook_status
 236 script_hook_quit(va_list ap, void *data)
 237 {
 238         VALUE args[1];
 239         int error;
 240
 241         erb_protected_method_call("quit_hook", 0, args, &error);
 242         if (error)
 243                 erb_report_error(NULL, error);
 244
 245         return EVENT_HOOK_STATUS_NEXT;
 246 }
 247
 248 struct event_hook_info ruby_scripting_hooks[] = {
 249         { "goto-url",        0, script_hook_goto_url,        NULL },
 250         { "follow-url",      0, script_hook_follow_url,      NULL },
 251         { "pre-format-html", 0, script_hook_pre_format_html, NULL },
 252         { "get-proxy",       0, script_hook_get_proxy,       NULL },
 253         { "quit",            0, script_hook_quit,            NULL },
 254
 255         NULL_EVENT_HOOK_INFO,
 256 };