227bea2ddfc8604acccadbc30dbc2a127cbff9fe
[asterisk/asterisk.git] / apps / app_curl.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C)  2004 - 2005, Tilghman Lesher
5  *
6  * Tilghman Lesher <curl-20050919@the-tilghman.com>
7  * and Brian Wilkins <bwilkins@cfl.rr.com> (Added POST option)
8  *
9  * app_curl.c is distributed with no restrictions on usage or
10  * redistribution.
11  *
12  * See http://www.asterisk.org for more information about
13  * the Asterisk project. Please do not directly contact
14  * any of the maintainers of this project for assistance;
15  * the project provides a web site, mailing lists and IRC
16  * channels for your use.
17  *
18  */
19
20 /*! \file
21  * \brief Curl - App to load a URL
22  * 
23  * \ingroup applications
24  */
25  
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <curl/curl.h>
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include "asterisk/lock.h"
36 #include "asterisk/file.h"
37 #include "asterisk/logger.h"
38 #include "asterisk/channel.h"
39 #include "asterisk/pbx.h"
40 #include "asterisk/cli.h"
41 #include "asterisk/options.h"
42 #include "asterisk/module.h"
43 #include "asterisk/app.h"
44
45 static char *tdesc = "Load external URL";
46
47 static char *app = "Curl";
48
49 static char *synopsis = "Load an external URL";
50
51 static char *descrip = 
52 "  Curl(URL[|postdata]): This application will request the specified URL.\n"
53 "It is mainly used for signalling external applications of an event.\n"
54 "Parameters:\n"
55 "  URL      - This is the external URL to request.\n"
56 "  postdata - This information will be treated as POST data.\n"
57 "This application will set the following variable:\n"
58 "  CURL - This variable will contain the resulting page.\n"
59 "This application has been deprecated in favor of the CURL function.\n";
60
61 STANDARD_LOCAL_USER;
62
63 LOCAL_USER_DECL;
64
65 struct MemoryStruct {
66         char *memory;
67         size_t size;
68 };
69
70 static void *myrealloc(void *ptr, size_t size)
71 {
72         /* There might be a realloc() out there that doesn't like reallocing
73            NULL pointers, so we take care of it here */
74         if (ptr)
75                 return realloc(ptr, size);
76         else
77                 return malloc(size);
78 }
79
80 static size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
81 {
82         register int realsize = size * nmemb;
83         struct MemoryStruct *mem = (struct MemoryStruct *)data;
84
85         mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
86         if (mem->memory) {
87                 memcpy(&(mem->memory[mem->size]), ptr, realsize);
88                 mem->size += realsize;
89                 mem->memory[mem->size] = 0;
90         }
91         return realsize;
92 }
93
94 static int curl_internal(struct MemoryStruct *chunk, char *url, char *post)
95 {
96         CURL *curl;
97
98         curl_global_init(CURL_GLOBAL_ALL);
99         curl = curl_easy_init();
100
101         if (!curl) {
102                 return -1;
103         }
104
105         curl_easy_setopt(curl, CURLOPT_URL, url);
106         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
107         curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)chunk);
108         curl_easy_setopt(curl, CURLOPT_USERAGENT, "asterisk-libcurl-agent/1.0");
109
110         if (post) {
111                 curl_easy_setopt(curl, CURLOPT_POST, 1);
112                 curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post);
113         }
114
115         curl_easy_perform(curl);
116         curl_easy_cleanup(curl);
117         return 0;
118 }
119
120 static int curl_exec(struct ast_channel *chan, void *data)
121 {
122         int res = 0;
123         struct localuser *u;
124         char *info;
125         struct MemoryStruct chunk = { NULL, 0 };
126         static int dep_warning = 0;
127         AST_DECLARE_APP_ARGS(args,
128                 AST_APP_ARG(url);
129                 AST_APP_ARG(postdata);
130         );
131         
132         if (!dep_warning) {
133                 ast_log(LOG_WARNING, "The application Curl is deprecated.  Please use the CURL() function instead.\n");
134                 dep_warning = 1;
135         }
136
137         if (ast_strlen_zero(data)) {
138                 ast_log(LOG_WARNING, "Curl requires an argument (URL)\n");
139                 return -1;
140         }
141         
142         LOCAL_USER_ADD(u);
143         
144         if ((info = ast_strdupa(data))) {
145                 AST_STANDARD_APP_ARGS(args, info);
146         } else {
147                 ast_log(LOG_ERROR, "Out of memory\n");
148                 LOCAL_USER_REMOVE(u);
149                 return -1;
150         }
151
152         if (! curl_internal(&chunk, args.url, args.postdata)) {
153                 if (chunk.memory) {
154                         chunk.memory[chunk.size] = '\0';
155                         if (chunk.memory[chunk.size - 1] == 10)
156                                 chunk.memory[chunk.size - 1] = '\0';
157
158                         pbx_builtin_setvar_helper(chan, "CURL", chunk.memory);
159
160                         free(chunk.memory);
161                 }
162         } else {
163                 ast_log(LOG_ERROR, "Cannot allocate curl structure\n");
164                 res = -1;
165         }
166
167         LOCAL_USER_REMOVE(u);
168         return res;
169 }
170
171 static char *acf_curl_exec(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
172 {
173         struct localuser *u;
174         char *info;
175         struct MemoryStruct chunk = { NULL, 0 };
176         AST_DECLARE_APP_ARGS(args,
177                 AST_APP_ARG(url);
178                 AST_APP_ARG(postdata);
179         );
180
181         *buf = '\0';
182         
183         if (ast_strlen_zero(data)) {
184                 ast_log(LOG_WARNING, "CURL requires an argument (URL)\n");
185                 return buf;
186         }
187
188         LOCAL_USER_ACF_ADD(u);
189
190         info = ast_strdupa(data);
191         if (!info) {
192                 ast_log(LOG_ERROR, "Out of memory\n");
193                 LOCAL_USER_REMOVE(u);
194                 return buf;
195         }
196
197         AST_STANDARD_APP_ARGS(args, info);      
198         
199         if (! curl_internal(&chunk, args.url, args.postdata)) {
200                 if (chunk.memory) {
201                         chunk.memory[chunk.size] = '\0';
202                         if (chunk.memory[chunk.size - 1] == 10)
203                                 chunk.memory[chunk.size - 1] = '\0';
204
205                         ast_copy_string(buf, chunk.memory, len);
206                         free(chunk.memory);
207                 }
208         } else {
209                 ast_log(LOG_ERROR, "Cannot allocate curl structure\n");
210         }
211
212         LOCAL_USER_REMOVE(u);
213         return buf;
214 }
215
216 struct ast_custom_function acf_curl = {
217         .name = "CURL",
218         .synopsis = "Retrieves the contents of a URL",
219         .syntax = "CURL(url[|post-data])",
220         .desc =
221         "  url       - URL to retrieve\n"
222         "  post-data - Optional data to send as a POST (GET is default action)\n",
223         .read = acf_curl_exec,
224 };
225
226 int unload_module(void)
227 {
228         int res;
229
230         res = ast_custom_function_unregister(&acf_curl);
231         res |= ast_unregister_application(app);
232
233         STANDARD_HANGUP_LOCALUSERS;
234         
235         return res;
236 }
237
238 int load_module(void)
239 {
240         int res;
241
242         res = ast_custom_function_register(&acf_curl);
243         res |= ast_register_application(app, curl_exec, synopsis, descrip);
244
245         return res;
246 }
247
248 char *description(void)
249 {
250         return tdesc;
251 }
252
253 int usecount(void)
254 {
255         int res;
256         STANDARD_USECOUNT(res);
257         return res;
258 }
259
260 char *key()
261 {
262         return ASTERISK_GPL_KEY;
263 }