e0af49b6698e64c75148ec5ecfddee14e1c75969
[dcpomatic.git] / src / lib / internet.cc
1 /*
2     Copyright (C) 2014-2019 Carl Hetherington <cth@carlh.net>
3
4     This file is part of DCP-o-matic.
5
6     DCP-o-matic is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     DCP-o-matic is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
18
19 */
20
21 #include "scoped_temporary.h"
22 #include "compose.hpp"
23 #include "exceptions.h"
24 #include "cross.h"
25 #include "util.h"
26 #include <curl/curl.h>
27 #include <zip.h>
28 #include <boost/function.hpp>
29 #include <boost/optional.hpp>
30 #include <boost/filesystem.hpp>
31 #include <boost/algorithm/string.hpp>
32 #include <string>
33
34 #include "i18n.h"
35
36 using std::string;
37 using std::list;
38 using boost::optional;
39 using boost::function;
40 using boost::algorithm::trim;
41
42
43 static size_t
44 get_from_url_data (void* buffer, size_t size, size_t nmemb, void* stream)
45 {
46         FILE* f = reinterpret_cast<FILE*> (stream);
47         return fwrite (buffer, size, nmemb, f);
48 }
49
50 optional<string>
51 get_from_url (string url, bool pasv, bool skip_pasv_ip, ScopedTemporary& temp)
52 {
53         CURL* curl = curl_easy_init ();
54         curl_easy_setopt (curl, CURLOPT_URL, url.c_str());
55
56         FILE* f = temp.open ("wb");
57         curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, get_from_url_data);
58         curl_easy_setopt (curl, CURLOPT_WRITEDATA, f);
59         curl_easy_setopt (curl, CURLOPT_FTP_USE_EPSV, 0);
60         curl_easy_setopt (curl, CURLOPT_FTP_USE_EPRT, 0);
61         if (skip_pasv_ip) {
62                 curl_easy_setopt (curl, CURLOPT_FTP_SKIP_PASV_IP, 1);
63         }
64         if (!pasv) {
65                 curl_easy_setopt (curl, CURLOPT_FTPPORT, "-");
66         }
67
68         /* Maximum time is 20s */
69         curl_easy_setopt (curl, CURLOPT_TIMEOUT, 20);
70
71         CURLcode const cr = curl_easy_perform (curl);
72
73         temp.close ();
74         curl_easy_cleanup (curl);
75         if (cr != CURLE_OK) {
76                 return String::compose (_("Download failed (%1 error %2)"), url, (int) cr);
77         }
78
79         return optional<string>();
80 }
81
82 optional<string>
83 get_from_url (string url, bool pasv, bool skip_pasv_ip, function<void (boost::filesystem::path)> load)
84 {
85         ScopedTemporary temp;
86         optional<string> e = get_from_url (url, pasv, skip_pasv_ip, temp);
87         if (e) {
88                 return e;
89         }
90         load (temp.file());
91         return optional<string>();
92 }
93
94 /** @param url URL of ZIP file.
95  *  @param file Filename within ZIP file.
96  *  @param load Function passed a (temporary) filesystem path of the unpacked file.
97  */
98 optional<string>
99 get_from_zip_url (string url, string file, bool pasv, bool skip_pasv_ip, function<void (boost::filesystem::path)> load)
100 {
101         /* Download the ZIP file to temp_zip */
102         ScopedTemporary temp_zip;
103         optional<string> e = get_from_url (url, pasv, skip_pasv_ip, temp_zip);
104         if (e) {
105                 return e;
106         }
107
108         /* Open the ZIP file and read `file' out of it */
109
110 #ifdef DCPOMATIC_HAVE_ZIP_SOURCE_T
111         /* This is the way to do it with newer versions of libzip, and is required on Windows.
112            The zip_source_t API is missing in the libzip versions shipped with Ubuntu 14.04,
113            Centos 6, Centos 7, Debian 7 and Debian 8.
114         */
115
116         FILE* zip_file = fopen_boost (temp_zip.file (), "rb");
117         if (!zip_file) {
118                 return optional<string> (_("Could not open downloaded ZIP file"));
119         }
120
121         zip_source_t* zip_source = zip_source_filep_create (zip_file, 0, -1, 0);
122         if (!zip_source) {
123                 return optional<string> (_("Could not open downloaded ZIP file"));
124         }
125
126         zip_error_t error;
127         zip_error_init (&error);
128         zip_t* zip = zip_open_from_source (zip_source, ZIP_RDONLY, &error);
129         if (!zip) {
130                 return String::compose (_("Could not open downloaded ZIP file (%1:%2: %3)"), error.zip_err, error.sys_err, error.str ? error.str : "");
131         }
132
133 #else
134         struct zip* zip = zip_open (temp_zip.c_str(), 0, 0);
135 #endif
136
137         struct zip_file* file_in_zip = zip_fopen (zip, file.c_str(), 0);
138         if (!file_in_zip) {
139                 return optional<string> (_("Unexpected ZIP file contents"));
140         }
141
142         ScopedTemporary temp_cert;
143         FILE* f = temp_cert.open ("wb");
144         char buffer[4096];
145         while (true) {
146                 int const N = zip_fread (file_in_zip, buffer, sizeof (buffer));
147                 checked_fwrite (buffer, N, f, temp_cert.file());
148                 if (N < int (sizeof (buffer))) {
149                         break;
150                 }
151         }
152         zip_fclose (file_in_zip);
153         zip_close (zip);
154         temp_cert.close ();
155
156         load (temp_cert.file ());
157         return optional<string> ();
158 }