WordPress.org

Make WordPress Core

Changeset 3851


Ignore:
Timestamp:
06/07/2006 11:17:59 PM (12 years ago)
Author:
ryan
Message:

Reworg post/page/attachment functions. #2525

Location:
trunk
Files:
6 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/comment.php

    r3740 r3851  
    196196}
    197197
     198function wp_blacklist_check($author, $email, $url, $comment, $user_ip, $user_agent) {
     199    global $wpdb;
     200
     201    do_action('wp_blacklist_check', $author, $email, $url, $comment, $user_ip, $user_agent);
     202
     203    if ( preg_match_all('/&#(\d+);/', $comment . $author . $url, $chars) ) {
     204        foreach ($chars[1] as $char) {
     205            // If it's an encoded char in the normal ASCII set, reject
     206            if ( 38 == $char )
     207                continue; // Unless it's &
     208            if ($char < 128)
     209                return true;
     210        }
     211    }
     212
     213    $mod_keys = trim( get_settings('blacklist_keys') );
     214    if ('' == $mod_keys )
     215        return false; // If moderation keys are empty
     216    $words = explode("\n", $mod_keys );
     217
     218    foreach ($words as $word) {
     219        $word = trim($word);
     220
     221        // Skip empty lines
     222        if ( empty($word) ) { continue; }
     223
     224        // Do some escaping magic so that '#' chars in the
     225        // spam words don't break things:
     226        $word = preg_quote($word, '#');
     227
     228        $pattern = "#$word#i";
     229        if ( preg_match($pattern, $author    ) ) return true;
     230        if ( preg_match($pattern, $email     ) ) return true;
     231        if ( preg_match($pattern, $url       ) ) return true;
     232        if ( preg_match($pattern, $comment   ) ) return true;
     233        if ( preg_match($pattern, $user_ip   ) ) return true;
     234        if ( preg_match($pattern, $user_agent) ) return true;
     235    }
     236
     237    if ( isset($_SERVER['REMOTE_ADDR']) ) {
     238        if ( wp_proxy_check($_SERVER['REMOTE_ADDR']) ) return true;
     239    }
     240
     241    return false;
     242}
     243
    198244function wp_delete_comment($comment_id) {
    199245    global $wpdb;
  • trunk/wp-includes/functions.php

    r3843 r3851  
    339339    wp_cache_delete($name, 'options');
    340340    return true;
    341 }
    342 
    343 function add_post_meta($post_id, $key, $value, $unique = false) {
    344     global $wpdb, $post_meta_cache;
    345 
    346     if ( $unique ) {
    347         if ( $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
    348 = '$key' AND post_id = '$post_id'") ) {
    349             return false;
    350         }
    351     }
    352 
    353     $original = $value;
    354     if ( is_array($value) || is_object($value) )
    355         $value = $wpdb->escape(serialize($value));
    356 
    357     $wpdb->query("INSERT INTO $wpdb->postmeta (post_id,meta_key,meta_value) VALUES ('$post_id','$key','$value')");
    358 
    359     $post_meta_cache['$post_id'][$key][] = $original;
    360 
    361     return true;
    362 }
    363 
    364 function delete_post_meta($post_id, $key, $value = '') {
    365     global $wpdb, $post_meta_cache;
    366 
    367     if ( empty($value) ) {
    368         $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
    369 post_id = '$post_id' AND meta_key = '$key'");
    370     } else {
    371         $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
    372 post_id = '$post_id' AND meta_key = '$key' AND meta_value = '$value'");
    373     }
    374 
    375     if ( !$meta_id )
    376         return false;
    377 
    378     if ( empty($value) ) {
    379         $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
    380 AND meta_key = '$key'");
    381         unset($post_meta_cache['$post_id'][$key]);
    382     } else {
    383         $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
    384 AND meta_key = '$key' AND meta_value = '$value'");
    385         $cache_key = $post_meta_cache['$post_id'][$key];
    386         if ($cache_key) foreach ( $cache_key as $index => $data )
    387             if ( $data == $value )
    388                 unset($post_meta_cache['$post_id'][$key][$index]);
    389     }
    390 
    391     unset($post_meta_cache['$post_id'][$key]);
    392 
    393     return true;
    394 }
    395 
    396 function get_post_meta($post_id, $key, $single = false) {
    397     global $wpdb, $post_meta_cache;
    398 
    399     if ( isset($post_meta_cache[$post_id][$key]) ) {
    400         if ( $single ) {
    401             return maybe_unserialize( $post_meta_cache[$post_id][$key][0] );
    402         } else {
    403             return maybe_unserialize( $post_meta_cache[$post_id][$key] );
    404         }
    405     }
    406 
    407     $metalist = $wpdb->get_results("SELECT meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' AND meta_key = '$key'", ARRAY_N);
    408 
    409     $values = array();
    410     if ( $metalist ) {
    411         foreach ($metalist as $metarow) {
    412             $values[] = $metarow[0];
    413         }
    414     }
    415 
    416     if ( $single ) {
    417         if ( count($values) ) {
    418             $return = maybe_unserialize( $values[0] );
    419         } else {
    420             return '';
    421         }
    422     } else {
    423         $return = $values;
    424     }
    425 
    426     return maybe_unserialize($return);
    427 }
    428 
    429 function update_post_meta($post_id, $key, $value, $prev_value = '') {
    430     global $wpdb, $post_meta_cache;
    431 
    432     $original_value = $value;
    433     if ( is_array($value) || is_object($value) )
    434         $value = $wpdb->escape(serialize($value));
    435 
    436     $original_prev = $prev_value;
    437     if ( is_array($prev_value) || is_object($prev_value) )
    438         $prev_value = $wpdb->escape(serialize($prev_value));
    439 
    440     if (! $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
    441 = '$key' AND post_id = '$post_id'") ) {
    442         return false;
    443     }
    444 
    445     if ( empty($prev_value) ) {
    446         $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
    447 meta_key = '$key' AND post_id = '$post_id'");
    448         $cache_key = $post_meta_cache['$post_id'][$key];
    449         if ( !empty($cache_key) )
    450             foreach ($cache_key as $index => $data)
    451                 $post_meta_cache['$post_id'][$key][$index] = $original_value;
    452     } else {
    453         $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
    454 meta_key = '$key' AND post_id = '$post_id' AND meta_value = '$prev_value'");
    455         $cache_key = $post_meta_cache['$post_id'][$key];
    456         if ( !empty($cache_key) )
    457             foreach ($cache_key as $index => $data)
    458                 if ( $data == $original_prev )
    459                     $post_meta_cache['$post_id'][$key][$index] = $original_value;
    460     }
    461 
    462     return true;
    463 }
    464 
    465 // Retrieves post data given a post ID or post object.
    466 // Handles post caching.
    467 function &get_post(&$post, $output = OBJECT) {
    468     global $post_cache, $wpdb;
    469 
    470     if ( empty($post) ) {
    471         if ( isset($GLOBALS['post']) )
    472             $_post = & $GLOBALS['post'];
    473         else
    474             $_post = null;
    475     } elseif ( is_object($post) ) {
    476         if ( 'page' == $post->post_type )
    477             return get_page($post, $output);
    478         if ( !isset($post_cache[$post->ID]) )
    479             $post_cache[$post->ID] = &$post;
    480         $_post = & $post_cache[$post->ID];
    481     } else {
    482         if ( $_post = wp_cache_get($post, 'pages') )
    483             return get_page($_post, $output);
    484         elseif ( isset($post_cache[$post]) )
    485             $_post = & $post_cache[$post];
    486         else {
    487             $query = "SELECT * FROM $wpdb->posts WHERE ID = '$post' LIMIT 1";
    488             $_post = & $wpdb->get_row($query);
    489             if ( 'page' == $_post->post_type )
    490                 return get_page($_post, $output);
    491             $post_cache[$post] = & $_post;
    492         }
    493     }
    494 
    495     if ( defined(WP_IMPORTING) )
    496         unset($post_cache);
    497 
    498     if ( $output == OBJECT ) {
    499         return $_post;
    500     } elseif ( $output == ARRAY_A ) {
    501         return get_object_vars($_post);
    502     } elseif ( $output == ARRAY_N ) {
    503         return array_values(get_object_vars($_post));
    504     } else {
    505         return $_post;
    506     }
    507 }
    508 
    509 function &get_children($post = 0, $output = OBJECT) {
    510     global $post_cache, $wpdb;
    511 
    512     if ( empty($post) ) {
    513         if ( isset($GLOBALS['post']) )
    514             $post_parent = & $GLOBALS['post']->post_parent;
    515         else
    516             return false;
    517     } elseif ( is_object($post) ) {
    518         $post_parent = $post->post_parent;
    519     } else {
    520         $post_parent = $post;
    521     }
    522 
    523     $post_parent = (int) $post_parent;
    524 
    525     $query = "SELECT * FROM $wpdb->posts WHERE post_parent = $post_parent";
    526 
    527     $children = $wpdb->get_results($query);
    528 
    529     if ( $children ) {
    530         foreach ( $children as $key => $child ) {
    531             $post_cache[$child->ID] =& $children[$key];
    532             $kids[$child->ID] =& $children[$key];
    533         }
    534     } else {
    535         return false;
    536     }
    537 
    538     if ( $output == OBJECT ) {
    539         return $kids;
    540     } elseif ( $output == ARRAY_A ) {
    541         foreach ( $kids as $kid )
    542             $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
    543         return $weeuns;
    544     } elseif ( $output == ARRAY_N ) {
    545         foreach ( $kids as $kid )
    546             $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
    547         return $babes;
    548     } else {
    549         return $kids;
    550     }
    551 }
    552 
    553 function get_page_by_path($page_path, $output = OBJECT) {
    554     global $wpdb;
    555     $page_path = rawurlencode(urldecode($page_path));
    556     $page_path = str_replace('%2F', '/', $page_path);
    557     $page_path = str_replace('%20', ' ', $page_path);
    558     $page_paths = '/' . trim($page_path, '/');
    559     $leaf_path  = sanitize_title(basename($page_paths));
    560     $page_paths = explode('/', $page_paths);
    561     foreach($page_paths as $pathdir)
    562         $full_path .= ($pathdir!=''?'/':'') . sanitize_title($pathdir);
    563 
    564     $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = '$leaf_path' AND post_type='page'");
    565 
    566     if ( empty($pages) )
    567         return NULL;
    568 
    569     foreach ($pages as $page) {
    570         $path = '/' . $leaf_path;
    571         $curpage = $page;
    572         while ($curpage->post_parent != 0) {
    573             $curpage = $wpdb->get_row("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE ID = '$curpage->post_parent' and post_type='page'");
    574             $path = '/' . $curpage->post_name . $path;
    575         }
    576 
    577         if ( $path == $full_path )
    578             return get_page($page->ID, $output);
    579     }
    580 
    581     return NULL;
    582 }
    583 
    584 // Retrieves page data given a page ID or page object.
    585 // Handles page caching.
    586 function &get_page(&$page, $output = OBJECT) {
    587     global $wpdb;
    588 
    589     if ( empty($page) ) {
    590         if ( isset($GLOBALS['page']) ) {
    591             $_page = & $GLOBALS['page'];
    592             wp_cache_add($_page->ID, $_page, 'pages');
    593         } else {
    594             $_page = null;
    595         }
    596     } elseif ( is_object($page) ) {
    597         if ( 'post' == $page->post_type )
    598             return get_post($page, $output);
    599         wp_cache_add($page->ID, $page, 'pages');
    600         $_page = $page;
    601     } else {
    602         if ( isset($GLOBALS['page']) && ($page == $GLOBALS['page']->ID) ) {
    603             $_page = & $GLOBALS['page'];
    604             wp_cache_add($_page->ID, $_page, 'pages');
    605         } elseif ( $_page = $GLOBALS['post_cache'][$page] ) {
    606             return get_post($page, $output);
    607         } elseif ( $_page = wp_cache_get($page, 'pages') ) {
    608             // Got it.
    609         } else {
    610             $query = "SELECT * FROM $wpdb->posts WHERE ID= '$page' LIMIT 1";
    611             $_page = & $wpdb->get_row($query);
    612             if ( 'post' == $_page->post_type )
    613                 return get_post($_page, $output);
    614             wp_cache_add($_page->ID, $_page, 'pages');
    615         }
    616     }
    617 
    618     if ( $output == OBJECT ) {
    619         return $_page;
    620     } elseif ( $output == ARRAY_A ) {
    621         return get_object_vars($_page);
    622     } elseif ( $output == ARRAY_N ) {
    623         return array_values(get_object_vars($_page));
    624     } else {
    625         return $_page;
    626     }
    627 }
    628 
    629 function get_all_page_ids() {
    630     global $wpdb;
    631 
    632     if ( ! $page_ids = wp_cache_get('all_page_ids', 'pages') ) {
    633         $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
    634         wp_cache_add('all_page_ids', $page_ids, 'pages');
    635     }
    636 
    637     return $page_ids;
    638341}
    639342
     
    1275978}
    1276979
    1277 function wp_head() {
    1278     do_action('wp_head');
    1279 }
    1280 
    1281 function wp_footer() {
    1282     do_action('wp_footer');
    1283 }
    1284 
    1285980/*
    1286981add_query_arg: Returns a modified querystring by adding
     
    16011296}
    16021297
     1298function wp_mkdir_p($target) {
     1299    // from php.net/mkdir user contributed notes
     1300    if (file_exists($target)) {
     1301        if (! @ is_dir($target))
     1302            return false;
     1303        else
     1304            return true;
     1305    }
     1306
     1307    // Attempting to create the directory may clutter up our display.
     1308    if (@ mkdir($target)) {
     1309        $stat = @ stat(dirname($target));
     1310        $dir_perms = $stat['mode'] & 0007777;  // Get the permission bits.
     1311        @ chmod($target, $dir_perms);
     1312        return true;
     1313    } else {
     1314        if ( is_dir(dirname($target)) )
     1315            return false;
     1316    }
     1317
     1318    // If the above failed, attempt to create the parent node, then try again.
     1319    if (wp_mkdir_p(dirname($target)))
     1320        return wp_mkdir_p($target);
     1321
     1322    return false;
     1323}
     1324
     1325// Returns an array containing the current upload directory's path and url, or an error message.
     1326function wp_upload_dir() {
     1327    $siteurl = get_settings('siteurl');
     1328    //prepend ABSPATH to $dir and $siteurl to $url if they're not already there
     1329    $path = str_replace(ABSPATH, '', trim(get_settings('upload_path')));
     1330    $dir = ABSPATH . $path;
     1331    $url = trailingslashit($siteurl) . $path;
     1332
     1333    if ( $dir == ABSPATH ) { //the option was empty
     1334        $dir = ABSPATH . 'wp-content/uploads';
     1335    }
     1336
     1337    if ( defined('UPLOADS') ) {
     1338        $dir = ABSPATH . UPLOADS;
     1339        $url = trailingslashit($siteurl) . UPLOADS;
     1340    }
     1341
     1342    if ( get_settings('uploads_use_yearmonth_folders')) {
     1343        // Generate the yearly and monthly dirs
     1344        $time = current_time( 'mysql' );
     1345        $y = substr( $time, 0, 4 );
     1346        $m = substr( $time, 5, 2 );
     1347        $dir = $dir . "/$y/$m";
     1348        $url = $url . "/$y/$m";
     1349    }
     1350
     1351    // Make sure we have an uploads dir
     1352    if ( ! wp_mkdir_p( $dir ) ) {
     1353        $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), $dir);
     1354        return array('error' => $message);
     1355    }
     1356
     1357    $uploads = array('path' => $dir, 'url' => $url, 'error' => false);
     1358    return apply_filters('upload_dir', $uploads);
     1359}
     1360
     1361function wp_upload_bits($name, $type, $bits) {
     1362    if ( empty($name) )
     1363        return array('error' => "Empty filename");
     1364
     1365    $upload = wp_upload_dir();
     1366
     1367    if ( $upload['error'] !== false )
     1368        return $upload;
     1369
     1370    $number = '';
     1371    $filename = $name;
     1372    $path_parts = pathinfo($filename);
     1373    $ext = $path_parts['extension'];
     1374    if ( empty($ext) )
     1375        $ext = '';
     1376    else
     1377        $ext = ".$ext";
     1378    while ( file_exists($upload['path'] . "/$filename") ) {
     1379        if ( '' == "$number$ext" )
     1380            $filename = $filename . ++$number . $ext;
     1381        else
     1382            $filename = str_replace("$number$ext", ++$number . $ext, $filename);
     1383    }
     1384
     1385    $new_file = $upload['path'] . "/$filename";
     1386    if ( ! wp_mkdir_p( dirname($new_file) ) ) {
     1387        $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), dirname($new_file));
     1388        return array('error' => $message);
     1389    }
     1390
     1391    $ifp = @ fopen($new_file, 'wb');
     1392    if ( ! $ifp )
     1393        return array('error' => "Could not write file $new_file.");
     1394
     1395    $success = @ fwrite($ifp, $bits);
     1396    fclose($ifp);
     1397    // Set correct file permissions
     1398    $stat = @ stat(dirname($new_file));
     1399    $perms = $stat['mode'] & 0007777;
     1400    $perms = $perms & 0000666;
     1401    @ chmod($new_file, $perms);
     1402
     1403    // Compute the URL
     1404    $url = $upload['url'] . "/$filename";
     1405
     1406    return array('file' => $new_file, 'url' => $url, 'error' => false);
     1407}
     1408
     1409function do_trackbacks($post_id) {
     1410    global $wpdb;
     1411
     1412    $post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $post_id");
     1413    $to_ping = get_to_ping($post_id);
     1414    $pinged  = get_pung($post_id);
     1415    if ( empty($to_ping) ) {
     1416        $wpdb->query("UPDATE $wpdb->posts SET to_ping = '' WHERE ID = '$post_id'");
     1417        return;
     1418    }
     1419
     1420    if (empty($post->post_excerpt))
     1421        $excerpt = apply_filters('the_content', $post->post_content);
     1422    else
     1423        $excerpt = apply_filters('the_excerpt', $post->post_excerpt);
     1424    $excerpt = str_replace(']]>', ']]&gt;', $excerpt);
     1425    $excerpt = strip_tags($excerpt);
     1426    if ( function_exists('mb_strcut') ) // For international trackbacks
     1427        $excerpt = mb_strcut($excerpt, 0, 252, get_settings('blog_charset')) . '...';
     1428    else
     1429        $excerpt = substr($excerpt, 0, 252) . '...';
     1430
     1431    $post_title = apply_filters('the_title', $post->post_title);
     1432    $post_title = strip_tags($post_title);
     1433
     1434    if ($to_ping) : foreach ($to_ping as $tb_ping) :
     1435        $tb_ping = trim($tb_ping);
     1436        if ( !in_array($tb_ping, $pinged) ) {
     1437            trackback($tb_ping, $post_title, $excerpt, $post_id);
     1438            $pinged[] = $tb_ping;
     1439        } else {
     1440            $wpdb->query("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, '$tb_ping', '')) WHERE ID = '$post_id'");
     1441        }
     1442    endforeach; endif;
     1443}
     1444
     1445function do_all_pings() {
     1446    global $wpdb;
     1447
     1448    // Do pingbacks
     1449    while ($ping = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_pingme' LIMIT 1")) {
     1450        $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$ping->ID} AND meta_key = '_pingme';");
     1451        pingback($ping->post_content, $ping->ID);
     1452    }
     1453   
     1454    // Do Enclosures
     1455    while ($enclosure = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_encloseme' LIMIT 1")) {
     1456        $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$enclosure->ID} AND meta_key = '_encloseme';");
     1457        do_enclose($enclosure->post_content, $enclosure->ID);
     1458    }
     1459
     1460    // Do Trackbacks
     1461    $trackbacks = $wpdb->get_results("SELECT ID FROM $wpdb->posts WHERE CHAR_LENGTH(TRIM(to_ping)) > 7 AND post_status = 'publish'");
     1462    if ( is_array($trackbacks) ) {
     1463        foreach ( $trackbacks as $trackback ) {
     1464            do_trackbacks($trackback->ID);
     1465        }
     1466    }
     1467
     1468    //Do Update Services/Generic Pings
     1469    generic_ping();
     1470}
     1471
     1472function wp_proxy_check($ipnum) {
     1473    if ( get_option('open_proxy_check') && isset($ipnum) ) {
     1474        $rev_ip = implode( '.', array_reverse( explode( '.', $ipnum ) ) );
     1475        $lookup = $rev_ip . '.opm.blitzed.org.';
     1476        if ( $lookup != gethostbyname( $lookup ) )
     1477            return true;
     1478    }
     1479
     1480    return false;
     1481}
     1482
    16031483?>
  • trunk/wp-includes/post-template.php

    r3845 r3851  
    11<?php
    22
    3 function get_the_password_form() {
    4     $output = '<form action="' . get_settings('siteurl') . '/wp-pass.php" method="post">
    5     <p>' . __("This post is password protected. To view it please enter your password below:") . '</p>
    6     <p><label>' . __("Password:") . ' <input name="post_password" type="password" size="20" /></label> <input type="submit" name="Submit" value="' . __("Submit") . '" /></p>
    7     </form>
    8     ';
    9     return $output;
    10 }
    11 
     3//
     4// "The Loop" post functions
     5//
    126
    137function the_ID() {
     
    1610}
    1711
     12
    1813function get_the_ID() {
    1914    global $id;
    2015    return $id;
    2116}
     17
    2218
    2319function the_title($before = '', $after = '', $echo = true) {
     
    4339}
    4440
     41function the_guid( $id = 0 ) {
     42    echo get_the_guid($id);
     43}
    4544
    4645function get_the_guid( $id = 0 ) {
     
    4948    return apply_filters('get_the_guid', $post->guid);
    5049}
    51 
    52 
    53 function the_guid( $id = 0 ) {
    54     echo get_the_guid($id);
    55 }
    56 
    5750
    5851function the_content($more_link_text = '(more...)', $stripteaser = 0, $more_file = '') {
     
    191184
    192185
    193 /*
    194 Post-meta: Custom per-post fields.
    195 */
    196 
    197 
    198 function get_post_custom( $post_id = 0 ) {
    199     global $id, $post_meta_cache, $wpdb;
    200 
    201     if ( ! $post_id )
    202         $post_id = $id;
    203 
    204     if ( isset($post_meta_cache[$post_id]) )
    205         return $post_meta_cache[$post_id];
    206 
    207     if ( $meta_list = $wpdb->get_results("SELECT post_id, meta_key, meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' ORDER BY post_id, meta_key", ARRAY_A) ) {
    208         // Change from flat structure to hierarchical:
    209         $post_meta_cache = array();
    210         foreach ( $meta_list as $metarow ) {
    211             $mpid = $metarow['post_id'];
    212             $mkey = $metarow['meta_key'];
    213             $mval = $metarow['meta_value'];
    214 
    215             // Force subkeys to be array type:
    216             if ( !isset($post_meta_cache[$mpid]) || !is_array($post_meta_cache[$mpid]) )
    217                 $post_meta_cache[$mpid] = array();
    218 
    219             if ( !isset($post_meta_cache[$mpid]["$mkey"]) || !is_array($post_meta_cache[$mpid]["$mkey"]) )
    220                 $post_meta_cache[$mpid]["$mkey"] = array();
    221 
    222             // Add a value to the current pid/key:
    223             $post_meta_cache[$mpid][$mkey][] = $mval;
    224         }
    225         return $post_meta_cache[$mpid];
    226     }
    227 }
    228 
    229 
    230 function get_post_custom_keys() {
    231     $custom = get_post_custom();
    232 
    233     if ( ! is_array($custom) )
    234         return;
    235 
    236     if ( $keys = array_keys($custom) )
    237         return $keys;
    238 }
    239 
    240 
    241 function get_post_custom_values( $key = '' ) {
    242     $custom = get_post_custom();
    243 
    244     return $custom[$key];
    245 }
     186//
     187// Post-meta: Custom per-post fields.
     188//
    246189
    247190
     
    275218
    276219
    277 /*
    278 Pages
    279 */
     220//
     221// Pages
     222//
     223
     224function wp_dropdown_pages($args = '') {
     225    if ( is_array($args) )
     226        $r = &$args;
     227    else
     228        parse_str($args, $r);
     229
     230    $defaults = array('depth' => 0, 'child_of' => 0, 'selected' => 0, 'echo' => 1,
     231        'name' => 'page_id');
     232    $r = array_merge($defaults, $r);
     233    extract($r);
     234
     235    $pages = get_pages($r);
     236    $output = '';
     237
     238    if ( ! empty($pages) ) {
     239        $output = "<select name='$name'>\n";
     240        $output .= walk_page_dropdown_tree($pages, $depth, $r);
     241        $output .= "</select>\n";
     242    }
     243
     244    $output = apply_filters('wp_dropdown_pages', $output);
     245
     246    if ( $echo )
     247        echo $output;
     248
     249    return $output;
     250}
     251
     252function wp_list_pages($args = '') {
     253    if ( is_array($args) )
     254        $r = &$args;
     255    else
     256        parse_str($args, $r);
     257
     258    $defaults = array('depth' => 0, 'show_date' => '', 'date_format' => get_settings('date_format'),
     259        'child_of' => 0, 'title_li' => __('Pages'), 'echo' => 1);
     260    $r = array_merge($defaults, $r);
     261
     262    $output = '';
     263
     264    // Query pages.
     265    $pages = get_pages($r);
     266
     267    if ( !empty($pages) ) {
     268        if ( $r['title_li'] )
     269            $output .= '<li class="pagenav">' . $r['title_li'] . '<ul>';
     270
     271        global $wp_query;
     272        $current_page = $wp_query->get_queried_object_id();
     273        $output .= walk_page_tree($pages, $r['depth'], $current_page, $r['show_date'], $r['date_format']);
     274
     275        if ( $r['title_li'] )
     276            $output .= '</ul></li>';
     277    }
     278
     279    $output = apply_filters('wp_list_pages', $output);
     280
     281    if ( $r['echo'] )
     282        echo $output;
     283    else
     284        return $output;
     285}
     286
     287//
     288// Page helpers
     289//
    280290
    281291function walk_page_tree() {
     
    291301}
    292302
    293 function &get_page_children($page_id, $pages) {
    294     global $page_cache;
    295 
    296     if ( empty($pages) )
    297         $pages = &$page_cache;
    298 
    299     $page_list = array();
    300     foreach ( $pages as $page ) {
    301         if ( $page->post_parent == $page_id ) {
    302             $page_list[] = $page;
    303             if ( $children = get_page_children($page->ID, $pages) )
    304                 $page_list = array_merge($page_list, $children);
    305         }
    306     }
    307     return $page_list;
    308 }
    309 
    310 
    311 function &get_pages($args = '') {
    312     global $wpdb;
    313 
    314     if ( is_array($args) )
    315         $r = &$args;
    316     else
    317         parse_str($args, $r);
    318 
    319     $defaults = array('child_of' => 0, 'sort_order' => 'ASC', 'sort_column' => 'post_title',
    320                 'hierarchical' => 1, 'exclude' => '', 'include' => '', 'meta_key' => '', 'meta_value' => '');
    321     $r = array_merge($defaults, $r);
    322     extract($r);
    323 
    324     $inclusions = '';
    325     if ( !empty($include) ) {
    326         $child_of = 0; //ignore child_of, exclude, meta_key, and meta_value params if using include
    327         $exclude = ''; 
    328         $meta_key = '';
    329         $meta_value = '';
    330         $incpages = preg_split('/[\s,]+/',$include);
    331         if ( count($incpages) ) {
    332             foreach ( $incpages as $incpage ) {
    333                 if (empty($inclusions))
    334                     $inclusions = ' AND ( ID = ' . intval($incpage) . ' ';
    335                 else
    336                     $inclusions .= ' OR ID = ' . intval($incpage) . ' ';
    337             }
    338         }
    339     }
    340     if (!empty($inclusions))
    341         $inclusions .= ')';
    342 
    343     $exclusions = '';
    344     if ( !empty($exclude) ) {
    345         $expages = preg_split('/[\s,]+/',$exclude);
    346         if ( count($expages) ) {
    347             foreach ( $expages as $expage ) {
    348                 if (empty($exclusions))
    349                     $exclusions = ' AND ( ID <> ' . intval($expage) . ' ';
    350                 else
    351                     $exclusions .= ' AND ID <> ' . intval($expage) . ' ';
    352             }
    353         }
    354     }
    355     if (!empty($exclusions))
    356         $exclusions .= ')';
    357 
    358     $query = "SELECT * FROM $wpdb->posts " ;
    359     $query .= ( empty( $meta_key ) ? "" : ", $wpdb->postmeta " ) ;
    360     $query .= " WHERE (post_type = 'page' AND post_status = 'publish') $exclusions $inclusions " ;
    361     $query .= ( empty( $meta_key ) | empty($meta_value)  ? "" : " AND ($wpdb->posts.ID = $wpdb->postmeta.post_id AND $wpdb->postmeta.meta_key = '$meta_key' AND $wpdb->postmeta.meta_value = '$meta_value' )" ) ;
    362     $query .= " ORDER BY " . $sort_column . " " . $sort_order ;
    363 
    364     $pages = $wpdb->get_results($query);
    365     $pages = apply_filters('get_pages', $pages, $r);
    366 
    367     if ( empty($pages) )
    368         return array();
    369 
    370     // Update cache.
    371     update_page_cache($pages);
    372 
    373     if ( $child_of || $hierarchical )
    374         $pages = & get_page_children($child_of, $pages);
    375 
    376     return $pages;
    377 }
    378 
    379 function wp_dropdown_pages($args = '') {
    380     if ( is_array($args) )
    381         $r = &$args;
    382     else
    383         parse_str($args, $r);
    384 
    385     $defaults = array('depth' => 0, 'child_of' => 0, 'selected' => 0, 'echo' => 1,
    386         'name' => 'page_id');
    387     $r = array_merge($defaults, $r);
    388     extract($r);
    389 
    390     $pages = get_pages($r);
    391     $output = '';
    392 
    393     if ( ! empty($pages) ) {
    394         $output = "<select name='$name'>\n";
    395         $output .= walk_page_dropdown_tree($pages, $depth, $r);
    396         $output .= "</select>\n";
    397     }
    398 
    399     $output = apply_filters('wp_dropdown_pages', $output);
    400 
    401     if ( $echo )
    402         echo $output;
    403 
    404     return $output;
    405 }
    406 
    407 function wp_list_pages($args = '') {
    408     if ( is_array($args) )
    409         $r = &$args;
    410     else
    411         parse_str($args, $r);
    412 
    413     $defaults = array('depth' => 0, 'show_date' => '', 'date_format' => get_settings('date_format'),
    414         'child_of' => 0, 'title_li' => __('Pages'), 'echo' => 1);
    415     $r = array_merge($defaults, $r);
    416 
    417     $output = '';
    418 
    419     // Query pages.
    420     $pages = get_pages($r);
    421 
    422     if ( !empty($pages) ) {
    423         if ( $r['title_li'] )
    424             $output .= '<li class="pagenav">' . $r['title_li'] . '<ul>';
    425 
    426         global $wp_query;
    427         $current_page = $wp_query->get_queried_object_id();
    428         $output .= walk_page_tree($pages, $r['depth'], $current_page, $r['show_date'], $r['date_format']);
    429 
    430         if ( $r['title_li'] )
    431             $output .= '</ul></li>';
    432     }
    433 
    434     $output = apply_filters('wp_list_pages', $output);
    435 
    436     if ( $r['echo'] )
    437         echo $output;
    438     else
    439         return $output;
    440 }
     303//
     304// Attachments
     305//
    441306
    442307function the_attachment_link($id = 0, $fullsize = false, $max_dims = false) {
     
    562427}
    563428
     429//
     430// Misc
     431//
     432
     433function get_the_password_form() {
     434    $output = '<form action="' . get_settings('siteurl') . '/wp-pass.php" method="post">
     435    <p>' . __("This post is password protected. To view it please enter your password below:") . '</p>
     436    <p><label>' . __("Password:") . ' <input name="post_password" type="password" size="20" /></label> <input type="submit" name="Submit" value="' . __("Submit") . '" /></p>
     437    </form>
     438    ';
     439    return $output;
     440}
     441
    564442?>
  • trunk/wp-includes/post.php

    r3849 r3851  
    11<?php
    22
    3 /**** DB Functions ****/
    4 
    5 /*
    6  * generic function for inserting data into the posts table.
    7  */
     3//
     4// Post functions
     5//
     6
     7function get_attached_file($attachment_id) {
     8    return get_post_meta($attachment_id, '_wp_attached_file', true);
     9}
     10
     11function &get_children($post = 0, $output = OBJECT) {
     12    global $post_cache, $wpdb;
     13
     14    if ( empty($post) ) {
     15        if ( isset($GLOBALS['post']) )
     16            $post_parent = & $GLOBALS['post']->post_parent;
     17        else
     18            return false;
     19    } elseif ( is_object($post) ) {
     20        $post_parent = $post->post_parent;
     21    } else {
     22        $post_parent = $post;
     23    }
     24
     25    $post_parent = (int) $post_parent;
     26
     27    $query = "SELECT * FROM $wpdb->posts WHERE post_parent = $post_parent";
     28
     29    $children = $wpdb->get_results($query);
     30
     31    if ( $children ) {
     32        foreach ( $children as $key => $child ) {
     33            $post_cache[$child->ID] =& $children[$key];
     34            $kids[$child->ID] =& $children[$key];
     35        }
     36    } else {
     37        return false;
     38    }
     39
     40    if ( $output == OBJECT ) {
     41        return $kids;
     42    } elseif ( $output == ARRAY_A ) {
     43        foreach ( $kids as $kid )
     44            $weeuns[$kid->ID] = get_object_vars($kids[$kid->ID]);
     45        return $weeuns;
     46    } elseif ( $output == ARRAY_N ) {
     47        foreach ( $kids as $kid )
     48            $babes[$kid->ID] = array_values(get_object_vars($kids[$kid->ID]));
     49        return $babes;
     50    } else {
     51        return $kids;
     52    }
     53}
     54
     55// get extended entry info (<!--more-->)
     56function get_extended($post) {
     57    list($main,$extended) = explode('<!--more-->', $post, 2);
     58
     59    // Strip leading and trailing whitespace
     60    $main = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$main);
     61    $extended = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$extended);
     62
     63    return array('main' => $main, 'extended' => $extended);
     64}
     65
     66// Retrieves post data given a post ID or post object.
     67// Handles post caching.
     68function &get_post(&$post, $output = OBJECT) {
     69    global $post_cache, $wpdb;
     70
     71    if ( empty($post) ) {
     72        if ( isset($GLOBALS['post']) )
     73            $_post = & $GLOBALS['post'];
     74        else
     75            $_post = null;
     76    } elseif ( is_object($post) ) {
     77        if ( 'page' == $post->post_type )
     78            return get_page($post, $output);
     79        if ( !isset($post_cache[$post->ID]) )
     80            $post_cache[$post->ID] = &$post;
     81        $_post = & $post_cache[$post->ID];
     82    } else {
     83        if ( $_post = wp_cache_get($post, 'pages') )
     84            return get_page($_post, $output);
     85        elseif ( isset($post_cache[$post]) )
     86            $_post = & $post_cache[$post];
     87        else {
     88            $query = "SELECT * FROM $wpdb->posts WHERE ID = '$post' LIMIT 1";
     89            $_post = & $wpdb->get_row($query);
     90            if ( 'page' == $_post->post_type )
     91                return get_page($_post, $output);
     92            $post_cache[$post] = & $_post;
     93        }
     94    }
     95
     96    if ( defined(WP_IMPORTING) )
     97        unset($post_cache);
     98
     99    if ( $output == OBJECT ) {
     100        return $_post;
     101    } elseif ( $output == ARRAY_A ) {
     102        return get_object_vars($_post);
     103    } elseif ( $output == ARRAY_N ) {
     104        return array_values(get_object_vars($_post));
     105    } else {
     106        return $_post;
     107    }
     108}
     109
     110// Takes a post ID, returns its mime type.
     111function get_post_mime_type($ID = '') {
     112    $post = & get_post($ID);
     113
     114    if ( is_object($post) )
     115        return $post->post_mime_type;
     116
     117    return false;
     118}
     119
     120function get_post_status($ID = '') {
     121    $post = get_post($ID);
     122
     123    if ( is_object($post) ) {
     124        if ( ('attachment' == $post->post_type) && $post->post_parent && ($post->ID != $post->post_parent) )
     125            return get_post_status($post->post_parent);
     126        else
     127            return $post->post_status;
     128    }
     129
     130    return false;
     131}
     132
     133function get_post_type($post = false) {
     134    global $wpdb, $posts;
     135
     136    if ( false === $post )
     137        $post = $posts[0];
     138    elseif ( (int) $post )
     139        $post = get_post($post, OBJECT);
     140
     141    if ( is_object($post) )
     142        return $post->post_type;
     143
     144    return false;
     145}
     146
     147
     148//
     149// Post meta functions
     150//
     151
     152function add_post_meta($post_id, $key, $value, $unique = false) {
     153    global $wpdb, $post_meta_cache;
     154
     155    if ( $unique ) {
     156        if ( $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
     157= '$key' AND post_id = '$post_id'") ) {
     158            return false;
     159        }
     160    }
     161
     162    $original = $value;
     163    if ( is_array($value) || is_object($value) )
     164        $value = $wpdb->escape(serialize($value));
     165
     166    $wpdb->query("INSERT INTO $wpdb->postmeta (post_id,meta_key,meta_value) VALUES ('$post_id','$key','$value')");
     167
     168    $post_meta_cache['$post_id'][$key][] = $original;
     169
     170    return true;
     171}
     172
     173function delete_post_meta($post_id, $key, $value = '') {
     174    global $wpdb, $post_meta_cache;
     175
     176    if ( empty($value) ) {
     177        $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
     178post_id = '$post_id' AND meta_key = '$key'");
     179    } else {
     180        $meta_id = $wpdb->get_var("SELECT meta_id FROM $wpdb->postmeta WHERE
     181post_id = '$post_id' AND meta_key = '$key' AND meta_value = '$value'");
     182    }
     183
     184    if ( !$meta_id )
     185        return false;
     186
     187    if ( empty($value) ) {
     188        $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
     189AND meta_key = '$key'");
     190        unset($post_meta_cache['$post_id'][$key]);
     191    } else {
     192        $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = '$post_id'
     193AND meta_key = '$key' AND meta_value = '$value'");
     194        $cache_key = $post_meta_cache['$post_id'][$key];
     195        if ($cache_key) foreach ( $cache_key as $index => $data )
     196            if ( $data == $value )
     197                unset($post_meta_cache['$post_id'][$key][$index]);
     198    }
     199
     200    unset($post_meta_cache['$post_id'][$key]);
     201
     202    return true;
     203}
     204
     205function get_post_meta($post_id, $key, $single = false) {
     206    global $wpdb, $post_meta_cache;
     207
     208    if ( isset($post_meta_cache[$post_id][$key]) ) {
     209        if ( $single ) {
     210            return maybe_unserialize( $post_meta_cache[$post_id][$key][0] );
     211        } else {
     212            return maybe_unserialize( $post_meta_cache[$post_id][$key] );
     213        }
     214    }
     215
     216    $metalist = $wpdb->get_results("SELECT meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' AND meta_key = '$key'", ARRAY_N);
     217
     218    $values = array();
     219    if ( $metalist ) {
     220        foreach ($metalist as $metarow) {
     221            $values[] = $metarow[0];
     222        }
     223    }
     224
     225    if ( $single ) {
     226        if ( count($values) ) {
     227            $return = maybe_unserialize( $values[0] );
     228        } else {
     229            return '';
     230        }
     231    } else {
     232        $return = $values;
     233    }
     234
     235    return maybe_unserialize($return);
     236}
     237
     238function update_post_meta($post_id, $key, $value, $prev_value = '') {
     239    global $wpdb, $post_meta_cache;
     240
     241    $original_value = $value;
     242    if ( is_array($value) || is_object($value) )
     243        $value = $wpdb->escape(serialize($value));
     244
     245    $original_prev = $prev_value;
     246    if ( is_array($prev_value) || is_object($prev_value) )
     247        $prev_value = $wpdb->escape(serialize($prev_value));
     248
     249    if (! $wpdb->get_var("SELECT meta_key FROM $wpdb->postmeta WHERE meta_key
     250= '$key' AND post_id = '$post_id'") ) {
     251        return false;
     252    }
     253
     254    if ( empty($prev_value) ) {
     255        $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
     256meta_key = '$key' AND post_id = '$post_id'");
     257        $cache_key = $post_meta_cache['$post_id'][$key];
     258        if ( !empty($cache_key) )
     259            foreach ($cache_key as $index => $data)
     260                $post_meta_cache['$post_id'][$key][$index] = $original_value;
     261    } else {
     262        $wpdb->query("UPDATE $wpdb->postmeta SET meta_value = '$value' WHERE
     263meta_key = '$key' AND post_id = '$post_id' AND meta_value = '$prev_value'");
     264        $cache_key = $post_meta_cache['$post_id'][$key];
     265        if ( !empty($cache_key) )
     266            foreach ($cache_key as $index => $data)
     267                if ( $data == $original_prev )
     268                    $post_meta_cache['$post_id'][$key][$index] = $original_value;
     269    }
     270
     271    return true;
     272}
     273
     274
     275function get_post_custom( $post_id = 0 ) {
     276    global $id, $post_meta_cache, $wpdb;
     277
     278    if ( ! $post_id )
     279        $post_id = $id;
     280
     281    if ( isset($post_meta_cache[$post_id]) )
     282        return $post_meta_cache[$post_id];
     283
     284    if ( $meta_list = $wpdb->get_results("SELECT post_id, meta_key, meta_value FROM $wpdb->postmeta WHERE post_id = '$post_id' ORDER BY post_id, meta_key", ARRAY_A) ) {
     285        // Change from flat structure to hierarchical:
     286        $post_meta_cache = array();
     287        foreach ( $meta_list as $metarow ) {
     288            $mpid = $metarow['post_id'];
     289            $mkey = $metarow['meta_key'];
     290            $mval = $metarow['meta_value'];
     291
     292            // Force subkeys to be array type:
     293            if ( !isset($post_meta_cache[$mpid]) || !is_array($post_meta_cache[$mpid]) )
     294                $post_meta_cache[$mpid] = array();
     295
     296            if ( !isset($post_meta_cache[$mpid]["$mkey"]) || !is_array($post_meta_cache[$mpid]["$mkey"]) )
     297                $post_meta_cache[$mpid]["$mkey"] = array();
     298
     299            // Add a value to the current pid/key:
     300            $post_meta_cache[$mpid][$mkey][] = $mval;
     301        }
     302        return $post_meta_cache[$mpid];
     303    }
     304}
     305
     306function get_post_custom_keys( $post_id = 0 ) {
     307    $custom = get_post_custom( $post_id );
     308
     309    if ( ! is_array($custom) )
     310        return;
     311
     312    if ( $keys = array_keys($custom) )
     313        return $keys;
     314}
     315
     316
     317function get_post_custom_values( $key = '', $post_id = 0 ) {
     318    $custom = get_post_custom($post_id);
     319
     320    return $custom[$key];
     321}
     322
     323function wp_delete_post($postid = 0) {
     324    global $wpdb, $wp_rewrite;
     325    $postid = (int) $postid;
     326
     327    if ( !$post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $postid") )
     328        return $post;
     329
     330    if ( 'attachment' == $post->post_type )
     331        return wp_delete_attachment($postid);
     332
     333    do_action('delete_post', $postid);
     334
     335    if ( 'publish' == $post->post_status && 'post' == $post->post_type ) {
     336        $categories = wp_get_post_categories($post->ID);
     337        if( is_array( $categories ) ) {
     338            foreach ( $categories as $cat_id ) {
     339                $wpdb->query("UPDATE $wpdb->categories SET category_count = category_count - 1 WHERE cat_ID = '$cat_id'");
     340                wp_cache_delete($cat_id, 'category');
     341            }
     342        }
     343    }
     344
     345    if ( 'page' == $post->post_type )
     346        $wpdb->query("UPDATE $wpdb->posts SET post_parent = $post->post_parent WHERE post_parent = $postid AND post_type = 'page'");
     347
     348    $wpdb->query("DELETE FROM $wpdb->posts WHERE ID = $postid");
     349
     350    $wpdb->query("DELETE FROM $wpdb->comments WHERE comment_post_ID = $postid");
     351
     352    $wpdb->query("DELETE FROM $wpdb->post2cat WHERE post_id = $postid");
     353
     354    $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = $postid");
     355
     356    if ( 'page' == $post->type ) {
     357        wp_cache_delete('all_page_ids', 'pages');
     358        $wp_rewrite->flush_rules();
     359    }
     360
     361    return $post;
     362}
     363
     364function wp_get_post_categories($post_ID = 0) {
     365    global $wpdb;
     366
     367    $post_ID = (int) $post_ID;
     368
     369    $sql = "SELECT category_id
     370        FROM $wpdb->post2cat
     371        WHERE post_id = '$post_ID'
     372        ORDER BY category_id";
     373
     374    $result = $wpdb->get_col($sql);
     375
     376    if ( !$result )
     377        $result = array();
     378
     379    return array_unique($result);
     380}
     381
     382function wp_get_recent_posts($num = 10) {
     383    global $wpdb;
     384
     385    // Set the limit clause, if we got a limit
     386    if ($num) {
     387        $limit = "LIMIT $num";
     388    }
     389
     390    $sql = "SELECT * FROM $wpdb->posts WHERE post_type = 'post' ORDER BY post_date DESC $limit";
     391    $result = $wpdb->get_results($sql,ARRAY_A);
     392
     393    return $result?$result:array();
     394}
     395
     396function wp_get_single_post($postid = 0, $mode = OBJECT) {
     397    global $wpdb;
     398
     399    $post = get_post($postid, $mode);
     400
     401    // Set categories
     402    if($mode == OBJECT) {
     403        $post->post_category = wp_get_post_categories($postid);
     404    }
     405    else {
     406        $post['post_category'] = wp_get_post_categories($postid);
     407    }
     408
     409    return $post;
     410}
     411
    8412function wp_insert_post($postarr = array()) {
    9413    global $wpdb, $wp_rewrite, $allowedtags, $user_ID;
     
    223627    return $post_ID;
    224628}
     629
     630function wp_update_post($postarr = array()) {
     631    global $wpdb;
     632
     633    if ( is_object($postarr) )
     634        $postarr = get_object_vars($postarr);
     635
     636    // First, get all of the original fields
     637    $post = wp_get_single_post($postarr['ID'], ARRAY_A);
     638
     639    // Escape data pulled from DB.
     640    $post = add_magic_quotes($post);
     641
     642    // Passed post category list overwrites existing category list if not empty.
     643    if ( isset($postarr['post_category']) && is_array($postarr['post_category'])
     644             && 0 != count($postarr['post_category']) )
     645        $post_cats = $postarr['post_category'];
     646    else
     647        $post_cats = $post['post_category'];
     648
     649    // Drafts shouldn't be assigned a date unless explicitly done so by the user
     650    if ( 'draft' == $post['post_status'] && empty($postarr['edit_date']) && empty($postarr['post_date']) &&
     651         ('0000-00-00 00:00:00' == $post['post_date']) )
     652        $clear_date = true;
     653    else
     654        $clear_date = false;
     655
     656    // Merge old and new fields with new fields overwriting old ones.
     657    $postarr = array_merge($post, $postarr);
     658    $postarr['post_category'] = $post_cats;
     659    if ( $clear_date ) {
     660        $postarr['post_date'] = '';
     661        $postarr['post_date_gmt'] = '';
     662    }
     663
     664    if ($postarr['post_type'] == 'attachment')
     665        return wp_insert_attachment($postarr);
     666
     667    return wp_insert_post($postarr);
     668}
     669
     670function wp_publish_post($post_id) {
     671    $post = get_post($post_id);
     672
     673    if ( empty($post) )
     674        return;
     675
     676    if ( 'publish' == $post->post_status )
     677        return;
     678
     679    return wp_update_post(array('post_status' => 'publish', 'ID' => $post_id));
     680}
     681
     682function wp_set_post_categories($post_ID = 0, $post_categories = array()) {
     683    global $wpdb;
     684    // If $post_categories isn't already an array, make it one:
     685    if (!is_array($post_categories) || 0 == count($post_categories))
     686        $post_categories = array(get_option('default_category'));
     687
     688    $post_categories = array_unique($post_categories);
     689
     690    // First the old categories
     691    $old_categories = $wpdb->get_col("
     692        SELECT category_id
     693        FROM $wpdb->post2cat
     694        WHERE post_id = $post_ID");
     695
     696    if (!$old_categories) {
     697        $old_categories = array();
     698    } else {
     699        $old_categories = array_unique($old_categories);
     700    }
     701
     702    // Delete any?
     703    $delete_cats = array_diff($old_categories,$post_categories);
     704
     705    if ($delete_cats) {
     706        foreach ($delete_cats as $del) {
     707            $wpdb->query("
     708                DELETE FROM $wpdb->post2cat
     709                WHERE category_id = $del
     710                    AND post_id = $post_ID
     711                ");
     712        }
     713    }
     714
     715    // Add any?
     716    $add_cats = array_diff($post_categories, $old_categories);
     717
     718    if ($add_cats) {
     719        foreach ($add_cats as $new_cat) {
     720            $wpdb->query("
     721                INSERT INTO $wpdb->post2cat (post_id, category_id)
     722                VALUES ($post_ID, $new_cat)");
     723        }
     724    }
     725
     726    // Update category counts.
     727    $all_affected_cats = array_unique(array_merge($post_categories, $old_categories));
     728    foreach ( $all_affected_cats as $cat_id ) {
     729        $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->post2cat, $wpdb->posts WHERE $wpdb->posts.ID=$wpdb->post2cat.post_id AND post_status = 'publish' AND post_type = 'post' AND category_id = '$cat_id'");
     730        $wpdb->query("UPDATE $wpdb->categories SET category_count = '$count' WHERE cat_ID = '$cat_id'");
     731        wp_cache_delete($cat_id, 'category');
     732    }
     733}   // wp_set_post_categories()
     734
     735//
     736// Trackback and ping functions
     737//
     738
     739function add_ping($post_id, $uri) { // Add a URI to those already pung
     740    global $wpdb;
     741    $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
     742    $pung = trim($pung);
     743    $pung = preg_split('/\s/', $pung);
     744    $pung[] = $uri;
     745    $new = implode("\n", $pung);
     746    $new = apply_filters('add_ping', $new);
     747    return $wpdb->query("UPDATE $wpdb->posts SET pinged = '$new' WHERE ID = $post_id");
     748}
     749
     750function get_enclosed($post_id) { // Get enclosures already enclosed for a post
     751    global $wpdb;
     752    $custom_fields = get_post_custom( $post_id );
     753    $pung = array();
     754    if ( !is_array( $custom_fields ) )
     755        return $pung;
     756
     757    foreach ( $custom_fields as $key => $val ) {
     758        if ( 'enclosure' != $key || !is_array( $val ) )
     759            continue;
     760        foreach( $val as $enc ) {
     761            $enclosure = split( "\n", $enc );
     762            $pung[] = trim( $enclosure[ 0 ] );
     763        }
     764    }
     765    $pung = apply_filters('get_enclosed', $pung);
     766    return $pung;
     767}
     768
     769function get_pung($post_id) { // Get URIs already pung for a post
     770    global $wpdb;
     771    $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
     772    $pung = trim($pung);
     773    $pung = preg_split('/\s/', $pung);
     774    $pung = apply_filters('get_pung', $pung);
     775    return $pung;
     776}
     777
     778function get_to_ping($post_id) { // Get any URIs in the todo list
     779    global $wpdb;
     780    $to_ping = $wpdb->get_var("SELECT to_ping FROM $wpdb->posts WHERE ID = $post_id");
     781    $to_ping = trim($to_ping);
     782    $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
     783    $to_ping = apply_filters('get_to_ping',  $to_ping);
     784    return $to_ping;
     785}
     786
     787// do trackbacks for a list of urls
     788// accepts a comma-separated list of trackback urls and a post id
     789function trackback_url_list($tb_list, $post_id) {
     790    if (!empty($tb_list)) {
     791        // get post data
     792        $postdata = wp_get_single_post($post_id, ARRAY_A);
     793
     794        // import postdata as variables
     795        extract($postdata);
     796
     797        // form an excerpt
     798        $excerpt = strip_tags($post_excerpt?$post_excerpt:$post_content);
     799
     800        if (strlen($excerpt) > 255) {
     801            $excerpt = substr($excerpt,0,252) . '...';
     802        }
     803
     804        $trackback_urls = explode(',', $tb_list);
     805        foreach($trackback_urls as $tb_url) {
     806            $tb_url = trim($tb_url);
     807            trackback($tb_url, stripslashes($post_title), $excerpt, $post_id);
     808        }
     809    }
     810}
     811
     812//
     813// Page functions
     814//
     815
     816function get_all_page_ids() {
     817    global $wpdb;
     818
     819    if ( ! $page_ids = wp_cache_get('all_page_ids', 'pages') ) {
     820        $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
     821        wp_cache_add('all_page_ids', $page_ids, 'pages');
     822    }
     823
     824    return $page_ids;
     825}
     826
     827
     828// Retrieves page data given a page ID or page object.
     829// Handles page caching.
     830function &get_page(&$page, $output = OBJECT) {
     831    global $wpdb;
     832
     833    if ( empty($page) ) {
     834        if ( isset($GLOBALS['page']) ) {
     835            $_page = & $GLOBALS['page'];
     836            wp_cache_add($_page->ID, $_page, 'pages');
     837        } else {
     838            $_page = null;
     839        }
     840    } elseif ( is_object($page) ) {
     841        if ( 'post' == $page->post_type )
     842            return get_post($page, $output);
     843        wp_cache_add($page->ID, $page, 'pages');
     844        $_page = $page;
     845    } else {
     846        if ( isset($GLOBALS['page']) && ($page == $GLOBALS['page']->ID) ) {
     847            $_page = & $GLOBALS['page'];
     848            wp_cache_add($_page->ID, $_page, 'pages');
     849        } elseif ( $_page = $GLOBALS['post_cache'][$page] ) {
     850            return get_post($page, $output);
     851        } elseif ( $_page = wp_cache_get($page, 'pages') ) {
     852            // Got it.
     853        } else {
     854            $query = "SELECT * FROM $wpdb->posts WHERE ID= '$page' LIMIT 1";
     855            $_page = & $wpdb->get_row($query);
     856            if ( 'post' == $_page->post_type )
     857                return get_post($_page, $output);
     858            wp_cache_add($_page->ID, $_page, 'pages');
     859        }
     860    }
     861
     862    if ( $output == OBJECT ) {
     863        return $_page;
     864    } elseif ( $output == ARRAY_A ) {
     865        return get_object_vars($_page);
     866    } elseif ( $output == ARRAY_N ) {
     867        return array_values(get_object_vars($_page));
     868    } else {
     869        return $_page;
     870    }
     871}
     872
     873function get_page_by_path($page_path, $output = OBJECT) {
     874    global $wpdb;
     875    $page_path = rawurlencode(urldecode($page_path));
     876    $page_path = str_replace('%2F', '/', $page_path);
     877    $page_path = str_replace('%20', ' ', $page_path);
     878    $page_paths = '/' . trim($page_path, '/');
     879    $leaf_path  = sanitize_title(basename($page_paths));
     880    $page_paths = explode('/', $page_paths);
     881    foreach($page_paths as $pathdir)
     882        $full_path .= ($pathdir!=''?'/':'') . sanitize_title($pathdir);
     883
     884    $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_name = '$leaf_path' AND post_type='page'");
     885
     886    if ( empty($pages) )
     887        return NULL;
     888
     889    foreach ($pages as $page) {
     890        $path = '/' . $leaf_path;
     891        $curpage = $page;
     892        while ($curpage->post_parent != 0) {
     893            $curpage = $wpdb->get_row("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE ID = '$curpage->post_parent' and post_type='page'");
     894            $path = '/' . $curpage->post_name . $path;
     895        }
     896
     897        if ( $path == $full_path )
     898            return get_page($page->ID, $output);
     899    }
     900
     901    return NULL;
     902}
     903
     904function &get_page_children($page_id, $pages) {
     905    global $page_cache;
     906
     907    if ( empty($pages) )
     908        $pages = &$page_cache;
     909
     910    $page_list = array();
     911    foreach ( $pages as $page ) {
     912        if ( $page->post_parent == $page_id ) {
     913            $page_list[] = $page;
     914            if ( $children = get_page_children($page->ID, $pages) )
     915                $page_list = array_merge($page_list, $children);
     916        }
     917    }
     918    return $page_list;
     919}
     920
     921//fetches the pages returned as a FLAT list, but arranged in order of their hierarchy, i.e., child parents
     922//immediately follow their parents
     923function get_page_hierarchy($posts, $parent = 0) {
     924    $result = array ( );
     925    if ($posts) { foreach ($posts as $post) {
     926        if ($post->post_parent == $parent) {
     927            $result[$post->ID] = $post->post_name;
     928            $children = get_page_hierarchy($posts, $post->ID);
     929            $result += $children; //append $children to $result
     930        }
     931    } }
     932    return $result;
     933}
     934
     935function &get_pages($args = '') {
     936    global $wpdb;
     937
     938    if ( is_array($args) )
     939        $r = &$args;
     940    else
     941        parse_str($args, $r);
     942
     943    $defaults = array('child_of' => 0, 'sort_order' => 'ASC', 'sort_column' => 'post_title',
     944                'hierarchical' => 1, 'exclude' => '', 'include' => '', 'meta_key' => '', 'meta_value' => '');
     945    $r = array_merge($defaults, $r);
     946    extract($r);
     947
     948    $inclusions = '';
     949    if ( !empty($include) ) {
     950        $child_of = 0; //ignore child_of, exclude, meta_key, and meta_value params if using include
     951        $exclude = ''; 
     952        $meta_key = '';
     953        $meta_value = '';
     954        $incpages = preg_split('/[\s,]+/',$include);
     955        if ( count($incpages) ) {
     956            foreach ( $incpages as $incpage ) {
     957                if (empty($inclusions))
     958                    $inclusions = ' AND ( ID = ' . intval($incpage) . ' ';
     959                else
     960                    $inclusions .= ' OR ID = ' . intval($incpage) . ' ';
     961            }
     962        }
     963    }
     964    if (!empty($inclusions))
     965        $inclusions .= ')';
     966
     967    $exclusions = '';
     968    if ( !empty($exclude) ) {
     969        $expages = preg_split('/[\s,]+/',$exclude);
     970        if ( count($expages) ) {
     971            foreach ( $expages as $expage ) {
     972                if (empty($exclusions))
     973                    $exclusions = ' AND ( ID <> ' . intval($expage) . ' ';
     974                else
     975                    $exclusions .= ' AND ID <> ' . intval($expage) . ' ';
     976            }
     977        }
     978    }
     979    if (!empty($exclusions))
     980        $exclusions .= ')';
     981
     982    $query = "SELECT * FROM $wpdb->posts " ;
     983    $query .= ( empty( $meta_key ) ? "" : ", $wpdb->postmeta " ) ;
     984    $query .= " WHERE (post_type = 'page' AND post_status = 'publish') $exclusions $inclusions " ;
     985    $query .= ( empty( $meta_key ) | empty($meta_value)  ? "" : " AND ($wpdb->posts.ID = $wpdb->postmeta.post_id AND $wpdb->postmeta.meta_key = '$meta_key' AND $wpdb->postmeta.meta_value = '$meta_value' )" ) ;
     986    $query .= " ORDER BY " . $sort_column . " " . $sort_order ;
     987
     988    $pages = $wpdb->get_results($query);
     989    $pages = apply_filters('get_pages', $pages, $r);
     990
     991    if ( empty($pages) )
     992        return array();
     993
     994    // Update cache.
     995    update_page_cache($pages);
     996
     997    if ( $child_of || $hierarchical )
     998        $pages = & get_page_children($child_of, $pages);
     999
     1000    return $pages;
     1001}
     1002
     1003function generate_page_uri_index() {
     1004    global $wpdb;
     1005
     1006    //get pages in order of hierarchy, i.e. children after parents
     1007    $posts = get_page_hierarchy($wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page'"));
     1008    //now reverse it, because we need parents after children for rewrite rules to work properly
     1009    $posts = array_reverse($posts, true);
     1010
     1011    $page_uris = array();
     1012    $page_attachment_uris = array();
     1013
     1014    if ($posts) {
     1015
     1016        foreach ($posts as $id => $post) {
     1017
     1018            // URI => page name
     1019            $uri = get_page_uri($id);
     1020            $attachments = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = '$id'");
     1021            if ( $attachments ) {
     1022                foreach ( $attachments as $attachment ) {
     1023                    $attach_uri = get_page_uri($attachment->ID);
     1024                    $page_attachment_uris[$attach_uri] = $attachment->ID;
     1025                }
     1026            }
     1027
     1028            $page_uris[$uri] = $id;
     1029        }
     1030
     1031        update_option('page_uris', $page_uris);
     1032
     1033        if ( $page_attachment_uris )
     1034            update_option('page_attachment_uris', $page_attachment_uris);
     1035    }
     1036}
     1037
     1038//
     1039// Attachment functions
     1040//
    2251041
    2261042function wp_insert_attachment($object, $file = false, $post_parent = 0) {
     
    4051221}
    4061222
    407 function wp_get_single_post($postid = 0, $mode = OBJECT) {
    408     global $wpdb;
    409 
    410     $post = get_post($postid, $mode);
    411 
    412     // Set categories
    413     if($mode == OBJECT) {
    414         $post->post_category = wp_get_post_categories($postid);
    415     }
    416     else {
    417         $post['post_category'] = wp_get_post_categories($postid);
    418     }
    419 
    420     return $post;
    421 }
    422 
    423 function wp_get_recent_posts($num = 10) {
    424     global $wpdb;
    425 
    426     // Set the limit clause, if we got a limit
    427     if ($num) {
    428         $limit = "LIMIT $num";
    429     }
    430 
    431     $sql = "SELECT * FROM $wpdb->posts WHERE post_type = 'post' ORDER BY post_date DESC $limit";
    432     $result = $wpdb->get_results($sql,ARRAY_A);
    433 
    434     return $result?$result:array();
    435 }
    436 
    437 function wp_update_post($postarr = array()) {
    438     global $wpdb;
    439 
    440     if ( is_object($postarr) )
    441         $postarr = get_object_vars($postarr);
    442 
    443     // First, get all of the original fields
    444     $post = wp_get_single_post($postarr['ID'], ARRAY_A);
    445 
    446     // Escape data pulled from DB.
    447     $post = add_magic_quotes($post);
    448 
    449     // Passed post category list overwrites existing category list if not empty.
    450     if ( isset($postarr['post_category']) && is_array($postarr['post_category'])
    451              && 0 != count($postarr['post_category']) )
    452         $post_cats = $postarr['post_category'];
    453     else
    454         $post_cats = $post['post_category'];
    455 
    456     // Drafts shouldn't be assigned a date unless explicitly done so by the user
    457     if ( 'draft' == $post['post_status'] && empty($postarr['edit_date']) && empty($postarr['post_date']) &&
    458          ('0000-00-00 00:00:00' == $post['post_date']) )
    459         $clear_date = true;
    460     else
    461         $clear_date = false;
    462 
    463     // Merge old and new fields with new fields overwriting old ones.
    464     $postarr = array_merge($post, $postarr);
    465     $postarr['post_category'] = $post_cats;
    466     if ( $clear_date ) {
    467         $postarr['post_date'] = '';
    468         $postarr['post_date_gmt'] = '';
    469     }
    470 
    471     if ($postarr['post_type'] == 'attachment')
    472         return wp_insert_attachment($postarr);
    473 
    474     return wp_insert_post($postarr);
    475 }
    476 
    477 function wp_publish_post($post_id) {
    478     $post = get_post($post_id);
    479 
    480     if ( empty($post) )
    481         return;
    482 
    483     if ( 'publish' == $post->post_status )
    484         return;
    485 
    486     return wp_update_post(array('post_status' => 'publish', 'ID' => $post_id));
    487 }
    488 
    489 function wp_get_post_categories($post_ID = 0) {
    490     global $wpdb;
    491 
    492     $post_ID = (int) $post_ID;
    493 
    494     $sql = "SELECT category_id
    495         FROM $wpdb->post2cat
    496         WHERE post_id = '$post_ID'
    497         ORDER BY category_id";
    498 
    499     $result = $wpdb->get_col($sql);
    500 
    501     if ( !$result )
    502         $result = array();
    503 
    504     return array_unique($result);
    505 }
    506 
    507 function wp_set_post_categories($post_ID = 0, $post_categories = array()) {
    508     global $wpdb;
    509     // If $post_categories isn't already an array, make it one:
    510     if (!is_array($post_categories) || 0 == count($post_categories))
    511         $post_categories = array(get_option('default_category'));
    512 
    513     $post_categories = array_unique($post_categories);
    514 
    515     // First the old categories
    516     $old_categories = $wpdb->get_col("
    517         SELECT category_id
    518         FROM $wpdb->post2cat
    519         WHERE post_id = $post_ID");
    520 
    521     if (!$old_categories) {
    522         $old_categories = array();
    523     } else {
    524         $old_categories = array_unique($old_categories);
    525     }
    526 
    527     // Delete any?
    528     $delete_cats = array_diff($old_categories,$post_categories);
    529 
    530     if ($delete_cats) {
    531         foreach ($delete_cats as $del) {
    532             $wpdb->query("
    533                 DELETE FROM $wpdb->post2cat
    534                 WHERE category_id = $del
    535                     AND post_id = $post_ID
    536                 ");
    537         }
    538     }
    539 
    540     // Add any?
    541     $add_cats = array_diff($post_categories, $old_categories);
    542 
    543     if ($add_cats) {
    544         foreach ($add_cats as $new_cat) {
    545             $wpdb->query("
    546                 INSERT INTO $wpdb->post2cat (post_id, category_id)
    547                 VALUES ($post_ID, $new_cat)");
    548         }
    549     }
    550 
    551     // Update category counts.
    552     $all_affected_cats = array_unique(array_merge($post_categories, $old_categories));
    553     foreach ( $all_affected_cats as $cat_id ) {
    554         $count = $wpdb->get_var("SELECT COUNT(*) FROM $wpdb->post2cat, $wpdb->posts WHERE $wpdb->posts.ID=$wpdb->post2cat.post_id AND post_status = 'publish' AND post_type = 'post' AND category_id = '$cat_id'");
    555         $wpdb->query("UPDATE $wpdb->categories SET category_count = '$count' WHERE cat_ID = '$cat_id'");
    556         wp_cache_delete($cat_id, 'category');
    557     }
    558 }   // wp_set_post_categories()
    559 
    560 function wp_delete_post($postid = 0) {
    561     global $wpdb, $wp_rewrite;
    562     $postid = (int) $postid;
    563 
    564     if ( !$post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $postid") )
    565         return $post;
    566 
    567     if ( 'attachment' == $post->post_type )
    568         return wp_delete_attachment($postid);
    569 
    570     do_action('delete_post', $postid);
    571 
    572     if ( 'publish' == $post->post_status && 'post' == $post->post_type ) {
    573         $categories = wp_get_post_categories($post->ID);
    574         if( is_array( $categories ) ) {
    575             foreach ( $categories as $cat_id ) {
    576                 $wpdb->query("UPDATE $wpdb->categories SET category_count = category_count - 1 WHERE cat_ID = '$cat_id'");
    577                 wp_cache_delete($cat_id, 'category');
    578             }
    579         }
    580     }
    581 
    582     if ( 'page' == $post->post_type )
    583         $wpdb->query("UPDATE $wpdb->posts SET post_parent = $post->post_parent WHERE post_parent = $postid AND post_type = 'page'");
    584 
    585     $wpdb->query("DELETE FROM $wpdb->posts WHERE ID = $postid");
    586 
    587     $wpdb->query("DELETE FROM $wpdb->comments WHERE comment_post_ID = $postid");
    588 
    589     $wpdb->query("DELETE FROM $wpdb->post2cat WHERE post_id = $postid");
    590 
    591     $wpdb->query("DELETE FROM $wpdb->postmeta WHERE post_id = $postid");
    592 
    593     if ( 'page' == $post->type ) {
    594         wp_cache_delete('all_page_ids', 'pages');
    595         $wp_rewrite->flush_rules();
    596     }
    597 
    598     return $post;
    599 }
    600 
    601 /**** /DB Functions ****/
    602 
    603 /**** Misc ****/
    604 
    605 // get permalink from post ID
    606 function post_permalink($post_id = 0, $mode = '') { // $mode legacy
    607     return get_permalink($post_id);
    608 }
    609 
    610 // Get author's preferred display name
    611 function get_author_name( $auth_id ) {
    612     $authordata = get_userdata( $auth_id );
    613 
    614     return $authordata->display_name;
    615 }
    616 
    617 // get extended entry info (<!--more-->)
    618 function get_extended($post) {
    619     list($main,$extended) = explode('<!--more-->', $post, 2);
    620 
    621     // Strip leading and trailing whitespace
    622     $main = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$main);
    623     $extended = preg_replace('/^[\s]*(.*)[\s]*$/','\\1',$extended);
    624 
    625     return array('main' => $main, 'extended' => $extended);
    626 }
    627 
    628 // do trackbacks for a list of urls
    629 // borrowed from edit.php
    630 // accepts a comma-separated list of trackback urls and a post id
    631 function trackback_url_list($tb_list, $post_id) {
    632     if (!empty($tb_list)) {
    633         // get post data
    634         $postdata = wp_get_single_post($post_id, ARRAY_A);
    635 
    636         // import postdata as variables
    637         extract($postdata);
    638 
    639         // form an excerpt
    640         $excerpt = strip_tags($post_excerpt?$post_excerpt:$post_content);
    641 
    642         if (strlen($excerpt) > 255) {
    643             $excerpt = substr($excerpt,0,252) . '...';
    644         }
    645 
    646         $trackback_urls = explode(',', $tb_list);
    647         foreach($trackback_urls as $tb_url) {
    648             $tb_url = trim($tb_url);
    649             trackback($tb_url, stripslashes($post_title), $excerpt, $post_id);
    650         }
    651     }
    652 }
    653 
    654 function wp_blacklist_check($author, $email, $url, $comment, $user_ip, $user_agent) {
    655     global $wpdb;
    656 
    657     do_action('wp_blacklist_check', $author, $email, $url, $comment, $user_ip, $user_agent);
    658 
    659     if ( preg_match_all('/&#(\d+);/', $comment . $author . $url, $chars) ) {
    660         foreach ($chars[1] as $char) {
    661             // If it's an encoded char in the normal ASCII set, reject
    662             if ( 38 == $char )
    663                 continue; // Unless it's &
    664             if ($char < 128)
    665                 return true;
    666         }
    667     }
    668 
    669     $mod_keys = trim( get_settings('blacklist_keys') );
    670     if ('' == $mod_keys )
    671         return false; // If moderation keys are empty
    672     $words = explode("\n", $mod_keys );
    673 
    674     foreach ($words as $word) {
    675         $word = trim($word);
    676 
    677         // Skip empty lines
    678         if ( empty($word) ) { continue; }
    679 
    680         // Do some escaping magic so that '#' chars in the
    681         // spam words don't break things:
    682         $word = preg_quote($word, '#');
    683 
    684         $pattern = "#$word#i";
    685         if ( preg_match($pattern, $author    ) ) return true;
    686         if ( preg_match($pattern, $email     ) ) return true;
    687         if ( preg_match($pattern, $url       ) ) return true;
    688         if ( preg_match($pattern, $comment   ) ) return true;
    689         if ( preg_match($pattern, $user_ip   ) ) return true;
    690         if ( preg_match($pattern, $user_agent) ) return true;
    691     }
    692 
    693     if ( isset($_SERVER['REMOTE_ADDR']) ) {
    694         if ( wp_proxy_check($_SERVER['REMOTE_ADDR']) ) return true;
    695     }
    696 
    697     return false;
    698 }
    699 
    700 function wp_proxy_check($ipnum) {
    701     if ( get_option('open_proxy_check') && isset($ipnum) ) {
    702         $rev_ip = implode( '.', array_reverse( explode( '.', $ipnum ) ) );
    703         $lookup = $rev_ip . '.opm.blitzed.org.';
    704         if ( $lookup != gethostbyname( $lookup ) )
    705             return true;
    706     }
    707 
    708     return false;
    709 }
    710 
    711 function do_trackbacks($post_id) {
    712     global $wpdb;
    713 
    714     $post = $wpdb->get_row("SELECT * FROM $wpdb->posts WHERE ID = $post_id");
    715     $to_ping = get_to_ping($post_id);
    716     $pinged  = get_pung($post_id);
    717     if ( empty($to_ping) ) {
    718         $wpdb->query("UPDATE $wpdb->posts SET to_ping = '' WHERE ID = '$post_id'");
    719         return;
    720     }
    721 
    722     if (empty($post->post_excerpt))
    723         $excerpt = apply_filters('the_content', $post->post_content);
    724     else
    725         $excerpt = apply_filters('the_excerpt', $post->post_excerpt);
    726     $excerpt = str_replace(']]>', ']]&gt;', $excerpt);
    727     $excerpt = strip_tags($excerpt);
    728     if ( function_exists('mb_strcut') ) // For international trackbacks
    729         $excerpt = mb_strcut($excerpt, 0, 252, get_settings('blog_charset')) . '...';
    730     else
    731         $excerpt = substr($excerpt, 0, 252) . '...';
    732 
    733     $post_title = apply_filters('the_title', $post->post_title);
    734     $post_title = strip_tags($post_title);
    735 
    736     if ($to_ping) : foreach ($to_ping as $tb_ping) :
    737         $tb_ping = trim($tb_ping);
    738         if ( !in_array($tb_ping, $pinged) ) {
    739             trackback($tb_ping, $post_title, $excerpt, $post_id);
    740             $pinged[] = $tb_ping;
    741         } else {
    742             $wpdb->query("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, '$tb_ping', '')) WHERE ID = '$post_id'");
    743         }
    744     endforeach; endif;
    745 }
    746 
    747 function get_pung($post_id) { // Get URIs already pung for a post
    748     global $wpdb;
    749     $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
    750     $pung = trim($pung);
    751     $pung = preg_split('/\s/', $pung);
    752     $pung = apply_filters('get_pung', $pung);
    753     return $pung;
    754 }
    755 
    756 function get_enclosed($post_id) { // Get enclosures already enclosed for a post
    757     global $wpdb;
    758     $custom_fields = get_post_custom( $post_id );
    759     $pung = array();
    760     if ( !is_array( $custom_fields ) )
    761         return $pung;
    762 
    763     foreach ( $custom_fields as $key => $val ) {
    764         if ( 'enclosure' != $key || !is_array( $val ) )
    765             continue;
    766         foreach( $val as $enc ) {
    767             $enclosure = split( "\n", $enc );
    768             $pung[] = trim( $enclosure[ 0 ] );
    769         }
    770     }
    771     $pung = apply_filters('get_enclosed', $pung);
    772     return $pung;
    773 }
    774 
    775 function get_to_ping($post_id) { // Get any URIs in the todo list
    776     global $wpdb;
    777     $to_ping = $wpdb->get_var("SELECT to_ping FROM $wpdb->posts WHERE ID = $post_id");
    778     $to_ping = trim($to_ping);
    779     $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
    780     $to_ping = apply_filters('get_to_ping',  $to_ping);
    781     return $to_ping;
    782 }
    783 
    784 function add_ping($post_id, $uri) { // Add a URI to those already pung
    785     global $wpdb;
    786     $pung = $wpdb->get_var("SELECT pinged FROM $wpdb->posts WHERE ID = $post_id");
    787     $pung = trim($pung);
    788     $pung = preg_split('/\s/', $pung);
    789     $pung[] = $uri;
    790     $new = implode("\n", $pung);
    791     $new = apply_filters('add_ping', $new);
    792     return $wpdb->query("UPDATE $wpdb->posts SET pinged = '$new' WHERE ID = $post_id");
    793 }
    794 
    795 //fetches the pages returned as a FLAT list, but arranged in order of their hierarchy, i.e., child parents
    796 //immediately follow their parents
    797 function get_page_hierarchy($posts, $parent = 0) {
    798     $result = array ( );
    799     if ($posts) { foreach ($posts as $post) {
    800         if ($post->post_parent == $parent) {
    801             $result[$post->ID] = $post->post_name;
    802             $children = get_page_hierarchy($posts, $post->ID);
    803             $result += $children; //append $children to $result
    804         }
    805     } }
    806     return $result;
    807 }
    808 
    809 function generate_page_uri_index() {
    810     global $wpdb;
    811 
    812     //get pages in order of hierarchy, i.e. children after parents
    813     $posts = get_page_hierarchy($wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page'"));
    814     //now reverse it, because we need parents after children for rewrite rules to work properly
    815     $posts = array_reverse($posts, true);
    816 
    817     $page_uris = array();
    818     $page_attachment_uris = array();
    819 
    820     if ($posts) {
    821 
    822         foreach ($posts as $id => $post) {
    823 
    824             // URI => page name
    825             $uri = get_page_uri($id);
    826             $attachments = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = '$id'");
    827             if ( $attachments ) {
    828                 foreach ( $attachments as $attachment ) {
    829                     $attach_uri = get_page_uri($attachment->ID);
    830                     $page_attachment_uris[$attach_uri] = $attachment->ID;
    831                 }
    832             }
    833 
    834             $page_uris[$uri] = $id;
    835         }
    836 
    837         update_option('page_uris', $page_uris);
    838 
    839         if ( $page_attachment_uris )
    840             update_option('page_attachment_uris', $page_attachment_uris);
    841     }
    842 }
    843 
    844 function get_post_status($ID = '') {
    845     $post = get_post($ID);
    846 
    847     if ( is_object($post) ) {
    848         if ( ('attachment' == $post->post_type) && $post->post_parent && ($post->ID != $post->post_parent) )
    849             return get_post_status($post->post_parent);
    850         else
    851             return $post->post_status;
    852     }
    853 
    854     return false;
    855 }
    856 
    857 function get_post_type($post = false) {
    858     global $wpdb, $posts;
    859 
    860     if ( false === $post )
    861         $post = $posts[0];
    862     elseif ( (int) $post )
    863         $post = get_post($post, OBJECT);
    864 
    865     if ( is_object($post) )
    866         return $post->post_type;
    867 
    868     return false;
    869 }
    870 
    871 // Takes a post ID, returns its mime type.
    872 function get_post_mime_type($ID = '') {
    873     $post = & get_post($ID);
    874 
    875     if ( is_object($post) )
    876         return $post->post_mime_type;
    877 
    878     return false;
    879 }
    880 
    881 function get_attached_file($attachment_id) {
    882     return get_post_meta($attachment_id, '_wp_attached_file', true);
    883 }
    884 
    885 function wp_mkdir_p($target) {
    886     // from php.net/mkdir user contributed notes
    887     if (file_exists($target)) {
    888         if (! @ is_dir($target))
    889             return false;
    890         else
    891             return true;
    892     }
    893 
    894     // Attempting to create the directory may clutter up our display.
    895     if (@ mkdir($target)) {
    896         $stat = @ stat(dirname($target));
    897         $dir_perms = $stat['mode'] & 0007777;  // Get the permission bits.
    898         @ chmod($target, $dir_perms);
    899         return true;
    900     } else {
    901         if ( is_dir(dirname($target)) )
    902             return false;
    903     }
    904 
    905     // If the above failed, attempt to create the parent node, then try again.
    906     if (wp_mkdir_p(dirname($target)))
    907         return wp_mkdir_p($target);
    908 
    909     return false;
    910 }
    911 
    912 // Returns an array containing the current upload directory's path and url, or an error message.
    913 function wp_upload_dir() {
    914     $siteurl = get_settings('siteurl');
    915     //prepend ABSPATH to $dir and $siteurl to $url if they're not already there
    916     $path = str_replace(ABSPATH, '', trim(get_settings('upload_path')));
    917     $dir = ABSPATH . $path;
    918     $url = trailingslashit($siteurl) . $path;
    919 
    920     if ( $dir == ABSPATH ) { //the option was empty
    921         $dir = ABSPATH . 'wp-content/uploads';
    922     }
    923 
    924     if ( defined('UPLOADS') ) {
    925         $dir = ABSPATH . UPLOADS;
    926         $url = trailingslashit($siteurl) . UPLOADS;
    927     }
    928 
    929     if ( get_settings('uploads_use_yearmonth_folders')) {
    930         // Generate the yearly and monthly dirs
    931         $time = current_time( 'mysql' );
    932         $y = substr( $time, 0, 4 );
    933         $m = substr( $time, 5, 2 );
    934         $dir = $dir . "/$y/$m";
    935         $url = $url . "/$y/$m";
    936     }
    937 
    938     // Make sure we have an uploads dir
    939     if ( ! wp_mkdir_p( $dir ) ) {
    940         $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), $dir);
    941         return array('error' => $message);
    942     }
    943 
    944     $uploads = array('path' => $dir, 'url' => $url, 'error' => false);
    945     return apply_filters('upload_dir', $uploads);
    946 }
    947 
    948 function wp_upload_bits($name, $type, $bits) {
    949     if ( empty($name) )
    950         return array('error' => "Empty filename");
    951 
    952     $upload = wp_upload_dir();
    953 
    954     if ( $upload['error'] !== false )
    955         return $upload;
    956 
    957     $number = '';
    958     $filename = $name;
    959     $path_parts = pathinfo($filename);
    960     $ext = $path_parts['extension'];
    961     if ( empty($ext) )
    962         $ext = '';
    963     else
    964         $ext = ".$ext";
    965     while ( file_exists($upload['path'] . "/$filename") ) {
    966         if ( '' == "$number$ext" )
    967             $filename = $filename . ++$number . $ext;
    968         else
    969             $filename = str_replace("$number$ext", ++$number . $ext, $filename);
    970     }
    971 
    972     $new_file = $upload['path'] . "/$filename";
    973     if ( ! wp_mkdir_p( dirname($new_file) ) ) {
    974         $message = sprintf(__('Unable to create directory %s. Is its parent directory writable by the server?'), dirname($new_file));
    975         return array('error' => $message);
    976     }
    977 
    978     $ifp = @ fopen($new_file, 'wb');
    979     if ( ! $ifp )
    980         return array('error' => "Could not write file $new_file.");
    981 
    982     $success = @ fwrite($ifp, $bits);
    983     fclose($ifp);
    984     // Set correct file permissions
    985     $stat = @ stat(dirname($new_file));
    986     $perms = $stat['mode'] & 0007777;
    987     $perms = $perms & 0000666;
    988     @ chmod($new_file, $perms);
    989 
    990     // Compute the URL
    991     $url = $upload['url'] . "/$filename";
    992 
    993     return array('file' => $new_file, 'url' => $url, 'error' => false);
    994 }
    995 
    996 function do_all_pings() {
    997     global $wpdb;
    998 
    999     // Do pingbacks
    1000     while ($ping = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_pingme' LIMIT 1")) {
    1001         $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$ping->ID} AND meta_key = '_pingme';");
    1002         pingback($ping->post_content, $ping->ID);
    1003     }
    1004    
    1005     // Do Enclosures
    1006     while ($enclosure = $wpdb->get_row("SELECT * FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_encloseme' LIMIT 1")) {
    1007         $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE post_id = {$enclosure->ID} AND meta_key = '_encloseme';");
    1008         do_enclose($enclosure->post_content, $enclosure->ID);
    1009     }
    1010 
    1011     // Do Trackbacks
    1012     $trackbacks = $wpdb->get_results("SELECT ID FROM $wpdb->posts WHERE CHAR_LENGTH(TRIM(to_ping)) > 7 AND post_status = 'publish'");
    1013     if ( is_array($trackbacks) ) {
    1014         foreach ( $trackbacks as $trackback ) {
    1015             do_trackbacks($trackback->ID);
    1016         }
    1017     }
    1018 
    1019     //Do Update Services/Generic Pings
    1020     generic_ping();
    1021 }
    1022 
    1023 /**
    1024  * Places a textarea according to the current user's preferences, filled with $content.
    1025  * Also places a script block that enables tabbing between Title and Content.
    1026  *
    1027  * @param string Editor contents
    1028  * @param string (optional) Previous form field's ID (for tabbing support)
    1029  */
    1030 function the_editor($content, $id = 'content', $prev_id = 'title') {
    1031     $rows = get_settings('default_post_edit_rows');
    1032     if (($rows < 3) || ($rows > 100))
    1033         $rows = 12;
    1034 
    1035     $rows = "rows='$rows'";
    1036 
    1037     the_quicktags();
    1038 
    1039     if ( user_can_richedit() )
    1040         add_filter('the_editor_content', 'wp_richedit_pre');
    1041 
    1042     $the_editor = apply_filters('the_editor', "<div><textarea class='mceEditor' $rows cols='40' name='$id' tabindex='2' id='$id'>%s</textarea></div>\n");
    1043     $the_editor_content = apply_filters('the_editor_content', $content);
    1044 
    1045     printf($the_editor, $the_editor_content);
    1046 
    1047     ?>
    1048     <script type="text/javascript">
    1049     //<!--
    1050     edCanvas = document.getElementById('<?php echo $id; ?>');
    1051     <?php if ( user_can_richedit() ) : ?>
    1052     // This code is meant to allow tabbing from Title to Post (TinyMCE).
    1053     if ( tinyMCE.isMSIE )
    1054         document.getElementById('<?php echo $prev_id; ?>').onkeydown = function (e)
    1055             {
    1056                 e = e ? e : window.event;
    1057                 if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
    1058                     var i = tinyMCE.selectedInstance;
    1059                     if(typeof i ==  'undefined')
    1060                         return true;
    1061                                     tinyMCE.execCommand("mceStartTyping");
    1062                     this.blur();
    1063                     i.contentWindow.focus();
    1064                     e.returnValue = false;
    1065                     return false;
    1066                 }
    1067             }
    1068     else
    1069         document.getElementById('<?php echo $prev_id; ?>').onkeypress = function (e)
    1070             {
    1071                 e = e ? e : window.event;
    1072                 if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
    1073                     var i = tinyMCE.selectedInstance;
    1074                     if(typeof i ==  'undefined')
    1075                         return true;
    1076                                     tinyMCE.execCommand("mceStartTyping");
    1077                     this.blur();
    1078                     i.contentWindow.focus();
    1079                     e.returnValue = false;
    1080                     return false;
    1081                 }
    1082             }
    1083     <?php endif; ?>
    1084     //-->
    1085     </script>
    1086     <?php
    1087 }
    1088 
    10891223?>
  • trunk/wp-includes/template-functions-author.php

    r3848 r3851  
    156156}
    157157
     158// Get author's preferred display name
     159function get_author_name( $auth_id ) {
     160    $authordata = get_userdata( $auth_id );
     161
     162    return $authordata->display_name;
     163}
     164
    158165function wp_list_authors($args = '') {
    159166    if ( is_array($args) )
  • trunk/wp-includes/template-functions-general.php

    r3740 r3851  
    695695}
    696696
     697function wp_head() {
     698    do_action('wp_head');
     699}
     700
     701function wp_footer() {
     702    do_action('wp_footer');
     703}
     704
    697705function rsd_link() {
    698706    echo '<link rel="EditURI" type="application/rsd+xml" title="RSD" href="' . get_bloginfo('wpurl') . "/xmlrpc.php?rsd\" />\n";
     
    704712        echo '<meta name="robots" content="noindex,nofollow" />' . "\n";
    705713}
     714
     715/**
     716 * Places a textarea according to the current user's preferences, filled with $content.
     717 * Also places a script block that enables tabbing between Title and Content.
     718 *
     719 * @param string Editor contents
     720 * @param string (optional) Previous form field's ID (for tabbing support)
     721 */
     722function the_editor($content, $id = 'content', $prev_id = 'title') {
     723    $rows = get_settings('default_post_edit_rows');
     724    if (($rows < 3) || ($rows > 100))
     725        $rows = 12;
     726
     727    $rows = "rows='$rows'";
     728
     729    the_quicktags();
     730
     731    if ( user_can_richedit() )
     732        add_filter('the_editor_content', 'wp_richedit_pre');
     733
     734    $the_editor = apply_filters('the_editor', "<div><textarea class='mceEditor' $rows cols='40' name='$id' tabindex='2' id='$id'>%s</textarea></div>\n");
     735    $the_editor_content = apply_filters('the_editor_content', $content);
     736
     737    printf($the_editor, $the_editor_content);
     738
     739    ?>
     740    <script type="text/javascript">
     741    //<!--
     742    edCanvas = document.getElementById('<?php echo $id; ?>');
     743    <?php if ( user_can_richedit() ) : ?>
     744    // This code is meant to allow tabbing from Title to Post (TinyMCE).
     745    if ( tinyMCE.isMSIE )
     746        document.getElementById('<?php echo $prev_id; ?>').onkeydown = function (e)
     747            {
     748                e = e ? e : window.event;
     749                if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
     750                    var i = tinyMCE.selectedInstance;
     751                    if(typeof i ==  'undefined')
     752                        return true;
     753                                    tinyMCE.execCommand("mceStartTyping");
     754                    this.blur();
     755                    i.contentWindow.focus();
     756                    e.returnValue = false;
     757                    return false;
     758                }
     759            }
     760    else
     761        document.getElementById('<?php echo $prev_id; ?>').onkeypress = function (e)
     762            {
     763                e = e ? e : window.event;
     764                if (e.keyCode == 9 && !e.shiftKey && !e.controlKey && !e.altKey) {
     765                    var i = tinyMCE.selectedInstance;
     766                    if(typeof i ==  'undefined')
     767                        return true;
     768                                    tinyMCE.execCommand("mceStartTyping");
     769                    this.blur();
     770                    i.contentWindow.focus();
     771                    e.returnValue = false;
     772                    return false;
     773                }
     774            }
     775    <?php endif; ?>
     776    //-->
     777    </script>
     778    <?php
     779}
     780
    706781?>
  • trunk/wp-includes/template-functions-links.php

    r3708 r3851  
    8585}
    8686
     87// get permalink from post ID
     88function post_permalink($post_id = 0, $mode = '') { // $mode legacy
     89    return get_permalink($post_id);
     90}
     91
    8792function get_page_link($id = false) {
    8893    global $post, $wp_rewrite;
  • trunk/wp-settings.php

    r3845 r3851  
    125125
    126126require (ABSPATH . WPINC . '/functions-formatting.php');
    127 require (ABSPATH . WPINC . '/functions-post.php');
    128127require (ABSPATH . WPINC . '/capabilities.php');
    129128require (ABSPATH . WPINC . '/classes.php');
     
    133132require (ABSPATH . WPINC . '/template-functions-links.php');
    134133require (ABSPATH . WPINC . '/template-functions-author.php');
    135 require (ABSPATH . WPINC . '/template-functions-post.php');
     134require (ABSPATH . WPINC . '/post.php');
     135require (ABSPATH . WPINC . '/post-template.php');
    136136require (ABSPATH . WPINC . '/category.php');
    137137require (ABSPATH . WPINC . '/category-template.php');
Note: See TracChangeset for help on using the changeset viewer.