summaryrefslogtreecommitdiffstats
path: root/web/lib/aurjson.class.php
blob: ab8ebbc1eaa08c06e1ee87eb947dbbbf0c0f8811 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
<?php
/**
 * AurJSON
 *
 * This file contains the AurRPC remote handling class
 **/
include_once("aur.inc.php");

/**
 * This class defines a remote interface for fetching data
 * from the AUR using JSON formatted elements.
 * @package rpc
 * @subpackage classes
 **/
class AurJSON {
    private $dbh = false;
    private static $exposed_methods = array(
        'search', 'info', 'multiinfo', 'msearch', 'suggest'
    );
    private static $fields = array(
        'Packages.ID', 'Packages.Name', 'PackageBases.Name AS PackageBase',
        'Version', 'CategoryID', 'Description', 'URL', 'NumVotes',
        'OutOfDateTS AS OutOfDate', 'Users.UserName AS Maintainer',
        'SubmittedTS AS FirstSubmitted', 'ModifiedTS AS LastModified'
    );
    private static $numeric_fields = array(
        'ID', 'CategoryID', 'NumVotes', 'OutOfDate', 'FirstSubmitted',
        'LastModified'
    );

    /**
     * Handles post data, and routes the request.
     * @param string $post_data The post data to parse and handle.
     * @return string The JSON formatted response data.
     **/
    public function handle($http_data) {
		// unset global aur headers from aur.inc
		// leave expires header to enforce validation
		// header_remove('Expires');
		// unset global aur.inc pragma header. We want to allow caching of data
		// in proxies, but require validation of data (if-none-match) if
		// possible
		header_remove('Pragma');
		// overwrite cache-control header set in aur.inc to allow caching, but
		// require validation
		header('Cache-Control: public, must-revalidate, max-age=0');
		header('Content-Type: application/json, charset=utf-8');

        // handle error states
        if ( !isset($http_data['type']) || !isset($http_data['arg']) ) {
            return $this->json_error('No request type/data specified.');
        }

        // do the routing
        if ( in_array($http_data['type'], self::$exposed_methods) ) {
            // set up db connection.
            $this->dbh = DB::connect();

            // ugh. this works. I hate you php.
            $json = call_user_func(array(&$this, $http_data['type']),
                $http_data['arg']);

			// calculate etag as an md5 based on the json result
			// this could be optimized by calculating the etag on the 
			// query result object before converting to json (step into
			// the above function call) and adding the 'type' to the response,
			// but having all this code here is cleaner and 'good enough'
			$etag = md5($json);
			header("Etag: \"$etag\"");
			// make sure to strip a few things off the if-none-match
			// header. stripping whitespace may not be required, but 
			// removing the quote on the incoming header is required 
			// to make the equality test
			$if_none_match = isset($_SERVER['HTTP_IF_NONE_MATCH']) ?
				trim($_SERVER['HTTP_IF_NONE_MATCH'], "\t\n\r\" ") : false;
			if ($if_none_match && $if_none_match == $etag) {
				header('HTTP/1.1 304 Not Modified');
				return;
			}

            // allow rpc callback for XDomainAjax
            if ( isset($http_data['callback']) ) {
                // it is more correct to send text/javascript
                // content-type for jsonp-callback
                header('content-type: text/javascript');
                return $http_data['callback'] . "({$json})";
            }
            else {
                // set content type header to app/json
                header('content-type: application/json');
                return $json;
            }
        }
        else {
            return $this->json_error('Incorrect request type specified.');
        }
    }

    /**
     * Returns a JSON formatted error string.
     *
     * @param $msg The error string to return
     * @return mixed A json formatted error response.
     **/
    private function json_error($msg) {
        // set content type header to app/json
        header('content-type: application/json');
        return $this->json_results('error', 0, $msg);
    }

    /**
     * Returns a JSON formatted result data.
     * @param $type The response method type.
     * @param $data The result data to return
     * @return mixed A json formatted result response.
     **/
    private function json_results($type, $count, $data) {
        return json_encode( array('type' => $type, 'resultcount' => $count, 'results' => $data) );
    }

    private function get_extended_fields($pkgid) {
        $query = "SELECT DependencyTypes.Name AS Type, " .
            "PackageDepends.DepName AS Name, " .
            "PackageDepends.DepCondition AS Cond " .
            "FROM PackageDepends " .
            "LEFT JOIN DependencyTypes " .
            "ON DependencyTypes.ID = PackageDepends.DepTypeID " .
            "WHERE PackageDepends.PackageID = " . $pkgid . " " .
            "UNION SELECT RelationTypes.Name AS Type, " .
            "PackageRelations.RelName AS Name, " .
            "PackageRelations.RelCondition AS Cond " .
            "FROM PackageRelations " .
            "LEFT JOIN RelationTypes " .
            "ON RelationTypes.ID = PackageRelations.RelTypeID " .
            "WHERE PackageRelations.PackageID = " . $pkgid . " " .
            "UNION SELECT 'groups' AS Type, Groups.Name, '' AS Cond " .
            "FROM Groups INNER JOIN PackageGroups " .
            "ON PackageGroups.PackageID = " . $pkgid . " " .
            "AND PackageGroups.GroupID = Groups.ID " .
            "UNION SELECT 'license' AS Type, Licenses.Name, '' AS Cond " .
            "FROM Licenses INNER JOIN PackageLicenses " .
            "ON PackageLicenses.PackageID = " . $pkgid . " " .
            "AND PackageLicenses.LicenseID = Licenses.ID";
        $result = $this->dbh->query($query);

        if (!$result) {
            return null;
        }

        $type_map = array(
            'depends' => 'Depends',
            'makedepends' => 'MakeDepends',
            'checkdepends' => 'CheckDepends',
            'optdepends' => 'OptDepends',
            'conflicts' => 'Conflicts',
            'provides' => 'Provides',
            'replaces' => 'Replaces',
            'groups' => 'Groups',
            'license' => 'License',
        );
        $data = array();
        while ($row = $result->fetch(PDO::FETCH_ASSOC)) {
            $type = $type_map[$row['Type']];
            $data[$type][] = $row['Name'] . $row['Cond'];
        }

        return $data;
    }

    private function process_query($type, $where_condition) {
        global $MAX_RPC_RESULTS;
        $fields = implode(',', self::$fields);
        $query = "SELECT {$fields} " .
            "FROM Packages LEFT JOIN PackageBases " .
            "ON PackageBases.ID = Packages.PackageBaseID " .
            "LEFT JOIN Users ON PackageBases.MaintainerUID = Users.ID " .
            "WHERE ${where_condition}";
        $result = $this->dbh->query($query);

        if ($result) {
            $resultcount = 0;
            $search_data = array();
            while ($row = $result->fetch(PDO::FETCH_ASSOC)) {
                $resultcount++;
                $pkgbase_name = $row['PackageBase'];
                $row['URLPath'] = URL_DIR . substr($pkgbase_name, 0, 2) . "/" . $pkgbase_name . "/" . $pkgbase_name . ".tar.gz";

                /* Unfortunately, mysql_fetch_assoc() returns all fields as
                 * strings. We need to coerce numeric values into integers to
                 * provide proper data types in the JSON response.
                 */
                foreach (self::$numeric_fields as $field) {
                    $row[$field] = intval($row[$field]);
                }

                if ($type == 'info' || $type == 'multiinfo') {
                    $row = array_merge($row, $this->get_extended_fields($row['ID']));
                }

                if ($type == 'info') {
                    $search_data = $row;
                    break;
                }
                else {
                    array_push($search_data, $row);
                }
            }

           if ($resultcount === $MAX_RPC_RESULTS) {
               return $this->json_error('Too many package results.');
           }

            return $this->json_results($type, $resultcount, $search_data);
        }
        else {
            return $this->json_results($type, 0, array());
        }
    }

    /**
     * Parse the args to the multiinfo function. We may have a string or an 
     * array, so do the appropriate thing. Within the elements, both * package 
     * IDs and package names are valid; sort them into the relevant arrays and
     * escape/quote the names.
     * @param $args the arg string or array to parse.
     * @return mixed An array containing 'ids' and 'names'.
     **/
    private function parse_multiinfo_args($args) {
        if (!is_array($args)) {
            $args = array($args);
        }

        $id_args = array();
        $name_args = array();
        foreach ($args as $arg) {
            if (!$arg) {
                continue;
            }
            if (is_numeric($arg)) {
                $id_args[] = intval($arg);
            } else {
                $name_args[] = $this->dbh->quote($arg);
            }
        }

        return array('ids' => $id_args, 'names' => $name_args);
    }

    /**
     * Performs a fulltext mysql search of the package database.
     * @param $keyword_string A string of keywords to search with.
     * @return mixed Returns an array of package matches.
     **/
    private function search($keyword_string) {
        global $MAX_RPC_RESULTS;
        if (strlen($keyword_string) < 2) {
            return $this->json_error('Query arg too small');
        }

        $keyword_string = $this->dbh->quote("%" . addcslashes($keyword_string, '%_') . "%");

        $where_condition = "(Packages.Name LIKE {$keyword_string} OR ";
        $where_condition.= "Description LIKE {$keyword_string}) ";
        $where_condition.= "LIMIT {$MAX_RPC_RESULTS}";

        return $this->process_query('search', $where_condition);
    }

    /**
     * Returns the info on a specific package.
     * @param $pqdata The ID or name of the package. Package Query Data.
     * @return mixed Returns an array of value data containing the package data
     **/
    private function info($pqdata) {
        if ( is_numeric($pqdata) ) {
            // just using sprintf to coerce the pqd to an int
            // should handle sql injection issues, since sprintf will
            // bork if not an int, or convert the string to a number 0
            $where_condition = "Packages.ID={$pqdata}";
        }
        else {
            $where_condition = sprintf("Packages.Name=%s", $this->dbh->quote($pqdata));
        }
        return $this->process_query('info', $where_condition);
    }

    /**
     * Returns the info on multiple packages.
     * @param $pqdata A comma-separated list of IDs or names of the packages.
     * @return mixed Returns an array of results containing the package data
     **/
    private function multiinfo($pqdata) {
        global $MAX_RPC_RESULTS;
        $args = $this->parse_multiinfo_args($pqdata);
        $ids = $args['ids'];
        $names = $args['names'];

        if (!$ids && !$names) {
            return $this->json_error('Invalid query arguments');
        }

        $where_condition = "";
        if ($ids) {
            $ids_value = implode(',', $args['ids']);
            $where_condition .= "ID IN ({$ids_value}) ";
        }
        if ($ids && $names) {
            $where_condition .= "OR ";
        }
        if ($names) {
            // individual names were quoted in parse_multiinfo_args()
            $names_value = implode(',', $args['names']);
            $where_condition .= "Packages.Name IN ({$names_value}) ";
        }

        $where_condition .= "LIMIT {$MAX_RPC_RESULTS}";

        return $this->process_query('multiinfo', $where_condition);
    }

    /**
     * Returns all the packages for a specific maintainer.
     * @param $maintainer The name of the maintainer.
     * @return mixed Returns an array of value data containing the package data
     **/
    private function msearch($maintainer) {
        global $MAX_RPC_RESULTS;
        $maintainer = $this->dbh->quote($maintainer);

        $where_condition = "Users.Username = {$maintainer} ";
        $where_condition .= "LIMIT {$MAX_RPC_RESULTS}";

        return $this->process_query('msearch', $where_condition);
    }

    /**
     * Get all package names that start with $search.
     * @param string $search Search string.
     * @return string The JSON formatted response data.
     **/
    private function suggest($search) {
        $query = 'SELECT Name FROM Packages WHERE Name LIKE ' .
            $this->dbh->quote(addcslashes($search, '%_') . '%') .
            ' ORDER BY Name ASC LIMIT 20';

        $result = $this->dbh->query($query);
        $result_array = array();

        if ($result) {
            $result_array = $result->fetchAll(PDO::FETCH_COLUMN, 0);
        }

        return json_encode($result_array);
    }
}