1 | /* Copyright 2009, UCAR/Unidata and OPeNDAP, Inc. |
---|
2 | See the COPYRIGHT file for more information. */ |
---|
3 | |
---|
4 | #include "config.h" |
---|
5 | #include <sys/stat.h> |
---|
6 | #ifdef HAVE_UNISTD_H |
---|
7 | #include <unistd.h> |
---|
8 | #endif |
---|
9 | #include <fcntl.h> |
---|
10 | #include "ocinternal.h" |
---|
11 | #include "ocdebug.h" |
---|
12 | #include "ochttp.h" |
---|
13 | #include "ocrc.h" |
---|
14 | |
---|
15 | static size_t WriteFileCallback(void*, size_t, size_t, void*); |
---|
16 | static size_t WriteMemoryCallback(void*, size_t, size_t, void*); |
---|
17 | |
---|
18 | struct Fetchdata { |
---|
19 | FILE* stream; |
---|
20 | size_t size; |
---|
21 | }; |
---|
22 | |
---|
23 | long |
---|
24 | ocfetchhttpcode(CURL* curl) |
---|
25 | { |
---|
26 | long httpcode; |
---|
27 | CURLcode cstat = CURLE_OK; |
---|
28 | /* Extract the http code */ |
---|
29 | cstat = curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&httpcode); |
---|
30 | if(cstat != CURLE_OK) httpcode = 0; |
---|
31 | return httpcode; |
---|
32 | } |
---|
33 | |
---|
34 | int |
---|
35 | ocfetchurl_file(CURL* curl, const char* url, FILE* stream, |
---|
36 | unsigned long* sizep, long* filetime) |
---|
37 | { |
---|
38 | int stat = OC_NOERR; |
---|
39 | CURLcode cstat = CURLE_OK; |
---|
40 | struct Fetchdata fetchdata; |
---|
41 | |
---|
42 | /* Set the URL */ |
---|
43 | cstat = curl_easy_setopt(curl, CURLOPT_URL, (void*)url); |
---|
44 | if (cstat != CURLE_OK) |
---|
45 | goto fail; |
---|
46 | |
---|
47 | /* send all data to this function */ |
---|
48 | cstat = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteFileCallback); |
---|
49 | if (cstat != CURLE_OK) |
---|
50 | goto fail; |
---|
51 | |
---|
52 | /* we pass our file to the callback function */ |
---|
53 | cstat = curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&fetchdata); |
---|
54 | if (cstat != CURLE_OK) |
---|
55 | goto fail; |
---|
56 | |
---|
57 | /* One last thing; always try to get the last modified time */ |
---|
58 | cstat = curl_easy_setopt(curl, CURLOPT_FILETIME, (long)1); |
---|
59 | if (cstat != CURLE_OK) |
---|
60 | goto fail; |
---|
61 | |
---|
62 | fetchdata.stream = stream; |
---|
63 | fetchdata.size = 0; |
---|
64 | cstat = curl_easy_perform(curl); |
---|
65 | if (cstat != CURLE_OK) |
---|
66 | goto fail; |
---|
67 | |
---|
68 | if (stat == OC_NOERR) { |
---|
69 | /* return the file size*/ |
---|
70 | #ifdef OCDEBUG |
---|
71 | oc_log(LOGNOTE,"filesize: %lu bytes",fetchdata.size); |
---|
72 | #endif |
---|
73 | if (sizep != NULL) |
---|
74 | *sizep = fetchdata.size; |
---|
75 | /* Get the last modified time */ |
---|
76 | if(filetime != NULL) |
---|
77 | cstat = curl_easy_getinfo(curl,CURLINFO_FILETIME,filetime); |
---|
78 | if(cstat != CURLE_OK) goto fail; |
---|
79 | } |
---|
80 | return OCTHROW(stat); |
---|
81 | |
---|
82 | fail: |
---|
83 | oc_log(LOGERR, "curl error: %s", curl_easy_strerror(cstat)); |
---|
84 | return OCTHROW(OC_ECURL); |
---|
85 | } |
---|
86 | |
---|
87 | int |
---|
88 | ocfetchurl(CURL* curl, const char* url, OCbytes* buf, long* filetime) |
---|
89 | { |
---|
90 | int stat = OC_NOERR; |
---|
91 | CURLcode cstat = CURLE_OK; |
---|
92 | size_t len; |
---|
93 | |
---|
94 | /* Set the URL */ |
---|
95 | cstat = curl_easy_setopt(curl, CURLOPT_URL, (void*)url); |
---|
96 | if (cstat != CURLE_OK) |
---|
97 | goto fail; |
---|
98 | |
---|
99 | /* send all data to this function */ |
---|
100 | cstat = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); |
---|
101 | if (cstat != CURLE_OK) |
---|
102 | goto fail; |
---|
103 | |
---|
104 | /* we pass our file to the callback function */ |
---|
105 | cstat = curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buf); |
---|
106 | if (cstat != CURLE_OK) |
---|
107 | goto fail; |
---|
108 | |
---|
109 | /* One last thing; always try to get the last modified time */ |
---|
110 | cstat = curl_easy_setopt(curl, CURLOPT_FILETIME, (long)1); |
---|
111 | |
---|
112 | cstat = curl_easy_perform(curl); |
---|
113 | if(cstat == CURLE_PARTIAL_FILE) { |
---|
114 | /* Log it but otherwise ignore */ |
---|
115 | oc_log(LOGWARN, "curl error: %s; ignored", |
---|
116 | curl_easy_strerror(cstat)); |
---|
117 | cstat = CURLE_OK; |
---|
118 | } |
---|
119 | if(cstat != CURLE_OK) goto fail; |
---|
120 | |
---|
121 | /* Get the last modified time */ |
---|
122 | if(filetime != NULL) |
---|
123 | cstat = curl_easy_getinfo(curl,CURLINFO_FILETIME,filetime); |
---|
124 | if(cstat != CURLE_OK) goto fail; |
---|
125 | |
---|
126 | /* Null terminate the buffer*/ |
---|
127 | len = ocbyteslength(buf); |
---|
128 | ocbytesappend(buf, '\0'); |
---|
129 | ocbytessetlength(buf, len); /* dont count null in buffer size*/ |
---|
130 | #ifdef OCDEBUG |
---|
131 | oc_log(LOGNOTE,"buffersize: %lu bytes",(unsigned long)ocbyteslength(buf)); |
---|
132 | #endif |
---|
133 | |
---|
134 | return OCTHROW(stat); |
---|
135 | |
---|
136 | fail: |
---|
137 | oc_log(LOGERR, "curl error: %s", curl_easy_strerror(cstat)); |
---|
138 | return OCTHROW(OC_ECURL); |
---|
139 | } |
---|
140 | |
---|
141 | static size_t |
---|
142 | WriteFileCallback(void* ptr, size_t size, size_t nmemb, void* data) |
---|
143 | { |
---|
144 | size_t realsize = size * nmemb; |
---|
145 | size_t count; |
---|
146 | struct Fetchdata* fetchdata; |
---|
147 | fetchdata = (struct Fetchdata*) data; |
---|
148 | if(realsize == 0) |
---|
149 | oc_log(LOGWARN,"WriteFileCallback: zero sized chunk"); |
---|
150 | count = fwrite(ptr, size, nmemb, fetchdata->stream); |
---|
151 | if (count > 0) { |
---|
152 | fetchdata->size += (count * size); |
---|
153 | } else { |
---|
154 | oc_log(LOGWARN,"WriteFileCallback: zero sized write"); |
---|
155 | } |
---|
156 | #ifdef OCPROGRESS |
---|
157 | oc_log(LOGNOTE,"callback: %lu bytes",(unsigned long)realsize); |
---|
158 | #endif |
---|
159 | return count; |
---|
160 | } |
---|
161 | |
---|
162 | static size_t |
---|
163 | WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data) |
---|
164 | { |
---|
165 | size_t realsize = size * nmemb; |
---|
166 | OCbytes* buf = (OCbytes*) data; |
---|
167 | if(realsize == 0) |
---|
168 | oc_log(LOGWARN,"WriteMemoryCallback: zero sized chunk"); |
---|
169 | /* Optimize for reading potentially large dods datasets */ |
---|
170 | if(!ocbytesavail(buf,realsize)) { |
---|
171 | /* double the size of the packet */ |
---|
172 | ocbytessetalloc(buf,2*ocbytesalloc(buf)); |
---|
173 | } |
---|
174 | ocbytesappendn(buf, ptr, realsize); |
---|
175 | #ifdef OCPROGRESS |
---|
176 | oc_log(LOGNOTE,"callback: %lu bytes",(unsigned long)realsize); |
---|
177 | #endif |
---|
178 | return realsize; |
---|
179 | } |
---|
180 | |
---|
181 | #if 0 |
---|
182 | static void |
---|
183 | assembleurl(DAPURL* durl, OCbytes* buf, int what) |
---|
184 | { |
---|
185 | encodeurltext(durl->url,buf); |
---|
186 | if(what & WITHPROJ) { |
---|
187 | ocbytescat(buf,"?"); |
---|
188 | encodeurltext(durl->projection,buf); |
---|
189 | } |
---|
190 | if(what & WITHSEL) encodeurltext(durl->selection,buf); |
---|
191 | |
---|
192 | } |
---|
193 | |
---|
194 | static char mustencode=""; |
---|
195 | static char hexchars[16] = { |
---|
196 | '0', '1', '2', '3', |
---|
197 | '4', '5', '6', '7', |
---|
198 | '8', '9', 'a', 'b', |
---|
199 | 'c', 'd', 'e', 'f', |
---|
200 | }; |
---|
201 | |
---|
202 | static void |
---|
203 | encodeurltext(char* text, OCbytes* buf) |
---|
204 | { |
---|
205 | /* Encode the URL to handle illegal characters */ |
---|
206 | len = strlen(url); |
---|
207 | encoded = ocmalloc(len*4+1); /* should never be larger than this*/ |
---|
208 | if(encoded==NULL) return; |
---|
209 | p = url; q = encoded; |
---|
210 | while((c=*p++)) { |
---|
211 | if(strchr(mustencode,c) != NULL) { |
---|
212 | char tmp[8]; |
---|
213 | int hex1, hex2; |
---|
214 | hex1 = (c & 0x0F); |
---|
215 | hex2 = (c & 0xF0) >> 4; |
---|
216 | tmp[0] = '0'; tmp[1] = 'x'; |
---|
217 | tmp[2] = hexchars[hex2]; tmp[3] = hexchars[hex1]; |
---|
218 | tmp[4] = '\0'; |
---|
219 | ocbytescat(buf,tmp); |
---|
220 | } else *q++ = (char)c; |
---|
221 | } |
---|
222 | |
---|
223 | } |
---|
224 | |
---|
225 | #endif |
---|
226 | |
---|
227 | int |
---|
228 | occurlopen(CURL** curlp) |
---|
229 | { |
---|
230 | int stat = OC_NOERR; |
---|
231 | CURLcode cstat = CURLE_OK; |
---|
232 | CURL* curl; |
---|
233 | /* initialize curl*/ |
---|
234 | curl = curl_easy_init(); |
---|
235 | if (curl == NULL) |
---|
236 | stat = OC_ECURL; |
---|
237 | else { |
---|
238 | cstat = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1); |
---|
239 | if (cstat != CURLE_OK) |
---|
240 | stat = OC_ECURL; |
---|
241 | /* some servers don't like requests that are made without a user-agent */ |
---|
242 | cstat = curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0"); |
---|
243 | if (cstat != CURLE_OK) |
---|
244 | stat = OC_ECURL; |
---|
245 | } |
---|
246 | if (curlp) |
---|
247 | *curlp = curl; |
---|
248 | return OCTHROW(stat); |
---|
249 | } |
---|
250 | |
---|
251 | void |
---|
252 | occurlclose(CURL* curl) |
---|
253 | { |
---|
254 | if (curl != NULL) |
---|
255 | curl_easy_cleanup(curl); |
---|
256 | } |
---|
257 | |
---|
258 | int |
---|
259 | ocfetchlastmodified(CURL* curl, char* url, long* filetime) |
---|
260 | { |
---|
261 | int stat = OC_NOERR; |
---|
262 | CURLcode cstat = CURLE_OK; |
---|
263 | |
---|
264 | /* Set the URL */ |
---|
265 | cstat = curl_easy_setopt(curl, CURLOPT_URL, (void*)url); |
---|
266 | if (cstat != CURLE_OK) |
---|
267 | goto fail; |
---|
268 | |
---|
269 | /* Ask for head */ |
---|
270 | cstat = curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30); /* 30sec timeout*/ |
---|
271 | cstat = curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2); |
---|
272 | cstat = curl_easy_setopt(curl, CURLOPT_HEADER, 1); |
---|
273 | cstat = curl_easy_setopt(curl, CURLOPT_NOBODY, 1); |
---|
274 | cstat = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1); |
---|
275 | cstat = curl_easy_setopt(curl, CURLOPT_FILETIME, (long)1); |
---|
276 | |
---|
277 | cstat = curl_easy_perform(curl); |
---|
278 | if(cstat != CURLE_OK) goto fail; |
---|
279 | if(filetime != NULL) |
---|
280 | cstat = curl_easy_getinfo(curl,CURLINFO_FILETIME,filetime); |
---|
281 | if(cstat != CURLE_OK) goto fail; |
---|
282 | |
---|
283 | return OCTHROW(stat); |
---|
284 | |
---|
285 | fail: |
---|
286 | oc_log(LOGERR, "curl error: %s", curl_easy_strerror(cstat)); |
---|
287 | return OCTHROW(OC_ECURL); |
---|
288 | } |
---|
289 | |
---|
290 | int |
---|
291 | ocping(const char* url) |
---|
292 | { |
---|
293 | int stat = OC_NOERR; |
---|
294 | CURLcode cstat = CURLE_OK; |
---|
295 | CURL* curl = NULL; |
---|
296 | OCbytes* buf = NULL; |
---|
297 | |
---|
298 | /* Create a CURL instance */ |
---|
299 | stat = occurlopen(&curl); |
---|
300 | if(stat != OC_NOERR) return stat; |
---|
301 | |
---|
302 | /* use a very short timeout: 10 seconds */ |
---|
303 | cstat = curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)10); |
---|
304 | if (cstat != CURLE_OK) |
---|
305 | goto done; |
---|
306 | |
---|
307 | /* fail on HTTP 400 code errors */ |
---|
308 | cstat = curl_easy_setopt(curl, CURLOPT_FAILONERROR, (long)1); |
---|
309 | if (cstat != CURLE_OK) |
---|
310 | goto done; |
---|
311 | |
---|
312 | /* Try to get the file */ |
---|
313 | buf = ocbytesnew(); |
---|
314 | stat = ocfetchurl(curl,url,buf,NULL); |
---|
315 | if(stat == OC_NOERR) { |
---|
316 | /* Don't trust curl to return an error when request gets 404 */ |
---|
317 | long http_code = 0; |
---|
318 | cstat = curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE, &http_code); |
---|
319 | if (cstat != CURLE_OK) |
---|
320 | goto done; |
---|
321 | if(http_code >= 400) { |
---|
322 | cstat = CURLE_HTTP_RETURNED_ERROR; |
---|
323 | goto done; |
---|
324 | } |
---|
325 | } else |
---|
326 | goto done; |
---|
327 | |
---|
328 | done: |
---|
329 | ocbytesfree(buf); |
---|
330 | occurlclose(curl); |
---|
331 | if(cstat != CURLE_OK) { |
---|
332 | oc_log(LOGERR, "curl error: %s", curl_easy_strerror(cstat)); |
---|
333 | stat = OC_EDAPSVC; |
---|
334 | } |
---|
335 | return OCTHROW(stat); |
---|
336 | } |
---|
337 | |
---|
338 | |
---|