?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
replace constants with class constants.
[phpbb.git] / phpBB / includes / functions_admin.php
blob89c6a21468da8bd5139b48146e684b038346b5c7
1 <?php
2 /**
3 *
4 * @package acp
5 * @version $Id$
6 * @copyright (c) 2005 phpBB Group
7 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
8 *
9 */
10
11 /**
12 * @ignore
13 */
14 if (!defined('IN_PHPBB'))
15 {
16 exit;
17 }
18
19 /**
20 * Recalculate Binary Tree
21 function recalc_btree($sql_id, $sql_table, $module_class = '')
22 {
23 global $db;
24
25 if (!$sql_id || !$sql_table)
26 {
27 return;
28 }
29
30 $sql_where = ($module_class) ? " WHERE module_class = '" . $db->sql_escape($module_class) . "'" : '';
31
32 // Reset to minimum possible left and right id
33 $sql = "SELECT MIN(left_id) as min_left_id, MIN(right_id) as min_right_id
34 FROM $sql_table
35 $sql_where";
36 $result = $db->sql_query($sql);
37 $row = $db->sql_fetchrow($result);
38 $db->sql_freeresult($result);
39
40 $substract = (int) (min($row['min_left_id'], $row['min_right_id']) - 1);
41
42 if ($substract > 0)
43 {
44 $sql = "UPDATE $sql_table
45 SET left_id = left_id - $substract, right_id = right_id - $substract
46 $sql_where";
47 $db->sql_query($sql);
48 }
49
50 $sql = "SELECT $sql_id, parent_id, left_id, right_id
51 FROM $sql_table
52 $sql_where
53 ORDER BY left_id ASC, parent_id ASC, $sql_id ASC";
54 $f_result = $db->sql_query($sql);
55
56 while ($item_data = $db->sql_fetchrow($f_result))
57 {
58 if ($item_data['parent_id'])
59 {
60 $sql = "SELECT left_id, right_id
61 FROM $sql_table
62 $sql_where " . (($sql_where) ? 'AND' : 'WHERE') . "
63 $sql_id = {$item_data['parent_id']}";
64 $result = $db->sql_query($sql);
65
66 if (!$row = $db->sql_fetchrow($result))
67 {
68 $sql = "UPDATE $sql_table SET parent_id = 0 WHERE $sql_id = " . $item_data[$sql_id];
69 $db->sql_query($sql);
70 }
71 $db->sql_freeresult($result);
72
73 $sql = "UPDATE $sql_table
74 SET left_id = left_id + 2, right_id = right_id + 2
75 $sql_where " . (($sql_where) ? 'AND' : 'WHERE') . "
76 left_id > {$row['right_id']}";
77 $db->sql_query($sql);
78
79 $sql = "UPDATE $sql_table
80 SET right_id = right_id + 2
81 $sql_where " . (($sql_where) ? 'AND' : 'WHERE') . "
82 {$row['left_id']} BETWEEN left_id AND right_id";
83 $db->sql_query($sql);
84
85 $item_data['left_id'] = $row['right_id'];
86 $item_data['right_id'] = $row['right_id'] + 1;
87 }
88 else
89 {
90 $sql = "SELECT MAX(right_id) AS right_id
91 FROM $sql_table
92 $sql_where";
93 $result = $db->sql_query($sql);
94 $row = $db->sql_fetchrow($result);
95 $db->sql_freeresult($result);
96
97 $item_data['left_id'] = $row['right_id'] + 1;
98 $item_data['right_id'] = $row['right_id'] + 2;
99 }
100
101 $sql = "UPDATE $sql_table
102 SET left_id = {$item_data['left_id']}, right_id = {$item_data['right_id']}
103 WHERE $sql_id = " . $item_data[$sql_id];
104 $db->sql_query($sql);
105 }
106 $db->sql_freeresult($f_result);
107 }
108 */
109
110 /**
111 * Simple version of jumpbox, just lists authed forums
112 */
113 function make_forum_select($select_id = false, $ignore_id = false, $ignore_acl = false, $ignore_nonpost = false, $ignore_emptycat = true, $only_acl_post = false, $return_array = false)
114 {
115 global $db, $user, $auth;
116
117 $acl = ($ignore_acl) ? '' : (($only_acl_post) ? 'f_post' : array('f_list', 'a_forum', 'a_forumadd', 'a_forumdel'));
118
119 // This query is identical to the jumpbox one
120 $sql = 'SELECT forum_id, forum_name, parent_id, forum_type, left_id, right_id
121 FROM ' . FORUMS_TABLE . '
122 ORDER BY left_id ASC';
123 $result = $db->sql_query($sql, 600);
124
125 $right = 0;
126 $padding_store = array('0' => '');
127 $padding = '';
128 $forum_list = ($return_array) ? array() : '';
129
130 // Sometimes it could happen that forums will be displayed here not be displayed within the index page
131 // This is the result of forums not displayed at index, having list permissions and a parent of a forum with no permissions.
132 // If this happens, the padding could be "broken"
133
134 while ($row = $db->sql_fetchrow($result))
135 {
136 if ($row['left_id'] < $right)
137 {
138 $padding .= '&nbsp; &nbsp;';
139 $padding_store[$row['parent_id']] = $padding;
140 }
141 else if ($row['left_id'] > $right + 1)
142 {
143 $padding = (isset($padding_store[$row['parent_id']])) ? $padding_store[$row['parent_id']] : '';
144 }
145
146 $right = $row['right_id'];
147 $disabled = false;
148
149 if ($acl && !$auth->acl_gets($acl, $row['forum_id']))
150 {
151 // List permission?
152 if ($auth->acl_get('f_list', $row['forum_id']))
153 {
154 $disabled = true;
155 }
156 else
157 {
158 continue;
159 }
160 }
161
162 if (
163 ((is_array($ignore_id) && in_array($row['forum_id'], $ignore_id)) || $row['forum_id'] == $ignore_id)
164 ||
165 // Non-postable forum with no subforums, don't display
166 ($row['forum_type'] == FORUM_CAT && ($row['left_id'] + 1 == $row['right_id']) && $ignore_emptycat)
167 ||
168 ($row['forum_type'] != FORUM_POST && $ignore_nonpost)
169 )
170 {
171 $disabled = true;
172 }
173
174 if ($return_array)
175 {
176 // Include some more information...
177 $selected = (is_array($select_id)) ? ((in_array($row['forum_id'], $select_id)) ? true : false) : (($row['forum_id'] == $select_id) ? true : false);
178 $forum_list[$row['forum_id']] = array_merge(array('padding' => $padding, 'selected' => ($selected && !$disabled), 'disabled' => $disabled), $row);
179 }
180 else
181 {
182 $selected = (is_array($select_id)) ? ((in_array($row['forum_id'], $select_id)) ? ' selected="selected"' : '') : (($row['forum_id'] == $select_id) ? ' selected="selected"' : '');
183 $forum_list .= '<option value="' . $row['forum_id'] . '"' . (($disabled) ? ' disabled="disabled" class="disabled-option"' : $selected) . '>' . $padding . $row['forum_name'] . '</option>';
184 }
185 }
186 $db->sql_freeresult($result);
187 unset($padding_store);
188
189 return $forum_list;
190 }
191
192 /**
193 * Generate size select options
194 */
195 function size_select_options($size_compare)
196 {
197 global $user;
198
199 $size_types_text = array($user->lang['BYTES'], $user->lang['KIB'], $user->lang['MIB']);
200 $size_types = array('b', 'kb', 'mb');
201
202 $s_size_options = '';
203
204 for ($i = 0, $size = sizeof($size_types_text); $i < $size; $i++)
205 {
206 $selected = ($size_compare == $size_types[$i]) ? ' selected="selected"' : '';
207 $s_size_options .= '<option value="' . $size_types[$i] . '"' . $selected . '>' . $size_types_text[$i] . '</option>';
208 }
209
210 return $s_size_options;
211 }
212
213 /**
214 * Generate list of groups (option fields without select)
215 *
216 * @param int $group_id The default group id to mark as selected
217 * @param array $exclude_ids The group ids to exclude from the list, false (default) if you whish to exclude no id
218 * @param int $manage_founder If set to false (default) all groups are returned, if 0 only those groups returned not being managed by founders only, if 1 only those groups returned managed by founders only.
219 *
220 * @return string The list of options.
221 */
222 function group_select_options($group_id, $exclude_ids = false, $manage_founder = false)
223 {
224 global $db, $user, $config;
225
226 $exclude_sql = ($exclude_ids !== false && sizeof($exclude_ids)) ? 'WHERE ' . $db->sql_in_set('group_id', array_map('intval', $exclude_ids), true) : '';
227 $sql_and = (!$config['coppa_enable']) ? (($exclude_sql) ? ' AND ' : ' WHERE ') . "group_name <> 'REGISTERED_COPPA'" : '';
228 $sql_founder = ($manage_founder !== false) ? (($exclude_sql || $sql_and) ? ' AND ' : ' WHERE ') . 'group_founder_manage = ' . (int) $manage_founder : '';
229
230 $sql = 'SELECT group_id, group_name, group_type
231 FROM ' . GROUPS_TABLE . "
232 $exclude_sql
233 $sql_and
234 $sql_founder
235 ORDER BY group_type DESC, group_name ASC";
236 $result = $db->sql_query($sql);
237
238 $s_group_options = '';
239 while ($row = $db->sql_fetchrow($result))
240 {
241 $selected = ($row['group_id'] == $group_id) ? ' selected="selected"' : '';
242 $s_group_options .= '<option' . (($row['group_type'] == GROUP_SPECIAL) ? ' class="sep"' : '') . ' value="' . $row['group_id'] . '"' . $selected . '>' . (($row['group_type'] == GROUP_SPECIAL) ? $user->lang['G_' . $row['group_name']] : $row['group_name']) . '</option>';
243 }
244 $db->sql_freeresult($result);
245
246 return $s_group_options;
247 }
248
249 /**
250 * Obtain authed forums list
251 */
252 function get_forum_list($acl_list = 'f_list', $id_only = true, $postable_only = false, $no_cache = false)
253 {
254 global $db, $auth;
255 static $forum_rows;
256
257 if (!isset($forum_rows))
258 {
259 // This query is identical to the jumpbox one
260 $expire_time = ($no_cache) ? 0 : 600;
261
262 $sql = 'SELECT forum_id, forum_name, parent_id, forum_type, left_id, right_id
263 FROM ' . FORUMS_TABLE . '
264 ORDER BY left_id ASC';
265 $result = $db->sql_query($sql, $expire_time);
266
267 $forum_rows = array();
268
269 $right = $padding = 0;
270 $padding_store = array('0' => 0);
271
272 while ($row = $db->sql_fetchrow($result))
273 {
274 if ($row['left_id'] < $right)
275 {
276 $padding++;
277 $padding_store[$row['parent_id']] = $padding;
278 }
279 else if ($row['left_id'] > $right + 1)
280 {
281 // Ok, if the $padding_store for this parent is empty there is something wrong. For now we will skip over it.
282 // @todo digging deep to find out "how" this can happen.
283 $padding = (isset($padding_store[$row['parent_id']])) ? $padding_store[$row['parent_id']] : $padding;
284 }
285
286 $right = $row['right_id'];
287 $row['padding'] = $padding;
288
289 $forum_rows[] = $row;
290 }
291 $db->sql_freeresult($result);
292 unset($padding_store);
293 }
294
295 $rowset = array();
296 foreach ($forum_rows as $row)
297 {
298 if ($postable_only && $row['forum_type'] != FORUM_POST)
299 {
300 continue;
301 }
302
303 if ($acl_list == '' || ($acl_list != '' && $auth->acl_gets($acl_list, $row['forum_id'])))
304 {
305 $rowset[] = ($id_only) ? $row['forum_id'] : $row;
306 }
307 }
308
309 return $rowset;
310 }
311
312 /**
313 * Get forum branch
314 */
315 function get_forum_branch($forum_id, $type = 'all', $order = 'descending', $include_forum = true)
316 {
317 global $db;
318
319 switch ($type)
320 {
321 case 'parents':
322 $condition = 'f1.left_id BETWEEN f2.left_id AND f2.right_id';
323 break;
324
325 case 'children':
326 $condition = 'f2.left_id BETWEEN f1.left_id AND f1.right_id';
327 break;
328
329 default:
330 $condition = 'f2.left_id BETWEEN f1.left_id AND f1.right_id OR f1.left_id BETWEEN f2.left_id AND f2.right_id';
331 break;
332 }
333
334 $rows = array();
335
336 $sql = 'SELECT f2.*
337 FROM ' . FORUMS_TABLE . ' f1
338 LEFT JOIN ' . FORUMS_TABLE . " f2 ON ($condition)
339 WHERE f1.forum_id = $forum_id
340 ORDER BY f2.left_id " . (($order == 'descending') ? 'ASC' : 'DESC');
341 $result = $db->sql_query($sql);
342
343 while ($row = $db->sql_fetchrow($result))
344 {
345 if (!$include_forum && $row['forum_id'] == $forum_id)
346 {
347 continue;
348 }
349
350 $rows[] = $row;
351 }
352 $db->sql_freeresult($result);
353
354 return $rows;
355 }
356
357 /**
358 * Get physical file listing
359 */
360 function filelist($rootdir, $dir = '', $type = 'gif|jpg|jpeg|png')
361 {
362 $matches = array();
363
364 // Remove initial / if present
365 $rootdir = (substr($rootdir, 0, 1) == '/') ? substr($rootdir, 1) : $rootdir;
366 // Add closing / if not present
367 $rootdir = ($rootdir && substr($rootdir, -1) != '/') ? $rootdir . '/' : $rootdir;
368
369 // Remove initial / if present
370 $dir = (substr($dir, 0, 1) == '/') ? substr($dir, 1) : $dir;
371 // Add closing / if not present
372 $dir = ($dir && substr($dir, -1) != '/') ? $dir . '/' : $dir;
373
374 if (!is_dir($rootdir . $dir))
375 {
376 return $matches;
377 }
378
379 $dh = @opendir($rootdir . $dir);
380
381 if (!$dh)
382 {
383 return $matches;
384 }
385
386 while (($fname = readdir($dh)) !== false)
387 {
388 if (is_file("$rootdir$dir$fname"))
389 {
390 if (filesize("$rootdir$dir$fname") && preg_match('#\.' . $type . '$#i', $fname))
391 {
392 $matches[$dir][] = $fname;
393 }
394 }
395 else if ($fname[0] != '.' && is_dir("$rootdir$dir$fname"))
396 {
397 $matches += filelist($rootdir, "$dir$fname", $type);
398 }
399 }
400 closedir($dh);
401
402 return $matches;
403 }
404
405 /**
406 * Move topic(s)
407 */
408 function move_topics($topic_ids, $forum_id, $auto_sync = true)
409 {
410 global $db;
411
412 if (empty($topic_ids))
413 {
414 return;
415 }
416
417 $forum_ids = array($forum_id);
418
419 if (!is_array($topic_ids))
420 {
421 $topic_ids = array($topic_ids);
422 }
423
424 $sql = 'DELETE FROM ' . TOPICS_TABLE . '
425 WHERE ' . $db->sql_in_set('topic_moved_id', $topic_ids) . '
426 AND forum_id = ' . $forum_id;
427 $db->sql_query($sql);
428
429 if ($auto_sync)
430 {
431 $sql = 'SELECT DISTINCT forum_id
432 FROM ' . TOPICS_TABLE . '
433 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
434 $result = $db->sql_query($sql);
435
436 while ($row = $db->sql_fetchrow($result))
437 {
438 $forum_ids[] = $row['forum_id'];
439 }
440 $db->sql_freeresult($result);
441 }
442
443 $table_ary = array(TOPICS_TABLE, POSTS_TABLE, LOG_TABLE, DRAFTS_TABLE, TOPICS_TRACK_TABLE);
444 foreach ($table_ary as $table)
445 {
446 $sql = "UPDATE $table
447 SET forum_id = $forum_id
448 WHERE " . $db->sql_in_set('topic_id', $topic_ids);
449 $db->sql_query($sql);
450 }
451 unset($table_ary);
452
453 if ($auto_sync)
454 {
455 sync('forum', 'forum_id', $forum_ids, true, true);
456 unset($forum_ids);
457 }
458 }
459
460 /**
461 * Move post(s)
462 */
463 function move_posts($post_ids, $topic_id, $auto_sync = true)
464 {
465 global $db;
466
467 if (!is_array($post_ids))
468 {
469 $post_ids = array($post_ids);
470 }
471
472 $forum_ids = array();
473 $topic_ids = array($topic_id);
474
475 $sql = 'SELECT DISTINCT topic_id, forum_id
476 FROM ' . POSTS_TABLE . '
477 WHERE ' . $db->sql_in_set('post_id', $post_ids);
478 $result = $db->sql_query($sql);
479
480 while ($row = $db->sql_fetchrow($result))
481 {
482 $forum_ids[] = $row['forum_id'];
483 $topic_ids[] = $row['topic_id'];
484 }
485 $db->sql_freeresult($result);
486
487 $sql = 'SELECT forum_id
488 FROM ' . TOPICS_TABLE . '
489 WHERE topic_id = ' . $topic_id;
490 $result = $db->sql_query($sql);
491 $forum_row = $db->sql_fetchrow($result);
492 $db->sql_freeresult($result);
493
494 if (!$forum_row)
495 {
496 trigger_error('NO_TOPIC');
497 }
498
499 $sql = 'UPDATE ' . POSTS_TABLE . '
500 SET forum_id = ' . $forum_row['forum_id'] . ", topic_id = $topic_id
501 WHERE " . $db->sql_in_set('post_id', $post_ids);
502 $db->sql_query($sql);
503
504 $sql = 'UPDATE ' . ATTACHMENTS_TABLE . "
505 SET topic_id = $topic_id, in_message = 0
506 WHERE " . $db->sql_in_set('post_msg_id', $post_ids);
507 $db->sql_query($sql);
508
509 if ($auto_sync)
510 {
511 $forum_ids[] = $forum_row['forum_id'];
512
513 sync('topic_reported', 'topic_id', $topic_ids);
514 sync('topic_attachment', 'topic_id', $topic_ids);
515 sync('topic', 'topic_id', $topic_ids, true);
516 sync('forum', 'forum_id', $forum_ids, true, true);
517 }
518
519 // Update posted information
520 update_posted_info($topic_ids);
521 }
522
523 /**
524 * Remove topic(s)
525 */
526 function delete_topics($where_type, $where_ids, $auto_sync = true, $post_count_sync = true, $call_delete_posts = true)
527 {
528 global $db, $config;
529
530 $approved_topics = 0;
531 $forum_ids = $topic_ids = array();
532
533 if ($where_type === 'range')
534 {
535 $where_clause = $where_ids;
536 }
537 else
538 {
539 $where_ids = (is_array($where_ids)) ? array_unique($where_ids) : array($where_ids);
540
541 if (!sizeof($where_ids))
542 {
543 return array('topics' => 0, 'posts' => 0);
544 }
545
546 $where_clause = $db->sql_in_set($where_type, $where_ids);
547 }
548
549 // Making sure that delete_posts does not call delete_topics again...
550 $return = array(
551 'posts' => ($call_delete_posts) ? delete_posts($where_type, $where_ids, false, true, $post_count_sync, false) : 0,
552 );
553
554 $sql = 'SELECT topic_id, forum_id, topic_approved, topic_moved_id
555 FROM ' . TOPICS_TABLE . '
556 WHERE ' . $where_clause;
557 $result = $db->sql_query($sql);
558
559 while ($row = $db->sql_fetchrow($result))
560 {
561 $forum_ids[] = $row['forum_id'];
562 $topic_ids[] = $row['topic_id'];
563
564 if ($row['topic_approved'] && !$row['topic_moved_id'])
565 {
566 $approved_topics++;
567 }
568 }
569 $db->sql_freeresult($result);
570
571 $return['topics'] = sizeof($topic_ids);
572
573 if (!sizeof($topic_ids))
574 {
575 return $return;
576 }
577
578 $db->sql_transaction('begin');
579
580 $table_ary = array(TOPICS_TRACK_TABLE, TOPICS_POSTED_TABLE, POLL_VOTES_TABLE, POLL_OPTIONS_TABLE, TOPICS_WATCH_TABLE, TOPICS_TABLE);
581
582 foreach ($table_ary as $table)
583 {
584 $sql = "DELETE FROM $table
585 WHERE " . $db->sql_in_set('topic_id', $topic_ids);
586 $db->sql_query($sql);
587 }
588 unset($table_ary);
589
590 $moved_topic_ids = array();
591
592 // update the other forums
593 $sql = 'SELECT topic_id, forum_id
594 FROM ' . TOPICS_TABLE . '
595 WHERE ' . $db->sql_in_set('topic_moved_id', $topic_ids);
596 $result = $db->sql_query($sql);
597
598 while ($row = $db->sql_fetchrow($result))
599 {
600 $forum_ids[] = $row['forum_id'];
601 $moved_topic_ids[] = $row['topic_id'];
602 }
603 $db->sql_freeresult($result);
604
605 if (sizeof($moved_topic_ids))
606 {
607 $sql = 'DELETE FROM ' . TOPICS_TABLE . '
608 WHERE ' . $db->sql_in_set('topic_id', $moved_topic_ids);
609 $db->sql_query($sql);
610 }
611
612 $db->sql_transaction('commit');
613
614 if ($auto_sync)
615 {
616 sync('forum', 'forum_id', array_unique($forum_ids), true, true);
617 sync('topic_reported', $where_type, $where_ids);
618 }
619
620 if ($approved_topics)
621 {
622 set_config('num_topics', $config['num_topics'] - $approved_topics, true);
623 }
624
625 return $return;
626 }
627
628 /**
629 * Remove post(s)
630 */
631 function delete_posts($where_type, $where_ids, $auto_sync = true, $posted_sync = true, $post_count_sync = true, $call_delete_topics = true)
632 {
633 global $db, $config;
634
635 if ($where_type === 'range')
636 {
637 $where_clause = $where_ids;
638 }
639 else
640 {
641 if (is_array($where_ids))
642 {
643 $where_ids = array_unique($where_ids);
644 }
645 else
646 {
647 $where_ids = array($where_ids);
648 }
649
650 if (!sizeof($where_ids))
651 {
652 return false;
653 }
654
655 $where_clause = $db->sql_in_set($where_type, array_map('intval', $where_ids));
656 }
657
658 $approved_posts = 0;
659 $post_ids = $topic_ids = $forum_ids = $post_counts = $remove_topics = array();
660
661 $sql = 'SELECT post_id, poster_id, post_approved, post_postcount, topic_id, forum_id
662 FROM ' . POSTS_TABLE . '
663 WHERE ' . $where_clause;
664 $result = $db->sql_query($sql);
665
666 while ($row = $db->sql_fetchrow($result))
667 {
668 $post_ids[] = $row['post_id'];
669 $poster_ids[] = $row['poster_id'];
670 $topic_ids[] = $row['topic_id'];
671 $forum_ids[] = $row['forum_id'];
672
673 if ($row['post_postcount'] && $post_count_sync && $row['post_approved'])
674 {
675 $post_counts[$row['poster_id']] = (!empty($post_counts[$row['poster_id']])) ? $post_counts[$row['poster_id']] + 1 : 1;
676 }
677
678 if ($row['post_approved'])
679 {
680 $approved_posts++;
681 }
682 }
683 $db->sql_freeresult($result);
684
685 if (!sizeof($post_ids))
686 {
687 return false;
688 }
689
690 $db->sql_transaction('begin');
691
692 $table_ary = array(POSTS_TABLE, REPORTS_TABLE);
693
694 foreach ($table_ary as $table)
695 {
696 $sql = "DELETE FROM $table
697 WHERE " . $db->sql_in_set('post_id', $post_ids);
698 $db->sql_query($sql);
699 }
700 unset($table_ary);
701
702 // Adjust users post counts
703 if (sizeof($post_counts) && $post_count_sync)
704 {
705 foreach ($post_counts as $poster_id => $substract)
706 {
707 $sql = 'UPDATE ' . USERS_TABLE . '
708 SET user_posts = 0
709 WHERE user_id = ' . $poster_id . '
710 AND user_posts < ' . $substract;
711 $db->sql_query($sql);
712
713 $sql = 'UPDATE ' . USERS_TABLE . '
714 SET user_posts = user_posts - ' . $substract . '
715 WHERE user_id = ' . $poster_id . '
716 AND user_posts >= ' . $substract;
717 $db->sql_query($sql);
718 }
719 }
720
721 // Remove topics now having no posts?
722 if (sizeof($topic_ids))
723 {
724 $sql = 'SELECT topic_id
725 FROM ' . POSTS_TABLE . '
726 WHERE ' . $db->sql_in_set('topic_id', $topic_ids) . '
727 GROUP BY topic_id';
728 $result = $db->sql_query($sql);
729
730 while ($row = $db->sql_fetchrow($result))
731 {
732 $remove_topics[] = $row['topic_id'];
733 }
734 $db->sql_freeresult($result);
735
736 // Actually, those not within remove_topics should be removed. ;)
737 $remove_topics = array_diff($topic_ids, $remove_topics);
738 }
739
740 // Remove the message from the search index
741 $search_type = basename($config['search_type']);
742
743 if (!file_exists(PHPBB_ROOT_PATH . 'includes/search/' . $search_type . '.' . PHP_EXT))
744 {
745 trigger_error('NO_SUCH_SEARCH_MODULE');
746 }
747
748 include_once(PHPBB_ROOT_PATH . "includes/search/$search_type." . PHP_EXT);
749
750 $error = false;
751 $search = new $search_type($error);
752
753 if ($error)
754 {
755 trigger_error($error);
756 }
757
758 $search->index_remove($post_ids, $poster_ids, $forum_ids);
759
760 delete_attachments('post', $post_ids, false);
761
762 $db->sql_transaction('commit');
763
764 // Resync topics_posted table
765 if ($posted_sync)
766 {
767 update_posted_info($topic_ids);
768 }
769
770 if ($auto_sync)
771 {
772 sync('topic_reported', 'topic_id', $topic_ids);
773 sync('topic', 'topic_id', $topic_ids, true);
774 sync('forum', 'forum_id', $forum_ids, true, true);
775 }
776
777 if ($approved_posts)
778 {
779 set_config('num_posts', $config['num_posts'] - $approved_posts, true);
780 }
781
782 // We actually remove topics now to not be inconsistent (the delete_topics function calls this function too)
783 if (sizeof($remove_topics) && $call_delete_topics)
784 {
785 delete_topics('topic_id', $remove_topics, $auto_sync, $post_count_sync, false);
786 }
787
788 return sizeof($post_ids);
789 }
790
791 /**
792 * Delete Attachments
793 *
794 * @param string $mode can be: post|message|topic|attach|user
795 * @param mixed $ids can be: post_ids, message_ids, topic_ids, attach_ids, user_ids
796 * @param bool $resync set this to false if you are deleting posts or topics
797 */
798 function delete_attachments($mode, $ids, $resync = true)
799 {
800 global $db, $config;
801
802 if (is_array($ids) && sizeof($ids))
803 {
804 $ids = array_unique($ids);
805 $ids = array_map('intval', $ids);
806 }
807 else
808 {
809 $ids = array((int) $ids);
810 }
811
812 if (!sizeof($ids))
813 {
814 return false;
815 }
816
817 switch ($mode)
818 {
819 case 'post':
820 case 'message':
821 $sql_id = 'post_msg_id';
822 break;
823
824 case 'topic':
825 $sql_id = 'topic_id';
826 break;
827
828 case 'user':
829 $sql_id = 'poster_id';
830 break;
831
832 case 'attach':
833 default:
834 $sql_id = 'attach_id';
835 $mode = 'attach';
836 break;
837 }
838
839 $post_ids = $message_ids = $topic_ids = $physical = array();
840
841 // Collect post and topic ids for later use if we need to touch remaining entries (if resync is enabled)
842 $sql = 'SELECT post_msg_id, topic_id, in_message, physical_filename, thumbnail, filesize, is_orphan
843 FROM ' . ATTACHMENTS_TABLE . '
844 WHERE ' . $db->sql_in_set($sql_id, $ids);
845 $result = $db->sql_query($sql);
846
847 while ($row = $db->sql_fetchrow($result))
848 {
849 // We only need to store post/message/topic ids if resync is enabled and the file is not orphaned
850 if ($resync && !$row['is_orphan'])
851 {
852 if (!$row['in_message'])
853 {
854 $post_ids[] = $row['post_msg_id'];
855 $topic_ids[] = $row['topic_id'];
856 }
857 else
858 {
859 $message_ids[] = $row['post_msg_id'];
860 }
861 }
862
863 $physical[] = array('filename' => $row['physical_filename'], 'thumbnail' => $row['thumbnail'], 'filesize' => $row['filesize'], 'is_orphan' => $row['is_orphan']);
864 }
865 $db->sql_freeresult($result);
866
867 // Delete attachments
868 $sql = 'DELETE FROM ' . ATTACHMENTS_TABLE . '
869 WHERE ' . $db->sql_in_set($sql_id, $ids);
870 $db->sql_query($sql);
871 $num_deleted = $db->sql_affectedrows();
872
873 if (!$num_deleted)
874 {
875 return 0;
876 }
877
878 // Delete attachments from filesystem
879 $space_removed = $files_removed = 0;
880 foreach ($physical as $file_ary)
881 {
882 if (phpbb_unlink($file_ary['filename'], 'file', true) && !$file_ary['is_orphan'])
883 {
884 // Only non-orphaned files count to the file size
885 $space_removed += $file_ary['filesize'];
886 $files_removed++;
887 }
888
889 if ($file_ary['thumbnail'])
890 {
891 phpbb_unlink($file_ary['filename'], 'thumbnail', true);
892 }
893 }
894
895 if ($space_removed || $files_removed)
896 {
897 set_config('upload_dir_size', $config['upload_dir_size'] - $space_removed, true);
898 set_config('num_files', $config['num_files'] - $files_removed, true);
899 }
900
901 // If we do not resync, we do not need to adjust any message, post, topic or user entries
902 if (!$resync)
903 {
904 return $num_deleted;
905 }
906
907 // No more use for the original ids
908 unset($ids);
909
910 // Now, we need to resync posts, messages, topics. We go through every one of them
911 $post_ids = array_unique($post_ids);
912 $message_ids = array_unique($message_ids);
913 $topic_ids = array_unique($topic_ids);
914
915 // Update post indicators for posts now no longer having attachments
916 if (sizeof($post_ids))
917 {
918 $sql = 'UPDATE ' . POSTS_TABLE . '
919 SET post_attachment = 0
920 WHERE ' . $db->sql_in_set('post_id', $post_ids);
921 $db->sql_query($sql);
922 }
923
924 // Update message table if messages are affected
925 if (sizeof($message_ids))
926 {
927 $sql = 'UPDATE ' . PRIVMSGS_TABLE . '
928 SET message_attachment = 0
929 WHERE ' . $db->sql_in_set('msg_id', $message_ids);
930 $db->sql_query($sql);
931 }
932
933 // Now update the topics. This is a bit trickier, because there could be posts still having attachments within the topic
934 if (sizeof($topic_ids))
935 {
936 // Just check which topics are still having an assigned attachment not orphaned by querying the attachments table (much less entries expected)
937 $sql = 'SELECT topic_id
938 FROM ' . ATTACHMENTS_TABLE . '
939 WHERE ' . $db->sql_in_set('topic_id', $topic_ids) . '
940 AND is_orphan = 0';
941 $result = $db->sql_query($sql);
942
943 $remaining_ids = array();
944 while ($row = $db->sql_fetchrow($result))
945 {
946 $remaining_ids[] = $row['topic_id'];
947 }
948 $db->sql_freeresult($result);
949
950 // Now only unset those ids remaining
951 $topic_ids = array_diff($topic_ids, $remaining_ids);
952
953 if (sizeof($topic_ids))
954 {
955 $sql = 'UPDATE ' . TOPICS_TABLE . '
956 SET topic_attachment = 0
957 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
958 $db->sql_query($sql);
959 }
960 }
961
962 return $num_deleted;
963 }
964
965 /**
966 * Remove topic shadows
967 */
968 function delete_topic_shadows($max_age, $forum_id = '', $auto_sync = true)
969 {
970 $where = (is_array($forum_id)) ? 'AND ' . $db->sql_in_set('t.forum_id', array_map('intval', $forum_id)) : (($forum_id) ? 'AND t.forum_id = ' . (int) $forum_id : '');
971
972 if ($db->multi_table_deletion)
973 {
974 $sql = 'DELETE FROM ' . TOPICS_TABLE . ' t
975 USING ' . TOPICS_TABLE . ' t2
976 WHERE t.topic_moved_id = t2.topic_id
977 AND t.topic_time < ' . (time() - $max_age)
978 . $where;
979 $db->sql_query($sql);
980 }
981 else
982 {
983 $sql = 'SELECT t.topic_id
984 FROM ' . TOPICS_TABLE . ' t, ' . TOPICS_TABLE . ' t2
985 WHERE t.topic_moved_id = t2.topic_id
986 AND t.topic_time < ' . (time() - $max_age)
987 . $where;
988 $result = $db->sql_query($sql);
989
990 $topic_ids = array();
991 while ($row = $db->sql_fetchrow($result))
992 {
993 $topic_ids[] = $row['topic_id'];
994 }
995 $db->sql_freeresult($result);
996
997 if (sizeof($topic_ids))
998 {
999 $sql = 'DELETE FROM ' . TOPICS_TABLE . '
1000 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
1001 $db->sql_query($sql);
1002 }
1003 }
1004
1005 if ($auto_sync)
1006 {
1007 $where_type = ($forum_id) ? 'forum_id' : '';
1008 sync('forum', $where_type, $forum_id, true, true);
1009 }
1010 }
1011
1012 /**
1013 * Update/Sync posted information for topics
1014 */
1015 function update_posted_info(&$topic_ids)
1016 {
1017 global $db, $config;
1018
1019 if (empty($topic_ids) || !$config['load_db_track'])
1020 {
1021 return;
1022 }
1023
1024 // First of all, let us remove any posted information for these topics
1025 $sql = 'DELETE FROM ' . TOPICS_POSTED_TABLE . '
1026 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
1027 $db->sql_query($sql);
1028
1029 // Now, let us collect the user/topic combos for rebuilding the information
1030 $sql = 'SELECT poster_id, topic_id
1031 FROM ' . POSTS_TABLE . '
1032 WHERE ' . $db->sql_in_set('topic_id', $topic_ids) . '
1033 AND poster_id <> ' . ANONYMOUS . '
1034 GROUP BY poster_id, topic_id';
1035 $result = $db->sql_query($sql);
1036
1037 $posted = array();
1038 while ($row = $db->sql_fetchrow($result))
1039 {
1040 // Add as key to make them unique (grouping by) and circumvent empty keys on array_unique
1041 $posted[$row['poster_id']][] = $row['topic_id'];
1042 }
1043 $db->sql_freeresult($result);
1044
1045 // Now add the information...
1046 $sql_ary = array();
1047 foreach ($posted as $user_id => $topic_row)
1048 {
1049 foreach ($topic_row as $topic_id)
1050 {
1051 $sql_ary[] = array(
1052 'user_id' => (int) $user_id,
1053 'topic_id' => (int) $topic_id,
1054 'topic_posted' => 1,
1055 );
1056 }
1057 }
1058 unset($posted);
1059
1060 $db->sql_multi_insert(TOPICS_POSTED_TABLE, $sql_ary);
1061 }
1062
1063 /**
1064 * Delete attached file
1065 */
1066 function phpbb_unlink($filename, $mode = 'file', $entry_removed = false)
1067 {
1068 global $db, $config;
1069
1070 // Because of copying topics or modifications a physical filename could be assigned more than once. If so, do not remove the file itself.
1071 $sql = 'SELECT COUNT(attach_id) AS num_entries
1072 FROM ' . ATTACHMENTS_TABLE . "
1073 WHERE physical_filename = '" . $db->sql_escape(basename($filename)) . "'";
1074 $result = $db->sql_query($sql);
1075 $num_entries = (int) $db->sql_fetchfield('num_entries');
1076 $db->sql_freeresult($result);
1077
1078 // Do not remove file if at least one additional entry with the same name exist.
1079 if (($entry_removed && $num_entries > 0) || (!$entry_removed && $num_entries > 1))
1080 {
1081 return false;
1082 }
1083
1084 $filename = ($mode == 'thumbnail') ? 'thumb_' . basename($filename) : basename($filename);
1085 return @unlink(PHPBB_ROOT_PATH . $config['upload_path'] . '/' . $filename);
1086 }
1087
1088 /**
1089 * All-encompasing sync function
1090 *
1091 * Exaples:
1092 * <code>
1093 * sync('topic', 'topic_id', 123); // resync topic #123
1094 * sync('topic', 'forum_id', array(2, 3)); // resync topics from forum #2 and #3
1095 * sync('topic'); // resync all topics
1096 * sync('topic', 'range', 'topic_id BETWEEN 1 AND 60'); // resync a range of topics/forums (only available for 'topic' and 'forum' modes)
1097 * </code>
1098 *
1099 * Modes:
1100 * - forum Resync complete forum
1101 * - topic Resync topics
1102 * - topic_moved Removes topic shadows that would be in the same forum as the topic they link to
1103 * - topic_approved Resyncs the topic_approved flag according to the status of the first post
1104 * - post_reported Resyncs the post_reported flag, relying on actual reports
1105 * - topic_reported Resyncs the topic_reported flag, relying on post_reported flags
1106 * - post_attachement Same as post_reported, but with attachment flags
1107 * - topic_attachement Same as topic_reported, but with attachment flags
1108 */
1109 function sync($mode, $where_type = '', $where_ids = '', $resync_parents = false, $sync_extra = false)
1110 {
1111 global $db;
1112
1113 if (is_array($where_ids))
1114 {
1115 $where_ids = array_unique($where_ids);
1116 $where_ids = array_map('intval', $where_ids);
1117 }
1118 else if ($where_type != 'range')
1119 {
1120 $where_ids = ($where_ids) ? array((int) $where_ids) : array();
1121 }
1122
1123 if ($mode == 'forum' || $mode == 'topic' || $mode == 'topic_approved' || $mode == 'topic_reported' || $mode == 'post_reported')
1124 {
1125 if (!$where_type)
1126 {
1127 $where_sql = '';
1128 $where_sql_and = 'WHERE';
1129 }
1130 else if ($where_type == 'range')
1131 {
1132 // Only check a range of topics/forums. For instance: 'topic_id BETWEEN 1 AND 60'
1133 $where_sql = 'WHERE (' . $mode[0] . ".$where_ids)";
1134 $where_sql_and = $where_sql . "\n\tAND";
1135 }
1136 else
1137 {
1138 // Do not sync the "global forum"
1139 $where_ids = array_diff($where_ids, array(0));
1140
1141 if (!sizeof($where_ids))
1142 {
1143 // Empty array with IDs. This means that we don't have any work to do. Just return.
1144 return;
1145 }
1146
1147 // Limit the topics/forums we are syncing, use specific topic/forum IDs.
1148 // $where_type contains the field for the where clause (forum_id, topic_id)
1149 $where_sql = 'WHERE ' . $db->sql_in_set($mode[0] . '.' . $where_type, $where_ids);
1150 $where_sql_and = $where_sql . "\n\tAND";
1151 }
1152 }
1153 else
1154 {
1155 if (!sizeof($where_ids))
1156 {
1157 return;
1158 }
1159
1160 // $where_type contains the field for the where clause (forum_id, topic_id)
1161 $where_sql = 'WHERE ' . $db->sql_in_set($mode[0] . '.' . $where_type, $where_ids);
1162 $where_sql_and = $where_sql . "\n\tAND";
1163 }
1164
1165 switch ($mode)
1166 {
1167 case 'topic_moved':
1168 if ($db->multi_table_deletion)
1169 {
1170 $sql = 'DELETE FROM ' . TOPICS_TABLE . '
1171 USING ' . TOPICS_TABLE . ' t1, ' . TOPICS_TABLE . " t2
1172 WHERE t1.topic_moved_id = t2.topic_id
1173 AND t1.forum_id = t2.forum_id";
1174 $db->sql_query($sql);
1175 }
1176 else
1177 {
1178 $sql = 'SELECT t1.topic_id
1179 FROM ' .TOPICS_TABLE . ' t1, ' . TOPICS_TABLE . " t2
1180 WHERE t1.topic_moved_id = t2.topic_id
1181 AND t1.forum_id = t2.forum_id";
1182 $result = $db->sql_query($sql);
1183
1184 $topic_id_ary = array();
1185 while ($row = $db->sql_fetchrow($result))
1186 {
1187 $topic_id_ary[] = $row['topic_id'];
1188 }
1189 $db->sql_freeresult($result);
1190
1191 if (!sizeof($topic_id_ary))
1192 {
1193 return;
1194 }
1195
1196 $sql = 'DELETE FROM ' . TOPICS_TABLE . '
1197 WHERE ' . $db->sql_in_set('topic_id', $topic_id_ary);
1198 $db->sql_query($sql);
1199 }
1200 break;
1201
1202 case 'topic_approved':
1203 if ($db->dbms_type == 'mysql')
1204 {
1205 $sql = 'UPDATE ' . TOPICS_TABLE . ' t, ' . POSTS_TABLE . " p
1206 SET t.topic_approved = p.post_approved
1207 $where_sql_and t.topic_first_post_id = p.post_id";
1208 $db->sql_query($sql);
1209 }
1210 else
1211 {
1212 $sql = 'SELECT t.topic_id, p.post_approved
1213 FROM ' . TOPICS_TABLE . ' t, ' . POSTS_TABLE . " p
1214 $where_sql_and p.post_id = t.topic_first_post_id
1215 AND p.post_approved <> t.topic_approved";
1216 $result = $db->sql_query($sql);
1217
1218 $topic_ids = array();
1219 while ($row = $db->sql_fetchrow($result))
1220 {
1221 $topic_ids[] = $row['topic_id'];
1222 }
1223 $db->sql_freeresult($result);
1224
1225 if (!sizeof($topic_ids))
1226 {
1227 return;
1228 }
1229
1230 $sql = 'UPDATE ' . TOPICS_TABLE . '
1231 SET topic_approved = 1 - topic_approved
1232 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
1233 $db->sql_query($sql);
1234 }
1235 break;
1236
1237 case 'post_reported':
1238 $post_ids = $post_reported = array();
1239
1240 $sql = 'SELECT p.post_id, p.post_reported
1241 FROM ' . POSTS_TABLE . " p
1242 $where_sql
1243 GROUP BY p.post_id, p.post_reported";
1244 $result = $db->sql_query($sql);
1245
1246 while ($row = $db->sql_fetchrow($result))
1247 {
1248 $post_ids[$row['post_id']] = $row['post_id'];
1249 if ($row['post_reported'])
1250 {
1251 $post_reported[$row['post_id']] = 1;
1252 }
1253 }
1254 $db->sql_freeresult($result);
1255
1256 $sql = 'SELECT DISTINCT(post_id)
1257 FROM ' . REPORTS_TABLE . '
1258 WHERE ' . $db->sql_in_set('post_id', $post_ids) . '
1259 AND report_closed = 0';
1260 $result = $db->sql_query($sql);
1261
1262 $post_ids = array();
1263 while ($row = $db->sql_fetchrow($result))
1264 {
1265 if (!isset($post_reported[$row['post_id']]))
1266 {
1267 $post_ids[] = $row['post_id'];
1268 }
1269 else
1270 {
1271 unset($post_reported[$row['post_id']]);
1272 }
1273 }
1274 $db->sql_freeresult($result);
1275
1276 // $post_reported should be empty by now, if it's not it contains
1277 // posts that are falsely flagged as reported
1278 foreach ($post_reported as $post_id => $void)
1279 {
1280 $post_ids[] = $post_id;
1281 }
1282
1283 if (sizeof($post_ids))
1284 {
1285 $sql = 'UPDATE ' . POSTS_TABLE . '
1286 SET post_reported = 1 - post_reported
1287 WHERE ' . $db->sql_in_set('post_id', $post_ids);
1288 $db->sql_query($sql);
1289 }
1290 break;
1291
1292 case 'topic_reported':
1293 if ($sync_extra)
1294 {
1295 sync('post_reported', $where_type, $where_ids);
1296 }
1297
1298 $topic_ids = $topic_reported = array();
1299
1300 $sql = 'SELECT DISTINCT(t.topic_id)
1301 FROM ' . POSTS_TABLE . " t
1302 $where_sql_and t.post_reported = 1";
1303 $result = $db->sql_query($sql);
1304
1305 while ($row = $db->sql_fetchrow($result))
1306 {
1307 $topic_reported[$row['topic_id']] = 1;
1308 }
1309 $db->sql_freeresult($result);
1310
1311 $sql = 'SELECT t.topic_id, t.topic_reported
1312 FROM ' . TOPICS_TABLE . " t
1313 $where_sql";
1314 $result = $db->sql_query($sql);
1315
1316 while ($row = $db->sql_fetchrow($result))
1317 {
1318 if ($row['topic_reported'] ^ isset($topic_reported[$row['topic_id']]))
1319 {
1320 $topic_ids[] = $row['topic_id'];
1321 }
1322 }
1323 $db->sql_freeresult($result);
1324
1325 if (sizeof($topic_ids))
1326 {
1327 $sql = 'UPDATE ' . TOPICS_TABLE . '
1328 SET topic_reported = 1 - topic_reported
1329 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
1330 $db->sql_query($sql);
1331 }
1332 break;
1333
1334 case 'post_attachment':
1335 $post_ids = $post_attachment = array();
1336
1337 $sql = 'SELECT p.post_id, p.post_attachment
1338 FROM ' . POSTS_TABLE . " p
1339 $where_sql
1340 GROUP BY p.post_id, p.post_attachment";
1341 $result = $db->sql_query($sql);
1342
1343 while ($row = $db->sql_fetchrow($result))
1344 {
1345 $post_ids[$row['post_id']] = $row['post_id'];
1346 if ($row['post_attachment'])
1347 {
1348 $post_attachment[$row['post_id']] = 1;
1349 }
1350 }
1351 $db->sql_freeresult($result);
1352
1353 $sql = 'SELECT DISTINCT(post_msg_id)
1354 FROM ' . ATTACHMENTS_TABLE . '
1355 WHERE ' . $db->sql_in_set('post_msg_id', $post_ids) . '
1356 AND in_message = 0';
1357 $result = $db->sql_query($sql);
1358
1359 $post_ids = array();
1360 while ($row = $db->sql_fetchrow($result))
1361 {
1362 if (!isset($post_attachment[$row['post_msg_id']]))
1363 {
1364 $post_ids[] = $row['post_msg_id'];
1365 }
1366 else
1367 {
1368 unset($post_attachment[$row['post_msg_id']]);
1369 }
1370 }
1371 $db->sql_freeresult($result);
1372
1373 // $post_attachment should be empty by now, if it's not it contains
1374 // posts that are falsely flagged as having attachments
1375 foreach ($post_attachment as $post_id => $void)
1376 {
1377 $post_ids[] = $post_id;
1378 }
1379
1380 if (sizeof($post_ids))
1381 {
1382 $sql = 'UPDATE ' . POSTS_TABLE . '
1383 SET post_attachment = 1 - post_attachment
1384 WHERE ' . $db->sql_in_set('post_id', $post_ids);
1385 $db->sql_query($sql);
1386 }
1387 break;
1388
1389 case 'topic_attachment':
1390 if ($sync_extra)
1391 {
1392 sync('post_attachment', $where_type, $where_ids);
1393 }
1394
1395 $topic_ids = $topic_attachment = array();
1396
1397 $sql = 'SELECT DISTINCT(t.topic_id)
1398 FROM ' . POSTS_TABLE . " t
1399 $where_sql_and t.post_attachment = 1";
1400 $result = $db->sql_query($sql);
1401
1402 while ($row = $db->sql_fetchrow($result))
1403 {
1404 $topic_attachment[$row['topic_id']] = 1;
1405 }
1406 $db->sql_freeresult($result);
1407
1408 $sql = 'SELECT t.topic_id, t.topic_attachment
1409 FROM ' . TOPICS_TABLE . " t
1410 $where_sql";
1411 $result = $db->sql_query($sql);
1412
1413 while ($row = $db->sql_fetchrow($result))
1414 {
1415 if ($row['topic_attachment'] ^ isset($topic_attachment[$row['topic_id']]))
1416 {
1417 $topic_ids[] = $row['topic_id'];
1418 }
1419 }
1420 $db->sql_freeresult($result);
1421
1422 if (sizeof($topic_ids))
1423 {
1424 $sql = 'UPDATE ' . TOPICS_TABLE . '
1425 SET topic_attachment = 1 - topic_attachment
1426 WHERE ' . $db->sql_in_set('topic_id', $topic_ids);
1427 $db->sql_query($sql);
1428 }
1429 break;
1430
1431 case 'forum':
1432
1433 // 1: Get the list of all forums
1434 $sql = 'SELECT f.*
1435 FROM ' . FORUMS_TABLE . " f
1436 $where_sql";
1437 $result = $db->sql_query($sql);
1438
1439 $forum_data = $forum_ids = $post_ids = $last_post_id = $post_info = array();
1440 while ($row = $db->sql_fetchrow($result))
1441 {
1442 if ($row['forum_type'] == FORUM_LINK)
1443 {
1444 continue;
1445 }
1446
1447 $forum_id = (int) $row['forum_id'];
1448 $forum_ids[$forum_id] = $forum_id;
1449
1450 $forum_data[$forum_id] = $row;
1451 if ($sync_extra)
1452 {
1453 $forum_data[$forum_id]['posts'] = 0;
1454 $forum_data[$forum_id]['topics'] = 0;
1455 $forum_data[$forum_id]['topics_real'] = 0;
1456 }
1457 $forum_data[$forum_id]['last_post_id'] = 0;
1458 $forum_data[$forum_id]['last_post_subject'] = '';
1459 $forum_data[$forum_id]['last_post_time'] = 0;
1460 $forum_data[$forum_id]['last_poster_id'] = 0;
1461 $forum_data[$forum_id]['last_poster_name'] = '';
1462 $forum_data[$forum_id]['last_poster_colour'] = '';
1463 }
1464 $db->sql_freeresult($result);
1465
1466 if (!sizeof($forum_ids))
1467 {
1468 break;
1469 }
1470
1471 $forum_ids = array_values($forum_ids);
1472
1473 // 2: Get topic counts for each forum (optional)
1474 if ($sync_extra)
1475 {
1476 $sql = 'SELECT forum_id, topic_approved, COUNT(topic_id) AS forum_topics
1477 FROM ' . TOPICS_TABLE . '
1478 WHERE ' . $db->sql_in_set('forum_id', $forum_ids) . '
1479 GROUP BY forum_id, topic_approved';
1480 $result = $db->sql_query($sql);
1481
1482 while ($row = $db->sql_fetchrow($result))
1483 {
1484 $forum_id = (int) $row['forum_id'];
1485 $forum_data[$forum_id]['topics_real'] += $row['forum_topics'];
1486
1487 if ($row['topic_approved'])
1488 {
1489 $forum_data[$forum_id]['topics'] = $row['forum_topics'];
1490 }
1491 }
1492 $db->sql_freeresult($result);
1493 }
1494
1495 // 3: Get post count for each forum (optional)
1496 if ($sync_extra)
1497 {
1498 if (sizeof($forum_ids) == 1)
1499 {
1500 $sql = 'SELECT SUM(t.topic_replies + 1) AS forum_posts
1501 FROM ' . TOPICS_TABLE . ' t
1502 WHERE ' . $db->sql_in_set('t.forum_id', $forum_ids) . '
1503 AND t.topic_approved = 1
1504 AND t.topic_status <> ' . ITEM_MOVED;
1505 }
1506 else
1507 {
1508 $sql = 'SELECT t.forum_id, SUM(t.topic_replies + 1) AS forum_posts
1509 FROM ' . TOPICS_TABLE . ' t
1510 WHERE ' . $db->sql_in_set('t.forum_id', $forum_ids) . '
1511 AND t.topic_approved = 1
1512 AND t.topic_status <> ' . ITEM_MOVED . '
1513 GROUP BY t.forum_id';
1514 }
1515
1516 $result = $db->sql_query($sql);
1517
1518 while ($row = $db->sql_fetchrow($result))
1519 {
1520 $forum_id = (sizeof($forum_ids) == 1) ? (int) $forum_ids[0] : (int) $row['forum_id'];
1521
1522 $forum_data[$forum_id]['posts'] = (int) $row['forum_posts'];
1523 }
1524 $db->sql_freeresult($result);
1525 }
1526
1527 // 4: Get last_post_id for each forum
1528 if (sizeof($forum_ids) == 1)
1529 {
1530 $sql = 'SELECT MAX(t.topic_last_post_id) as last_post_id
1531 FROM ' . TOPICS_TABLE . ' t
1532 WHERE ' . $db->sql_in_set('t.forum_id', $forum_ids) . '
1533 AND t.topic_approved = 1';
1534 }
1535 else
1536 {
1537 $sql = 'SELECT t.forum_id, MAX(t.topic_last_post_id) as last_post_id
1538 FROM ' . TOPICS_TABLE . ' t
1539 WHERE ' . $db->sql_in_set('t.forum_id', $forum_ids) . '
1540 AND t.topic_approved = 1
1541 GROUP BY t.forum_id';
1542 }
1543
1544 $result = $db->sql_query($sql);
1545
1546 while ($row = $db->sql_fetchrow($result))
1547 {
1548 $forum_id = (sizeof($forum_ids) == 1) ? (int) $forum_ids[0] : (int) $row['forum_id'];
1549
1550 $forum_data[$forum_id]['last_post_id'] = (int) $row['last_post_id'];
1551
1552 $post_ids[] = $row['last_post_id'];
1553 }
1554 $db->sql_freeresult($result);
1555
1556 // 5: Retrieve last_post infos
1557 if (sizeof($post_ids))
1558 {
1559 $sql = 'SELECT p.post_id, p.poster_id, p.post_subject, p.post_time, p.post_username, u.username, u.user_colour
1560 FROM ' . POSTS_TABLE . ' p, ' . USERS_TABLE . ' u
1561 WHERE ' . $db->sql_in_set('p.post_id', $post_ids) . '
1562 AND p.poster_id = u.user_id';
1563 $result = $db->sql_query($sql);
1564
1565 while ($row = $db->sql_fetchrow($result))
1566 {
1567 $post_info[$row['post_id']] = $row;
1568 }
1569 $db->sql_freeresult($result);
1570
1571 foreach ($forum_data as $forum_id => $data)
1572 {
1573 if ($data['last_post_id'])
1574 {
1575 if (isset($post_info[$data['last_post_id']]))
1576 {
1577 $forum_data[$forum_id]['last_post_subject'] = $post_info[$data['last_post_id']]['post_subject'];
1578 $forum_data[$forum_id]['last_post_time'] = $post_info[$data['last_post_id']]['post_time'];
1579 $forum_data[$forum_id]['last_poster_id'] = $post_info[$data['last_post_id']]['poster_id'];
1580 $forum_data[$forum_id]['last_poster_name'] = ($post_info[$data['last_post_id']]['poster_id'] != ANONYMOUS) ? $post_info[$data['last_post_id']]['username'] : $post_info[$data['last_post_id']]['post_username'];
1581 $forum_data[$forum_id]['last_poster_colour'] = $post_info[$data['last_post_id']]['user_colour'];
1582 }
1583 else
1584 {
1585 // For some reason we did not find the post in the db
1586 $forum_data[$forum_id]['last_post_id'] = 0;
1587 $forum_data[$forum_id]['last_post_subject'] = '';
1588 $forum_data[$forum_id]['last_post_time'] = 0;
1589 $forum_data[$forum_id]['last_poster_id'] = 0;
1590 $forum_data[$forum_id]['last_poster_name'] = '';
1591 $forum_data[$forum_id]['last_poster_colour'] = '';
1592 }
1593 }
1594 }
1595 unset($post_info);
1596 }
1597
1598 // 6: Now do that thing
1599 $fieldnames = array('last_post_id', 'last_post_subject', 'last_post_time', 'last_poster_id', 'last_poster_name', 'last_poster_colour');
1600
1601 if ($sync_extra)
1602 {
1603 array_push($fieldnames, 'posts', 'topics', 'topics_real');
1604 }
1605
1606 foreach ($forum_data as $forum_id => $row)
1607 {
1608 $sql_ary = array();
1609
1610 foreach ($fieldnames as $fieldname)
1611 {
1612 if ($row['forum_' . $fieldname] != $row[$fieldname])
1613 {
1614 if (preg_match('#(name|colour|subject)$#', $fieldname))
1615 {
1616 $sql_ary['forum_' . $fieldname] = (string) $row[$fieldname];
1617 }
1618 else
1619 {
1620 $sql_ary['forum_' . $fieldname] = (int) $row[$fieldname];
1621 }
1622 }
1623 }
1624
1625 if (sizeof($sql_ary))
1626 {
1627 $sql = 'UPDATE ' . FORUMS_TABLE . '
1628 SET ' . $db->sql_build_array('UPDATE', $sql_ary) . '
1629 WHERE forum_id = ' . $forum_id;
1630 $db->sql_query($sql);
1631 }
1632 }
1633 break;
1634
1635 case 'topic':
1636 $topic_data = $post_ids = $approved_unapproved_ids = $resync_forums = $delete_topics = $delete_posts = $moved_topics = array();
1637
1638 $sql = 'SELECT t.topic_id, t.forum_id, t.topic_moved_id, t.topic_approved, ' . (($sync_extra) ? 't.topic_attachment, t.topic_reported, ' : '') . 't.topic_poster, t.topic_time, t.topic_replies, t.topic_replies_real, t.topic_first_post_id, t.topic_first_poster_name, t.topic_first_poster_colour, t.topic_last_post_id, t.topic_last_post_subject, t.topic_last_poster_id, t.topic_last_poster_name, t.topic_last_poster_colour, t.topic_last_post_time
1639 FROM ' . TOPICS_TABLE . " t
1640 $where_sql";
1641 $result = $db->sql_query($sql);
1642
1643 while ($row = $db->sql_fetchrow($result))
1644 {
1645 if ($row['topic_moved_id'])
1646 {
1647 $moved_topics[] = $row['topic_id'];
1648 continue;
1649 }
1650
1651 $topic_id = (int) $row['topic_id'];
1652 $topic_data[$topic_id] = $row;
1653 $topic_data[$topic_id]['replies_real'] = -1;
1654 $topic_data[$topic_id]['replies'] = 0;
1655 $topic_data[$topic_id]['first_post_id'] = 0;
1656 $topic_data[$topic_id]['last_post_id'] = 0;
1657 unset($topic_data[$topic_id]['topic_id']);
1658
1659 // This array holds all topic_ids
1660 $delete_topics[$topic_id] = '';
1661
1662 if ($sync_extra)
1663 {
1664 $topic_data[$topic_id]['reported'] = 0;
1665 $topic_data[$topic_id]['attachment'] = 0;
1666 }
1667 }
1668 $db->sql_freeresult($result);
1669
1670 // Use "t" as table alias because of the $where_sql clause
1671 // NOTE: 't.post_approved' in the GROUP BY is causing a major slowdown.
1672 $sql = 'SELECT t.topic_id, t.post_approved, COUNT(t.post_id) AS total_posts, MIN(t.post_id) AS first_post_id, MAX(t.post_id) AS last_post_id
1673 FROM ' . POSTS_TABLE . " t
1674 $where_sql
1675 GROUP BY t.topic_id, t.post_approved";
1676 $result = $db->sql_query($sql);
1677
1678 while ($row = $db->sql_fetchrow($result))
1679 {
1680 $topic_id = (int) $row['topic_id'];
1681
1682 $row['first_post_id'] = (int) $row['first_post_id'];
1683 $row['last_post_id'] = (int) $row['last_post_id'];
1684
1685 if (!isset($topic_data[$topic_id]))
1686 {
1687 // Hey, these posts come from a topic that does not exist
1688 $delete_posts[$topic_id] = '';
1689 }
1690 else
1691 {
1692 // Unset the corresponding entry in $delete_topics
1693 // When we'll be done, only topics with no posts will remain
1694 unset($delete_topics[$topic_id]);
1695
1696 $topic_data[$topic_id]['replies_real'] += $row['total_posts'];
1697 $topic_data[$topic_id]['first_post_id'] = (!$topic_data[$topic_id]['first_post_id']) ? $row['first_post_id'] : min($topic_data[$topic_id]['first_post_id'], $row['first_post_id']);
1698
1699 if ($row['post_approved'] || !$topic_data[$topic_id]['last_post_id'])
1700 {
1701 $topic_data[$topic_id]['replies'] = $row['total_posts'] - 1;
1702 $topic_data[$topic_id]['last_post_id'] = $row['last_post_id'];
1703 }
1704 }
1705 }
1706 $db->sql_freeresult($result);
1707
1708 foreach ($topic_data as $topic_id => $row)
1709 {
1710 $post_ids[] = $row['first_post_id'];
1711 if ($row['first_post_id'] != $row['last_post_id'])
1712 {
1713 $post_ids[] = $row['last_post_id'];
1714 }
1715 }
1716
1717 // Now we delete empty topics and orphan posts
1718 if (sizeof($delete_posts))
1719 {
1720 delete_posts('topic_id', array_keys($delete_posts), false);
1721 unset($delete_posts);
1722 }
1723
1724 if (!sizeof($topic_data))
1725 {
1726 // If we get there, topic ids were invalid or topics did not contain any posts
1727 delete_topics($where_type, $where_ids, true);
1728 return;
1729 }
1730
1731 if (sizeof($delete_topics))
1732 {
1733 $delete_topic_ids = array();
1734 foreach ($delete_topics as $topic_id => $void)
1735 {
1736 unset($topic_data[$topic_id]);
1737 $delete_topic_ids[] = $topic_id;
1738 }
1739
1740 delete_topics('topic_id', $delete_topic_ids, false);
1741 unset($delete_topics, $delete_topic_ids);
1742 }
1743
1744 $sql = 'SELECT p.post_id, p.topic_id, p.post_approved, p.poster_id, p.post_subject, p.post_username, p.post_time, u.username, u.user_colour
1745 FROM ' . POSTS_TABLE . ' p, ' . USERS_TABLE . ' u
1746 WHERE ' . $db->sql_in_set('p.post_id', $post_ids) . '
1747 AND u.user_id = p.poster_id';
1748 $result = $db->sql_query($sql);
1749
1750 $post_ids = array();
1751 while ($row = $db->sql_fetchrow($result))
1752 {
1753 $topic_id = intval($row['topic_id']);
1754
1755 if ($row['post_id'] == $topic_data[$topic_id]['first_post_id'])
1756 {
1757 if ($topic_data[$topic_id]['topic_approved'] != $row['post_approved'])
1758 {
1759 $approved_unapproved_ids[] = $topic_id;
1760 }
1761 $topic_data[$topic_id]['time'] = $row['post_time'];
1762 $topic_data[$topic_id]['poster'] = $row['poster_id'];
1763 $topic_data[$topic_id]['first_poster_name'] = ($row['poster_id'] == ANONYMOUS) ? $row['post_username'] : $row['username'];
1764 $topic_data[$topic_id]['first_poster_colour'] = $row['user_colour'];
1765 }
1766
1767 if ($row['post_id'] == $topic_data[$topic_id]['last_post_id'])
1768 {
1769 $topic_data[$topic_id]['last_poster_id'] = $row['poster_id'];
1770 $topic_data[$topic_id]['last_post_subject'] = $row['post_subject'];
1771 $topic_data[$topic_id]['last_post_time'] = $row['post_time'];
1772 $topic_data[$topic_id]['last_poster_name'] = ($row['poster_id'] == ANONYMOUS) ? $row['post_username'] : $row['username'];
1773 $topic_data[$topic_id]['last_poster_colour'] = $row['user_colour'];
1774 }
1775 }
1776 $db->sql_freeresult($result);
1777
1778 // Make sure shadow topics do link to existing topics
1779 if (sizeof($moved_topics))
1780 {
1781 $delete_topics = array();
1782
1783 $sql = 'SELECT t1.topic_id, t1.topic_moved_id
1784 FROM ' . TOPICS_TABLE . ' t1
1785 LEFT JOIN ' . TOPICS_TABLE . ' t2 ON (t2.topic_id = t1.topic_moved_id)
1786 WHERE ' . $db->sql_in_set('t1.topic_id', $moved_topics) . '
1787 AND t2.topic_id IS NULL';
1788 $result = $db->sql_query($sql);
1789
1790 while ($row = $db->sql_fetchrow($result))
1791 {
1792 $delete_topics[] = $row['topic_id'];
1793 }
1794 $db->sql_freeresult($result);
1795
1796 if (sizeof($delete_topics))
1797 {
1798 delete_topics('topic_id', $delete_topics, false);
1799 }
1800 unset($delete_topics);
1801
1802 // Make sure shadow topics having no last post data being updated (this only rarely happens...)
1803 $sql = 'SELECT topic_id, topic_moved_id, topic_last_post_id, topic_first_post_id
1804 FROM ' . TOPICS_TABLE . '
1805 WHERE ' . $db->sql_in_set('topic_id', $moved_topics) . '
1806 AND topic_last_post_time = 0';
1807 $result = $db->sql_query($sql);
1808
1809 $shadow_topic_data = $post_ids = array();
1810 while ($row = $db->sql_fetchrow($result))
1811 {
1812 $shadow_topic_data[$row['topic_moved_id']] = $row;
1813 $post_ids[] = $row['topic_last_post_id'];
1814 $post_ids[] = $row['topic_first_post_id'];
1815 }
1816 $db->sql_freeresult($result);
1817
1818 $sync_shadow_topics = array();
1819 if (sizeof($post_ids))
1820 {
1821 $sql = 'SELECT p.post_id, p.topic_id, p.post_approved, p.poster_id, p.post_subject, p.post_username, p.post_time, u.username, u.user_colour
1822 FROM ' . POSTS_TABLE . ' p, ' . USERS_TABLE . ' u
1823 WHERE ' . $db->sql_in_set('p.post_id', $post_ids) . '
1824 AND u.user_id = p.poster_id';
1825 $result = $db->sql_query($sql);
1826
1827 $post_ids = array();
1828 while ($row = $db->sql_fetchrow($result))
1829 {
1830 $topic_id = (int) $row['topic_id'];
1831
1832 // Ok, there should be a shadow topic. If there isn't, then there's something wrong with the db.
1833 // However, there's not much we can do about it.
1834 if (!empty($shadow_topic_data[$topic_id]))
1835 {
1836 if ($row['post_id'] == $shadow_topic_data[$topic_id]['topic_first_post_id'])
1837 {
1838 $orig_topic_id = $shadow_topic_data[$topic_id]['topic_id'];
1839
1840 if (!isset($sync_shadow_topics[$orig_topic_id]))
1841 {
1842 $sync_shadow_topics[$orig_topic_id] = array();
1843 }
1844
1845 $sync_shadow_topics[$orig_topic_id]['topic_time'] = $row['post_time'];
1846 $sync_shadow_topics[$orig_topic_id]['topic_poster'] = $row['poster_id'];
1847 $sync_shadow_topics[$orig_topic_id]['topic_first_poster_name'] = ($row['poster_id'] == ANONYMOUS) ? $row['post_username'] : $row['username'];
1848 $sync_shadow_topics[$orig_topic_id]['topic_first_poster_colour'] = $row['user_colour'];
1849 }
1850
1851 if ($row['post_id'] == $shadow_topic_data[$topic_id]['topic_last_post_id'])
1852 {
1853 $orig_topic_id = $shadow_topic_data[$topic_id]['topic_id'];
1854
1855 if (!isset($sync_shadow_topics[$orig_topic_id]))
1856 {
1857 $sync_shadow_topics[$orig_topic_id] = array();
1858 }
1859
1860 $sync_shadow_topics[$orig_topic_id]['topic_last_poster_id'] = $row['poster_id'];
1861 $sync_shadow_topics[$orig_topic_id]['topic_last_post_subject'] = $row['post_subject'];
1862 $sync_shadow_topics[$orig_topic_id]['topic_last_post_time'] = $row['post_time'];
1863 $sync_shadow_topics[$orig_topic_id]['topic_last_poster_name'] = ($row['poster_id'] == ANONYMOUS) ? $row['post_username'] : $row['username'];
1864 $sync_shadow_topics[$orig_topic_id]['topic_last_poster_colour'] = $row['user_colour'];
1865 }
1866 }
1867 }
1868 $db->sql_freeresult($result);
1869
1870 $shadow_topic_data = array();
1871
1872 // Update the information we collected
1873 if (sizeof($sync_shadow_topics))
1874 {
1875 foreach ($sync_shadow_topics as $sync_topic_id => $sql_ary)
1876 {
1877 $sql = 'UPDATE ' . TOPICS_TABLE . '
1878 SET ' . $db->sql_build_array('UPDATE', $sql_ary) . '
1879 WHERE topic_id = ' . $sync_topic_id;
1880 $db->sql_query($sql);
1881 }
1882 }
1883 }
1884
1885 unset($sync_shadow_topics, $shadow_topic_data);
1886 }
1887
1888 // approved becomes unapproved, and vice-versa
1889 if (sizeof($approved_unapproved_ids))
1890 {
1891 $sql = 'UPDATE ' . TOPICS_TABLE . '
1892 SET topic_approved = 1 - topic_approved
1893 WHERE ' . $db->sql_in_set('topic_id', $approved_unapproved_ids);
1894 $db->sql_query($sql);
1895 }
1896 unset($approved_unapproved_ids);
1897
1898 // These are fields that will be synchronised
1899 $fieldnames = array('time', 'replies', 'replies_real', 'poster', 'first_post_id', 'first_poster_name', 'first_poster_colour', 'last_post_id', 'last_post_subject', 'last_post_time', 'last_poster_id', 'last_poster_name', 'last_poster_colour');
1900
1901 if ($sync_extra)
1902 {
1903 // This routine assumes that post_reported values are correct
1904 // if they are not, use sync('post_reported') first
1905 $sql = 'SELECT t.topic_id, p.post_id
1906 FROM ' . TOPICS_TABLE . ' t, ' . POSTS_TABLE . " p
1907 $where_sql_and p.topic_id = t.topic_id
1908 AND p.post_reported = 1
1909 GROUP BY t.topic_id, p.post_id";
1910 $result = $db->sql_query($sql);
1911
1912 $fieldnames[] = 'reported';
1913 while ($row = $db->sql_fetchrow($result))
1914 {
1915 $topic_data[intval($row['topic_id'])]['reported'] = 1;
1916 }
1917 $db->sql_freeresult($result);
1918
1919 // This routine assumes that post_attachment values are correct
1920 // if they are not, use sync('post_attachment') first
1921 $sql = 'SELECT t.topic_id, p.post_id
1922 FROM ' . TOPICS_TABLE . ' t, ' . POSTS_TABLE . " p
1923 $where_sql_and p.topic_id = t.topic_id
1924 AND p.post_attachment = 1
1925 GROUP BY t.topic_id, p.post_id";
1926 $result = $db->sql_query($sql);
1927
1928 $fieldnames[] = 'attachment';
1929 while ($row = $db->sql_fetchrow($result))
1930 {
1931 $topic_data[intval($row['topic_id'])]['attachment'] = 1;
1932 }
1933 $db->sql_freeresult($result);
1934 }
1935
1936 foreach ($topic_data as $topic_id => $row)
1937 {
1938 $sql_ary = array();
1939
1940 foreach ($fieldnames as $fieldname)
1941 {
1942 if (isset($row[$fieldname]) && isset($row['topic_' . $fieldname]) && $row['topic_' . $fieldname] != $row[$fieldname])
1943 {
1944 $sql_ary['topic_' . $fieldname] = $row[$fieldname];
1945 }
1946 }
1947
1948 if (sizeof($sql_ary))
1949 {
1950 $sql = 'UPDATE ' . TOPICS_TABLE . '
1951 SET ' . $db->sql_build_array('UPDATE', $sql_ary) . '
1952 WHERE topic_id = ' . $topic_id;
1953 $db->sql_query($sql);
1954
1955 $resync_forums[$row['forum_id']] = $row['forum_id'];
1956 }
1957 }
1958 unset($topic_data);
1959
1960 // if some topics have been resync'ed then resync parent forums
1961 // except when we're only syncing a range, we don't want to sync forums during
1962 // batch processing.
1963 if ($resync_parents && sizeof($resync_forums) && $where_type != 'range')
1964 {
1965 sync('forum', 'forum_id', array_values($resync_forums), true, true);
1966 }
1967 break;
1968 }
1969
1970 return;
1971 }
1972
1973 /**
1974 * Prune function
1975 */
1976 function prune($forum_id, $prune_mode, $prune_date, $prune_flags = 0, $auto_sync = true)
1977 {
1978 global $db;
1979
1980 if (!is_array($forum_id))
1981 {
1982 $forum_id = array($forum_id);
1983 }
1984
1985 if (!sizeof($forum_id))
1986 {
1987 return;
1988 }
1989
1990 $sql_and = '';
1991
1992 if (!($prune_flags & FORUM_FLAG_PRUNE_ANNOUNCE))
1993 {
1994 $sql_and .= ' AND topic_type <> ' . POST_ANNOUNCE;
1995 }
1996
1997 if (!($prune_flags & FORUM_FLAG_PRUNE_STICKY))
1998 {
1999 $sql_and .= ' AND topic_type <> ' . POST_STICKY;
2000 }
2001
2002 if ($prune_mode == 'posted')
2003 {
2004 $sql_and .= " AND topic_last_post_time < $prune_date";
2005 }
2006
2007 if ($prune_mode == 'viewed')
2008 {
2009 $sql_and .= " AND topic_last_view_time < $prune_date";
2010 }
2011
2012 $sql = 'SELECT topic_id
2013 FROM ' . TOPICS_TABLE . '
2014 WHERE ' . $db->sql_in_set('forum_id', $forum_id) . "
2015 AND poll_start = 0
2016 $sql_and";
2017 $result = $db->sql_query($sql);
2018
2019 $topic_list = array();
2020 while ($row = $db->sql_fetchrow($result))
2021 {
2022 $topic_list[] = $row['topic_id'];
2023 }
2024 $db->sql_freeresult($result);
2025
2026 if ($prune_flags & FORUM_FLAG_PRUNE_POLL)
2027 {
2028 $sql = 'SELECT topic_id
2029 FROM ' . TOPICS_TABLE . '
2030 WHERE ' . $db->sql_in_set('forum_id', $forum_id) . "
2031 AND poll_start > 0
2032 AND poll_last_vote < $prune_date
2033 $sql_and";
2034 $result = $db->sql_query($sql);
2035
2036 while ($row = $db->sql_fetchrow($result))
2037 {
2038 $topic_list[] = $row['topic_id'];
2039 }
2040 $db->sql_freeresult($result);
2041
2042 $topic_list = array_unique($topic_list);
2043 }
2044
2045 return delete_topics('topic_id', $topic_list, $auto_sync, false);
2046 }
2047
2048 /**
2049 * Function auto_prune(), this function now relies on passed vars
2050 */
2051 function auto_prune($forum_id, $prune_mode, $prune_flags, $prune_days, $prune_freq)
2052 {
2053 global $db;
2054
2055 $sql = 'SELECT forum_name
2056 FROM ' . FORUMS_TABLE . "
2057 WHERE forum_id = $forum_id";
2058 $result = $db->sql_query($sql, 3600);
2059 $row = $db->sql_fetchrow($result);
2060 $db->sql_freeresult($result);
2061
2062 if ($row)
2063 {
2064 $prune_date = time() - ($prune_days * 86400);
2065 $next_prune = time() + ($prune_freq * 86400);
2066
2067 prune($forum_id, $prune_mode, $prune_date, $prune_flags, true);
2068
2069 $sql = 'UPDATE ' . FORUMS_TABLE . "
2070 SET prune_next = $next_prune
2071 WHERE forum_id = $forum_id";
2072 $db->sql_query($sql);
2073
2074 add_log('admin', 'LOG_AUTO_PRUNE', $row['forum_name']);
2075 }
2076
2077 return;
2078 }
2079
2080 /**
2081 * remove_comments will strip the sql comment lines out of an uploaded sql file
2082 * specifically for mssql and postgres type files in the install....
2083 */
2084 function remove_comments(&$output)
2085 {
2086 $lines = explode("\n", $output);
2087 $output = '';
2088
2089 // try to keep mem. use down
2090 $linecount = sizeof($lines);
2091
2092 $in_comment = false;
2093 for ($i = 0; $i < $linecount; $i++)
2094 {
2095 if (trim($lines[$i]) == '/*')
2096 {
2097 $in_comment = true;
2098 }
2099
2100 if (!$in_comment)
2101 {
2102 $output .= $lines[$i] . "\n";
2103 }
2104
2105 if (trim($lines[$i]) == '*/')
2106 {
2107 $in_comment = false;
2108 }
2109 }
2110
2111 unset($lines);
2112 return $output;
2113 }
2114
2115 /**
2116 * Cache moderators, called whenever permissions are changed via admin_permissions. Changes of username
2117 * and group names must be carried through for the moderators table
2118 */
2119 function cache_moderators()
2120 {
2121 global $db, $cache, $auth;
2122
2123 // Remove cached sql results
2124 $cache->destroy('sql', MODERATOR_CACHE_TABLE);
2125
2126 // Clear table
2127 if ($db->truncate)
2128 {
2129 $db->sql_query('TRUNCATE TABLE ' . MODERATOR_CACHE_TABLE);
2130 }
2131 else
2132 {
2133 $db->sql_query('DELETE FROM ' . MODERATOR_CACHE_TABLE);
2134 }
2135
2136 // We add moderators who have forum moderator permissions without an explicit ACL_NEVER setting
2137 $hold_ary = $ug_id_ary = $sql_ary = array();
2138
2139 // Grab all users having moderative options...
2140 $hold_ary = $auth->acl_user_raw_data(false, 'm_%', false);
2141
2142 // Add users?
2143 if (sizeof($hold_ary))
2144 {
2145 // At least one moderative option warrants a display
2146 $ug_id_ary = array_keys($hold_ary);
2147
2148 // Remove users who have group memberships with DENY moderator permissions
2149 $sql = $db->sql_build_query('SELECT', array(
2150 'SELECT' => 'a.forum_id, ug.user_id',
2151
2152 'FROM' => array(
2153 ACL_OPTIONS_TABLE => 'o',
2154 USER_GROUP_TABLE => 'ug',
2155 ACL_GROUPS_TABLE => 'a'
2156 ),
2157
2158 'LEFT_JOIN' => array(
2159 array(
2160 'FROM' => array(ACL_ROLES_DATA_TABLE => 'r'),
2161 'ON' => 'a.auth_role_id = r.role_id'
2162 )
2163 ),
2164
2165 'WHERE' => '(o.auth_option_id = a.auth_option_id OR o.auth_option_id = r.auth_option_id)
2166 AND ((a.auth_setting = ' . phpbb::ACL_NEVER . ' AND r.auth_setting IS NULL)
2167 OR r.auth_setting = ' . phpbb::ACL_NEVER . ')
2168 AND a.group_id = ug.group_id
2169 AND ' . $db->sql_in_set('ug.user_id', $ug_id_ary) . "
2170 AND ug.user_pending = 0
2171 AND o.auth_option " . $db->sql_like_expression('m_' . $db->any_char),
2172 ));
2173 $result = $db->sql_query($sql);
2174
2175 while ($row = $db->sql_fetchrow($result))
2176 {
2177 if (isset($hold_ary[$row['user_id']][$row['forum_id']]))
2178 {
2179 unset($hold_ary[$row['user_id']][$row['forum_id']]);
2180 }
2181 }
2182 $db->sql_freeresult($result);
2183
2184 if (sizeof($hold_ary))
2185 {
2186 // Get usernames...
2187 $sql = 'SELECT user_id, username
2188 FROM ' . USERS_TABLE . '
2189 WHERE ' . $db->sql_in_set('user_id', array_keys($hold_ary));
2190 $result = $db->sql_query($sql);
2191
2192 $usernames_ary = array();
2193 while ($row = $db->sql_fetchrow($result))
2194 {
2195 $usernames_ary[$row['user_id']] = $row['username'];
2196 }
2197
2198 foreach ($hold_ary as $user_id => $forum_id_ary)
2199 {
2200 // Do not continue if user does not exist
2201 if (!isset($usernames_ary[$user_id]))
2202 {
2203 continue;
2204 }
2205
2206 foreach ($forum_id_ary as $forum_id => $auth_ary)
2207 {
2208 $sql_ary[] = array(
2209 'forum_id' => (int) $forum_id,
2210 'user_id' => (int) $user_id,
2211 'username' => (string) $usernames_ary[$user_id],
2212 'group_id' => 0,
2213 'group_name' => ''
2214 );
2215 }
2216 }
2217 }
2218 }
2219
2220 // Now to the groups...
2221 $hold_ary = $auth->acl_group_raw_data(false, 'm_%', false);
2222
2223 if (sizeof($hold_ary))
2224 {
2225 $ug_id_ary = array_keys($hold_ary);
2226
2227 // Make sure not hidden or special groups are involved...
2228 $sql = 'SELECT group_name, group_id, group_type
2229 FROM ' . GROUPS_TABLE . '
2230 WHERE ' . $db->sql_in_set('group_id', $ug_id_ary);
2231 $result = $db->sql_query($sql);
2232
2233 $groupnames_ary = array();
2234 while ($row = $db->sql_fetchrow($result))
2235 {
2236 if ($row['group_type'] == GROUP_HIDDEN || $row['group_type'] == GROUP_SPECIAL)
2237 {
2238 unset($hold_ary[$row['group_id']]);
2239 }
2240
2241 $groupnames_ary[$row['group_id']] = $row['group_name'];
2242 }
2243 $db->sql_freeresult($result);
2244
2245 foreach ($hold_ary as $group_id => $forum_id_ary)
2246 {
2247 // If there is no group, we do not assign it...
2248 if (!isset($groupnames_ary[$group_id]))
2249 {
2250 continue;
2251 }
2252
2253 foreach ($forum_id_ary as $forum_id => $auth_ary)
2254 {
2255 $flag = false;
2256 foreach ($auth_ary as $auth_option => $setting)
2257 {
2258 // Make sure at least one ACL_YES option is set...
2259 if ($setting == phpbb::ACL_YES)
2260 {
2261 $flag = true;
2262 break;
2263 }
2264 }
2265
2266 if (!$flag)
2267 {
2268 continue;
2269 }
2270
2271 $sql_ary[] = array(
2272 'forum_id' => (int) $forum_id,
2273 'user_id' => 0,
2274 'username' => '',
2275 'group_id' => (int) $group_id,
2276 'group_name' => (string) $groupnames_ary[$group_id]
2277 );
2278 }
2279 }
2280 }
2281
2282 $db->sql_multi_insert(MODERATOR_CACHE_TABLE, $sql_ary);
2283 }
2284
2285 /**
2286 * View log
2287 */
2288 function view_log($mode, &$log, &$log_count, $limit = 0, $offset = 0, $forum_id = 0, $topic_id = 0, $user_id = 0, $limit_days = 0, $sort_by = 'l.log_time DESC')
2289 {
2290 global $db, $user, $auth;
2291
2292 $topic_id_list = $reportee_id_list = $is_auth = $is_mod = array();
2293
2294 $profile_url = (defined('IN_ADMIN')) ? append_sid(PHPBB_ADMIN_PATH . 'index.' . PHP_EXT, 'i=users&amp;mode=overview') : append_sid('memberlist', 'mode=viewprofile');
2295
2296 switch ($mode)
2297 {
2298 case 'admin':
2299 $log_type = LOG_ADMIN;
2300 $sql_forum = '';
2301 break;
2302
2303 case 'mod':
2304 $log_type = LOG_MOD;
2305
2306 if ($topic_id)
2307 {
2308 $sql_forum = 'AND l.topic_id = ' . intval($topic_id);
2309 }
2310 else if (is_array($forum_id))
2311 {
2312 $sql_forum = 'AND ' . $db->sql_in_set('l.forum_id', array_map('intval', $forum_id));
2313 }
2314 else
2315 {
2316 $sql_forum = ($forum_id) ? 'AND l.forum_id = ' . intval($forum_id) : '';
2317 }
2318 break;
2319
2320 case 'user':
2321 $log_type = LOG_USERS;
2322 $sql_forum = 'AND l.reportee_id = ' . (int) $user_id;
2323 break;
2324
2325 case 'users':
2326 $log_type = LOG_USERS;
2327 $sql_forum = '';
2328 break;
2329
2330 case 'critical':
2331 $log_type = LOG_CRITICAL;
2332 $sql_forum = '';
2333 break;
2334
2335 default:
2336 return;
2337 }
2338
2339 $sql = "SELECT l.*, u.username, u.username_clean, u.user_colour
2340 FROM " . LOG_TABLE . " l, " . USERS_TABLE . " u
2341 WHERE l.log_type = $log_type
2342 AND u.user_id = l.user_id
2343 " . (($limit_days) ? "AND l.log_time >= $limit_days" : '') . "
2344 $sql_forum
2345 ORDER BY $sort_by";
2346 $result = $db->sql_query_limit($sql, $limit, $offset);
2347
2348 $i = 0;
2349 $log = array();
2350 while ($row = $db->sql_fetchrow($result))
2351 {
2352 if ($row['topic_id'])
2353 {
2354 $topic_id_list[] = $row['topic_id'];
2355 }
2356
2357 if ($row['reportee_id'])
2358 {
2359 $reportee_id_list[] = $row['reportee_id'];
2360 }
2361
2362 $log[$i] = array(
2363 'id' => $row['log_id'],
2364
2365 'reportee_id' => $row['reportee_id'],
2366 'reportee_username' => '',
2367 'reportee_username_full'=> '',
2368
2369 'user_id' => $row['user_id'],
2370 'username' => $row['username'],
2371 'username_full' => get_username_string('full', $row['user_id'], $row['username'], $row['user_colour'], false, $profile_url),
2372
2373 'ip' => $row['log_ip'],
2374 'time' => $row['log_time'],
2375 'forum_id' => $row['forum_id'],
2376 'topic_id' => $row['topic_id'],
2377
2378 'viewforum' => ($row['forum_id'] && $auth->acl_get('f_read', $row['forum_id'])) ? append_sid('viewforum', 'f=' . $row['forum_id']) : false,
2379 'action' => (isset($user->lang[$row['log_operation']])) ? $user->lang[$row['log_operation']] : '{' . ucfirst(str_replace('_', ' ', $row['log_operation'])) . '}',
2380 );
2381
2382 if (!empty($row['log_data']))
2383 {
2384 $log_data_ary = unserialize($row['log_data']);
2385
2386 if (isset($user->lang[$row['log_operation']]))
2387 {
2388 // Check if there are more occurrences of % than arguments, if there are we fill out the arguments array
2389 // It doesn't matter if we add more arguments than placeholders
2390 if ((substr_count($log[$i]['action'], '%') - sizeof($log_data_ary)) > 0)
2391 {
2392 $log_data_ary = array_merge($log_data_ary, array_fill(0, substr_count($log[$i]['action'], '%') - sizeof($log_data_ary), ''));
2393 }
2394
2395 $log[$i]['action'] = vsprintf($log[$i]['action'], $log_data_ary);
2396
2397 // If within the admin panel we do not censor text out
2398 if (defined('IN_ADMIN'))
2399 {
2400 $log[$i]['action'] = bbcode_nl2br($log[$i]['action']);
2401 }
2402 else
2403 {
2404 $log[$i]['action'] = bbcode_nl2br(censor_text($log[$i]['action']));
2405 }
2406 }
2407 else
2408 {
2409 $log[$i]['action'] .= '<br />' . implode('', $log_data_ary);
2410 }
2411
2412 /* Apply make_clickable... has to be seen if it is for good. :/
2413 // Seems to be not for the moment, reconsider later...
2414 $log[$i]['action'] = make_clickable($log[$i]['action']);
2415 */
2416 }
2417
2418 $i++;
2419 }
2420 $db->sql_freeresult($result);
2421
2422 if (sizeof($topic_id_list))
2423 {
2424 $topic_id_list = array_unique($topic_id_list);
2425
2426 // This query is not really needed if move_topics() updates the forum_id field,
2427 // although it's also used to determine if the topic still exists in the database
2428 $sql = 'SELECT topic_id, forum_id
2429 FROM ' . TOPICS_TABLE . '
2430 WHERE ' . $db->sql_in_set('topic_id', array_map('intval', $topic_id_list));
2431 $result = $db->sql_query($sql);
2432
2433 $default_forum_id = 0;
2434
2435 while ($row = $db->sql_fetchrow($result))
2436 {
2437 if (!$row['forum_id'])
2438 {
2439 if ($auth->acl_getf_global('f_read'))
2440 {
2441 if (!$default_forum_id)
2442 {
2443 $sql = 'SELECT forum_id
2444 FROM ' . FORUMS_TABLE . '
2445 WHERE forum_type = ' . FORUM_POST;
2446 $f_result = $db->sql_query_limit($sql, 1);
2447 $default_forum_id = (int) $db->sql_fetchfield('forum_id', $f_result);
2448 $db->sql_freeresult($f_result);
2449 }
2450
2451 $is_auth[$row['topic_id']] = $default_forum_id;
2452 }
2453 }
2454 else
2455 {
2456 if ($auth->acl_get('f_read', $row['forum_id']))
2457 {
2458 $is_auth[$row['topic_id']] = $row['forum_id'];
2459 }
2460 }
2461
2462 if ($auth->acl_gets('a_', 'm_', $row['forum_id']))
2463 {
2464 $is_mod[$row['topic_id']] = $row['forum_id'];
2465 }
2466 }
2467 $db->sql_freeresult($result);
2468
2469 foreach ($log as $key => $row)
2470 {
2471 $log[$key]['viewtopic'] = (isset($is_auth[$row['topic_id']])) ? append_sid('viewtopic', 'f=' . $is_auth[$row['topic_id']] . '&amp;t=' . $row['topic_id']) : false;
2472 $log[$key]['viewlogs'] = (isset($is_mod[$row['topic_id']])) ? append_sid('mcp', 'i=logs&amp;mode=topic_logs&amp;t=' . $row['topic_id'], true, $user->session_id) : false;
2473 }
2474 }
2475
2476 if (sizeof($reportee_id_list))
2477 {
2478 $reportee_id_list = array_unique($reportee_id_list);
2479 $reportee_names_list = array();
2480
2481 $sql = 'SELECT user_id, username, user_colour
2482 FROM ' . USERS_TABLE . '
2483 WHERE ' . $db->sql_in_set('user_id', $reportee_id_list);
2484 $result = $db->sql_query($sql);
2485
2486 while ($row = $db->sql_fetchrow($result))
2487 {
2488 $reportee_names_list[$row['user_id']] = $row;
2489 }
2490 $db->sql_freeresult($result);
2491
2492 foreach ($log as $key => $row)
2493 {
2494 if (!isset($reportee_names_list[$row['reportee_id']]))
2495 {
2496 continue;
2497 }
2498
2499 $log[$key]['reportee_username'] = $reportee_names_list[$row['reportee_id']]['username'];
2500 $log[$key]['reportee_username_full'] = get_username_string('full', $row['reportee_id'], $reportee_names_list[$row['reportee_id']]['username'], $reportee_names_list[$row['reportee_id']]['user_colour'], false, $profile_url);
2501 }
2502 }
2503
2504 $sql = 'SELECT COUNT(l.log_id) AS total_entries
2505 FROM ' . LOG_TABLE . " l
2506 WHERE l.log_type = $log_type
2507 AND l.log_time >= $limit_days
2508 $sql_forum";
2509 $result = $db->sql_query($sql);
2510 $log_count = (int) $db->sql_fetchfield('total_entries');
2511 $db->sql_freeresult($result);
2512
2513 return;
2514 }
2515
2516 /**
2517 * Update foes - remove moderators and administrators from foe lists...
2518 */
2519 function update_foes($group_id = false, $user_id = false)
2520 {
2521 global $db, $auth;
2522
2523 // update foes for some user
2524 if (is_array($user_id) && sizeof($user_id))
2525 {
2526 $sql = 'DELETE FROM ' . ZEBRA_TABLE . '
2527 WHERE ' . $db->sql_in_set('zebra_id', $user_id) . '
2528 AND foe = 1';
2529 $db->sql_query($sql);
2530 return;
2531 }
2532
2533 // update foes for some group
2534 if (is_array($group_id) && sizeof($group_id))
2535 {
2536 // Grab group settings...
2537 $sql = $db->sql_build_query('SELECT', array(
2538 'SELECT' => 'a.group_id',
2539
2540 'FROM' => array(
2541 ACL_OPTIONS_TABLE => 'ao',
2542 ACL_GROUPS_TABLE => 'a'
2543 ),
2544
2545 'LEFT_JOIN' => array(
2546 array(
2547 'FROM' => array(ACL_ROLES_DATA_TABLE => 'r'),
2548 'ON' => 'a.auth_role_id = r.role_id'
2549 ),
2550 ),
2551
2552 'WHERE' => '(ao.auth_option_id = a.auth_option_id OR ao.auth_option_id = r.auth_option_id)
2553 AND ' . $db->sql_in_set('a.group_id', $group_id) . "
2554 AND ao.auth_option IN ('a_', 'm_')",
2555
2556 'GROUP_BY' => 'a.group_id'
2557 ));
2558 $result = $db->sql_query($sql);
2559
2560 $groups = array();
2561 while ($row = $db->sql_fetchrow($result))
2562 {
2563 $groups[] = (int) $row['group_id'];
2564 }
2565 $db->sql_freeresult($result);
2566
2567 if (!sizeof($groups))
2568 {
2569 return;
2570 }
2571
2572 if ($db->multi_table_deletion)
2573 {
2574 $sql = 'DELETE FROM' . ZEBRA_TABLE . ' z
2575 USING ' . USER_GROUP_TABLE . ' ug
2576 WHERE z.zebra_id = ug.user_id
2577 AND z.foe = 1
2578 AND ' . $db->sql_in_set('ug.group_id', $groups);
2579 $db->sql_query($sql);
2580 }
2581 else
2582 {
2583 $sql = 'SELECT user_id
2584 FROM ' . USER_GROUP_TABLE . '
2585 WHERE ' . $db->sql_in_set('group_id', $groups);
2586 $result = $db->sql_query($sql);
2587
2588 $users = array();
2589 while ($row = $db->sql_fetchrow($result))
2590 {
2591 $users[] = (int) $row['user_id'];
2592 }
2593 $db->sql_freeresult($result);
2594
2595 if (sizeof($users))
2596 {
2597 $sql = 'DELETE FROM ' . ZEBRA_TABLE . '
2598 WHERE ' . $db->sql_in_set('zebra_id', $users) . '
2599 AND foe = 1';
2600 $db->sql_query($sql);
2601 }
2602 }
2603
2604 return;
2605 }
2606
2607 // update foes for everyone
2608 $perms = array();
2609 foreach ($auth->acl_get_list(false, array('a_', 'm_'), false) as $forum_id => $forum_ary)
2610 {
2611 foreach ($forum_ary as $auth_option => $user_ary)
2612 {
2613 $perms = array_merge($perms, $user_ary);
2614 }
2615 }
2616
2617 if (sizeof($perms))
2618 {
2619 $sql = 'DELETE FROM ' . ZEBRA_TABLE . '
2620 WHERE ' . $db->sql_in_set('zebra_id', array_unique($perms)) . '
2621 AND foe = 1';
2622 $db->sql_query($sql);
2623 }
2624 unset($perms);
2625 }
2626
2627 /**
2628 * Lists inactive users
2629 */
2630 function view_inactive_users(&$users, &$user_count, $limit = 0, $offset = 0, $limit_days = 0, $sort_by = 'user_inactive_time DESC')
2631 {
2632 global $db, $user;
2633
2634 $sql = 'SELECT COUNT(user_id) AS user_count
2635 FROM ' . USERS_TABLE . '
2636 WHERE user_type = ' . phpbb::USER_INACTIVE .
2637 (($limit_days) ? " AND user_inactive_time >= $limit_days" : '');
2638 $result = $db->sql_query($sql);
2639 $user_count = (int) $db->sql_fetchfield('user_count');
2640 $db->sql_freeresult($result);
2641
2642 if ($offset >= $user_count)
2643 {
2644 $offset = ($offset - $limit < 0) ? 0 : $offset - $limit;
2645 }
2646
2647 $sql = 'SELECT user_id, username, user_regdate, user_lastvisit, user_inactive_time, user_inactive_reason
2648 FROM ' . USERS_TABLE . '
2649 WHERE user_type = ' . phpbb::USER_INACTIVE .
2650 (($limit_days) ? " AND user_inactive_time >= $limit_days" : '') . "
2651 ORDER BY $sort_by";
2652 $result = $db->sql_query_limit($sql, $limit, $offset);
2653
2654 while ($row = $db->sql_fetchrow($result))
2655 {
2656 $row['inactive_reason'] = $user->lang['INACTIVE_REASON_UNKNOWN'];
2657 switch ($row['user_inactive_reason'])
2658 {
2659 case INACTIVE_REGISTER:
2660 $row['inactive_reason'] = $user->lang['INACTIVE_REASON_REGISTER'];
2661 break;
2662
2663 case INACTIVE_PROFILE:
2664 $row['inactive_reason'] = $user->lang['INACTIVE_REASON_PROFILE'];
2665 break;
2666
2667 case INACTIVE_MANUAL:
2668 $row['inactive_reason'] = $user->lang['INACTIVE_REASON_MANUAL'];
2669 break;
2670
2671 case INACTIVE_REMIND:
2672 $row['inactive_reason'] = $user->lang['INACTIVE_REASON_REMIND'];
2673 break;
2674 }
2675
2676 $users[] = $row;
2677 }
2678
2679 return $offset;
2680 }
2681
2682 /**
2683 * Lists warned users
2684 */
2685 function view_warned_users(&$users, &$user_count, $limit = 0, $offset = 0, $limit_days = 0, $sort_by = 'user_warnings DESC')
2686 {
2687 global $db;
2688
2689 $sql = 'SELECT user_id, username, user_colour, user_warnings, user_last_warning
2690 FROM ' . USERS_TABLE . '
2691 WHERE user_warnings > 0
2692 ' . (($limit_days) ? "AND user_last_warning >= $limit_days" : '') . "
2693 ORDER BY $sort_by";
2694 $result = $db->sql_query_limit($sql, $limit, $offset);
2695 $users = $db->sql_fetchrowset($result);
2696 $db->sql_freeresult($result);
2697
2698 $sql = 'SELECT count(user_id) AS user_count
2699 FROM ' . USERS_TABLE . '
2700 WHERE user_warnings > 0
2701 ' . (($limit_days) ? "AND user_last_warning >= $limit_days" : '');
2702 $result = $db->sql_query($sql);
2703 $user_count = (int) $db->sql_fetchfield('user_count');
2704 $db->sql_freeresult($result);
2705
2706 return;
2707 }
2708
2709 /**
2710 * Get database size
2711 */
2712 function get_database_size()
2713 {
2714 global $db, $user, $table_prefix;
2715
2716 $database_size = false;
2717
2718 // This code is heavily influenced by a similar routine in phpMyAdmin 2.2.0
2719 switch ($db->dbms_type)
2720 {
2721 case 'mysql':
2722 $sql = 'SELECT VERSION() AS mysql_version';
2723 $result = $db->sql_query($sql);
2724 $row = $db->sql_fetchrow($result);
2725 $db->sql_freeresult($result);
2726
2727 if ($row)
2728 {
2729 $version = $row['mysql_version'];
2730
2731 if (preg_match('#(3\.23|[45]\.)#', $version))
2732 {
2733 $db_name = (preg_match('#^(?:3\.23\.(?:[6-9]|[1-9]{2}))|[45]\.#', $version)) ? "`{$db->dbname}`" : $db->dbname;
2734
2735 $sql = 'SHOW TABLE STATUS
2736 FROM ' . $db_name;
2737 $result = $db->sql_query($sql, 7200);
2738
2739 $database_size = 0;
2740 while ($row = $db->sql_fetchrow($result))
2741 {
2742 if ((isset($row['Type']) && $row['Type'] != 'MRG_MyISAM') || (isset($row['Engine']) && ($row['Engine'] == 'MyISAM' || $row['Engine'] == 'InnoDB')))
2743 {
2744 if ($table_prefix != '')
2745 {
2746 if (strpos($row['Name'], $table_prefix) !== false)
2747 {
2748 $database_size += $row['Data_length'] + $row['Index_length'];
2749 }
2750 }
2751 else
2752 {
2753 $database_size += $row['Data_length'] + $row['Index_length'];
2754 }
2755 }
2756 }
2757 $db->sql_freeresult($result);
2758 }
2759 }
2760 break;
2761
2762 case 'firebird':
2763 global $dbname;
2764
2765 // if it on the local machine, we can get lucky
2766 if (file_exists($dbname))
2767 {
2768 $database_size = filesize($dbname);
2769 }
2770
2771 break;
2772
2773 case 'sqlite':
2774 global $dbhost;
2775
2776 if (file_exists($dbhost))
2777 {
2778 $database_size = filesize($dbhost);
2779 }
2780
2781 break;
2782
2783 case 'mssql':
2784 $sql = 'SELECT ((SUM(size) * 8.0) * 1024.0) as dbsize
2785 FROM sysfiles';
2786 $result = $db->sql_query($sql, 7200);
2787 $database_size = ($row = $db->sql_fetchrow($result)) ? $row['dbsize'] : false;
2788 $db->sql_freeresult($result);
2789 break;
2790
2791 case 'postgres':
2792 $sql = "SELECT proname
2793 FROM pg_proc
2794 WHERE proname = 'pg_database_size'";
2795 $result = $db->sql_query($sql);
2796 $row = $db->sql_fetchrow($result);
2797 $db->sql_freeresult($result);
2798
2799 if ($row['proname'] == 'pg_database_size')
2800 {
2801 $database = $db->dbname;
2802 if (strpos($database, '.') !== false)
2803 {
2804 list($database, ) = explode('.', $database);
2805 }
2806
2807 $sql = "SELECT oid
2808 FROM pg_database
2809 WHERE datname = '$database'";
2810 $result = $db->sql_query($sql);
2811 $row = $db->sql_fetchrow($result);
2812 $db->sql_freeresult($result);
2813
2814 $oid = $row['oid'];
2815
2816 $sql = 'SELECT pg_database_size(' . $oid . ') as size';
2817 $result = $db->sql_query($sql);
2818 $row = $db->sql_fetchrow($result);
2819 $db->sql_freeresult($result);
2820
2821 $database_size = $row['size'];
2822 }
2823 break;
2824
2825 case 'oracle':
2826 $sql = 'SELECT SUM(bytes) as dbsize
2827 FROM user_segments';
2828 $result = $db->sql_query($sql, 7200);
2829 $database_size = ($row = $db->sql_fetchrow($result)) ? $row['dbsize'] : false;
2830 $db->sql_freeresult($result);
2831 break;
2832 }
2833
2834 $database_size = ($database_size !== false) ? get_formatted_filesize($database_size) : $user->lang['NOT_AVAILABLE'];
2835
2836 return $database_size;
2837 }
2838
2839 /**
2840 * Retrieve contents from remotely stored file
2841 */
2842 function get_remote_file($host, $directory, $filename, &$errstr, &$errno, $port = 80, $timeout = 10)
2843 {
2844 global $user;
2845
2846 if ($fsock = @fsockopen($host, $port, $errno, $errstr, $timeout))
2847 {
2848 @fputs($fsock, "GET $directory/$filename HTTP/1.1\r\n");
2849 @fputs($fsock, "HOST: $host\r\n");
2850 @fputs($fsock, "Connection: close\r\n\r\n");
2851
2852 $file_info = '';
2853 $get_info = false;
2854
2855 while (!@feof($fsock))
2856 {
2857 if ($get_info)
2858 {
2859 $file_info .= @fread($fsock, 1024);
2860 }
2861 else
2862 {
2863 $line = @fgets($fsock, 1024);
2864 if ($line == "\r\n")
2865 {
2866 $get_info = true;
2867 }
2868 else if (stripos($line, '404 not found') !== false)
2869 {
2870 $errstr = $user->lang['FILE_NOT_FOUND'] . ': ' . $filename;
2871 return false;
2872 }
2873 }
2874 }
2875 @fclose($fsock);
2876 }
2877 else
2878 {
2879 if ($errstr)
2880 {
2881 $errstr = utf8_convert_message($errstr);
2882 return false;
2883 }
2884 else
2885 {
2886 $errstr = $user->lang['FSOCK_DISABLED'];
2887 return false;
2888 }
2889 }
2890
2891 return $file_info;
2892 }
2893
2894 /**
2895 * Tidy Warnings
2896 * Remove all warnings which have now expired from the database
2897 * The duration of a warning can be defined by the administrator
2898 * This only removes the warning and reduces the associated count,
2899 * it does not remove the user note recording the contents of the warning
2900 */
2901 function tidy_warnings()
2902 {
2903 global $db, $config;
2904
2905 $expire_date = time() - ($config['warnings_expire_days'] * 86400);
2906 $warning_list = $user_list = array();
2907
2908 $sql = 'SELECT * FROM ' . WARNINGS_TABLE . "
2909 WHERE warning_time < $expire_date";
2910 $result = $db->sql_query($sql);
2911
2912 while ($row = $db->sql_fetchrow($result))
2913 {
2914 $warning_list[] = $row['warning_id'];
2915 $user_list[$row['user_id']] = isset($user_list[$row['user_id']]) ? ++$user_list[$row['user_id']] : 1;
2916 }
2917 $db->sql_freeresult($result);
2918
2919 if (sizeof($warning_list))
2920 {
2921 $db->sql_transaction('begin');
2922
2923 $sql = 'DELETE FROM ' . WARNINGS_TABLE . '
2924 WHERE ' . $db->sql_in_set('warning_id', $warning_list);
2925 $db->sql_query($sql);
2926
2927 foreach ($user_list as $user_id => $value)
2928 {
2929 $sql = 'UPDATE ' . USERS_TABLE . " SET user_warnings = user_warnings - $value
2930 WHERE user_id = $user_id";
2931 $db->sql_query($sql);
2932 }
2933
2934 $db->sql_transaction('commit');
2935 }
2936
2937 set_config('warnings_last_gc', time(), true);
2938 }
2939
2940 /**
2941 * Tidy database, doing some maintanance tasks
2942 */
2943 function tidy_database()
2944 {
2945 global $db;
2946
2947 // Here we check permission consistency
2948
2949 // Sometimes, it can happen permission tables having forums listed which do not exist
2950 $sql = 'SELECT forum_id
2951 FROM ' . FORUMS_TABLE;
2952 $result = $db->sql_query($sql);
2953
2954 $forum_ids = array(0);
2955 while ($row = $db->sql_fetchrow($result))
2956 {
2957 $forum_ids[] = $row['forum_id'];
2958 }
2959 $db->sql_freeresult($result);
2960
2961 // Delete those rows from the acl tables not having listed the forums above
2962 $sql = 'DELETE FROM ' . ACL_GROUPS_TABLE . '
2963 WHERE ' . $db->sql_in_set('forum_id', $forum_ids, true);
2964 $db->sql_query($sql);
2965
2966 $sql = 'DELETE FROM ' . ACL_USERS_TABLE . '
2967 WHERE ' . $db->sql_in_set('forum_id', $forum_ids, true);
2968 $db->sql_query($sql);
2969
2970 set_config('database_last_gc', time(), true);
2971 }
2972
2973 /**
2974 * Add permission language - this will make sure custom files will be included
2975 */
2976 function add_permission_language()
2977 {
2978 global $user;
2979
2980 // First of all, our own file. We need to include it as the first file because it presets all relevant variables.
2981 $user->add_lang('acp/permissions_phpbb');
2982
2983 $files_to_add = array();
2984
2985 // Now search in acp and mods folder for permissions_ files.
2986 foreach (array('acp/', 'mods/') as $path)
2987 {
2988 $dh = @opendir($user->lang_path . $user->lang_name . '/' . $path);
2989
2990 if ($dh)
2991 {
2992 while (($file = readdir($dh)) !== false)
2993 {
2994 if ($file !== 'permissions_phpbb.' . PHP_EXT && strpos($file, 'permissions_') === 0 && substr($file, -(strlen(PHP_EXT) + 1)) === '.' . PHP_EXT)
2995 {
2996 $files_to_add[] = $path . substr($file, 0, -(strlen(PHP_EXT) + 1));
2997 }
2998 }
2999 closedir($dh);
3000 }
3001 }
3002
3003 if (!sizeof($files_to_add))
3004 {
3005 return false;
3006 }
3007
3008 $user->add_lang($files_to_add);
3009 return true;
3010 }
3011
3012 ?>
phpbb is a php-based BBS (buletin board system)