src/scripting/python/hooks.c

   1 /* Python scripting hooks */
   2 /* $Id: hooks.c,v 1.10 2005/06/30 15:10:04 witekfl Exp $ */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include "scripting/python/core.h"
   9
  10 #include "elinks.h"
  11
  12 #include "main/event.h"
  13 #include "protocol/uri.h"
  14 #include "scripting/python/hooks.h"
  15 #include "session/location.h"
  16 #include "session/session.h"
  17 #include "util/string.h"
  18
  19 /* The events that will trigger the functions below and what they are expected
  20  * to do is explained in doc/events.txt */
  21
  22 static void
  23 do_script_hook_goto_url(struct session *ses, unsigned char **url)
  24 {
  25         PyObject *pFunc = PyDict_GetItemString(pDict, "goto_url_hook");
  26
  27         if (pFunc && PyCallable_Check(pFunc)) {
  28                 PyObject *pValue;
  29                 unsigned char *str;
  30
  31                 if (!ses || !have_location(ses)) {
  32                         str = NULL;
  33                 } else {
  34                         str = struri(cur_loc(ses)->vs.uri);
  35                 }
  36                 pValue = PyObject_CallFunction(pFunc, "s", str);
  37                 if (pValue && (pValue != Py_None)) {
  38                         const unsigned char *res = PyString_AsString(pValue);
  39
  40                         if (res) {
  41                                 unsigned char *new_url = stracpy((unsigned char *)res);
  42
  43                                 if (new_url) mem_free_set(url, new_url);
  44                         }
  45                         Py_DECREF(pValue);
  46                 } else {
  47                         if (PyErr_Occurred()) {
  48                                 PyErr_Print();
  49                                 PyErr_Clear();
  50                         }
  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
  61         if (pDict && *url)
  62                 do_script_hook_goto_url(ses, url);
  63
  64         return EVENT_HOOK_STATUS_NEXT;
  65 }
  66
  67 static void
  68 do_script_hook_follow_url(unsigned char **url)
  69 {
  70         PyObject *pFunc = PyDict_GetItemString(pDict, "follow_url_hook");
  71
  72         if (pFunc && PyCallable_Check(pFunc)) {
  73                 PyObject *pValue = PyObject_CallFunction(pFunc, "s", *url);
  74                 if (pValue && (pValue != Py_None)) {
  75                         const unsigned char *str = PyString_AsString(pValue);
  76                         unsigned char *new_url;
  77
  78                         if (str) {
  79                                 new_url = stracpy((unsigned char *)str);
  80                                 if (new_url) mem_free_set(url, new_url);
  81                         }
  82                         Py_DECREF(pValue);
  83                 } else {
  84                         if (PyErr_Occurred()) {
  85                                 PyErr_Print();
  86                                 PyErr_Clear();
  87                         }
  88                 }
  89         }
  90 }
  91
  92 static enum evhook_status
  93 script_hook_follow_url(va_list ap, void *data)
  94 {
  95         unsigned char **url = va_arg(ap, unsigned char **);
  96
  97         if (pDict && *url)
  98                 do_script_hook_follow_url(url);
  99
 100         return EVENT_HOOK_STATUS_NEXT;
 101 }
 102
 103 static void
 104 do_script_hook_pre_format_html(unsigned char *url, unsigned char **html,
 105                                int *html_len)
 106 {
 107         PyObject *pFunc = PyDict_GetItemString(pDict, "pre_format_html_hook");
 108
 109         if (pFunc && PyCallable_Check(pFunc)) {
 110                 PyObject *pValue = PyObject_CallFunction(pFunc, "ss", url, *html);
 111
 112                 if (pValue && (pValue != Py_None)) {
 113                         const unsigned char *str = PyString_AsString(pValue);
 114
 115                         if (str) {
 116                                 *html_len = PyString_Size(pValue); /* strlen(str); */
 117                                 *html = memacpy((unsigned char *)str, *html_len);
 118                                 /* Isn't a memleak here? --witekfl */
 119                                 if (!*html) *html_len = 0;
 120                         }
 121                         Py_DECREF(pValue);
 122                 } else {
 123                         if (PyErr_Occurred()) {
 124                                 PyErr_Print();
 125                                 PyErr_Clear();
 126                         }
 127                 }
 128         }
 129 }
 130
 131 static enum evhook_status
 132 script_hook_pre_format_html(va_list ap, void *data)
 133 {
 134         unsigned char **html = va_arg(ap, unsigned char **);
 135         int *html_len = va_arg(ap, int *);
 136         struct session *ses = va_arg(ap, struct session *);
 137         unsigned char *url = va_arg(ap, unsigned char *);
 138
 139         if (pDict && ses && url && *html && *html_len)
 140                 do_script_hook_pre_format_html(url, html, html_len);
 141
 142         return EVENT_HOOK_STATUS_NEXT;
 143 }
 144
 145 static inline void
 146 do_script_hook_get_proxy(unsigned char **new_proxy_url, unsigned char *url)
 147 {
 148         PyObject *pFunc = PyDict_GetItemString(pDict, "proxy_for_hook");
 149
 150         if (pFunc && PyCallable_Check(pFunc)) {
 151                 PyObject *pValue = PyObject_CallFunction(pFunc, "s", url);
 152
 153                 if (pValue && (pValue != Py_None)) {
 154                         const unsigned char *str = PyString_AsString(pValue);
 155
 156                         if (str) {
 157                                 unsigned char *new_url = stracpy((unsigned char *)str);
 158
 159                                 if (new_url) mem_free_set(new_proxy_url, new_url);
 160                         }
 161                         Py_DECREF(pValue);
 162                 } else {
 163                         if (PyErr_Occurred()) {
 164                                 PyErr_Print();
 165                                 PyErr_Clear();
 166                         }
 167                 }
 168         }
 169 }
 170
 171 static enum evhook_status
 172 script_hook_get_proxy(va_list ap, void *data)
 173 {
 174         unsigned char **new_proxy_url = va_arg(ap, unsigned char **);
 175         unsigned char *url = va_arg(ap, unsigned char *);
 176
 177         if (pDict && new_proxy_url && url)
 178                 do_script_hook_get_proxy(new_proxy_url, url);
 179
 180         return EVENT_HOOK_STATUS_NEXT;
 181 }
 182
 183 static void
 184 do_script_hook_quit(void)
 185 {
 186         PyObject *pFunc = PyDict_GetItemString(pDict, "quit_hook");
 187
 188         if (pFunc && PyCallable_Check(pFunc)) {
 189                 PyObject *pValue = PyObject_CallFunction(pFunc, NULL);
 190
 191                 if (pValue) {
 192                         if (pValue != Py_None) {
 193                                 Py_DECREF(pValue);
 194                         }
 195                 } else {
 196                         if (PyErr_Occurred()) {
 197                                 PyErr_Print();
 198                                 PyErr_Clear();
 199                         }
 200                 }
 201         }
 202 }
 203
 204 static enum evhook_status
 205 script_hook_quit(va_list ap, void *data)
 206 {
 207         if (pDict) do_script_hook_quit();
 208         return EVENT_HOOK_STATUS_NEXT;
 209 }
 210
 211 struct event_hook_info python_scripting_hooks[] = {
 212         { "goto-url", 0, script_hook_goto_url, NULL },
 213         { "follow-url", 0, script_hook_follow_url, NULL },
 214         { "pre-format-html", 0, script_hook_pre_format_html, NULL },
 215         { "get-proxy", 0, script_hook_get_proxy, NULL },
 216         { "quit", 0, script_hook_quit, NULL },
 217         NULL_EVENT_HOOK_INFO,
 218 };