WordPress 4.2
[autoinstalls/wordpress.git] / wp-includes / option.php
1 <?php
2 /**
3  * Option API
4  *
5  * @package WordPress
6  * @subpackage Option
7  */
8
9 /**
10  * Retrieve option value based on name of option.
11  *
12  * If the option does not exist or does not have a value, then the return value
13  * will be false. This is useful to check whether you need to install an option
14  * and is commonly used during installation of plugin options and to test
15  * whether upgrading is required.
16  *
17  * If the option was serialized then it will be unserialized when it is returned.
18  *
19  * @since 1.5.0
20  *
21  * @param string $option Name of option to retrieve. Expected to not be SQL-escaped.
22  * @param mixed $default Optional. Default value to return if the option does not exist.
23  * @return mixed Value set for the option.
24  */
25 function get_option( $option, $default = false ) {
26         global $wpdb;
27
28         $option = trim( $option );
29         if ( empty( $option ) )
30                 return false;
31
32         /**
33          * Filter the value of an existing option before it is retrieved.
34          *
35          * The dynamic portion of the hook name, `$option`, refers to the option name.
36          *
37          * Passing a truthy value to the filter will short-circuit retrieving
38          * the option value, returning the passed value instead.
39          *
40          * @since 1.5.0
41          *
42          * @param bool|mixed $pre_option Value to return instead of the option value.
43          *                               Default false to skip it.
44          */
45         $pre = apply_filters( 'pre_option_' . $option, false );
46         if ( false !== $pre )
47                 return $pre;
48
49         if ( defined( 'WP_SETUP_CONFIG' ) )
50                 return false;
51
52         if ( ! defined( 'WP_INSTALLING' ) ) {
53                 // prevent non-existent options from triggering multiple queries
54                 $notoptions = wp_cache_get( 'notoptions', 'options' );
55                 if ( isset( $notoptions[ $option ] ) ) {
56                         /**
57                          * Filter the default value for an option.
58                          *
59                          * The dynamic portion of the hook name, `$option`, refers to the option name.
60                          *
61                          * @since 3.4.0
62                          *
63                          * @param mixed $default The default value to return if the option does not exist
64                          *                       in the database.
65                          */
66                         return apply_filters( 'default_option_' . $option, $default );
67                 }
68
69                 $alloptions = wp_load_alloptions();
70
71                 if ( isset( $alloptions[$option] ) ) {
72                         $value = $alloptions[$option];
73                 } else {
74                         $value = wp_cache_get( $option, 'options' );
75
76                         if ( false === $value ) {
77                                 $row = $wpdb->get_row( $wpdb->prepare( "SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1", $option ) );
78
79                                 // Has to be get_row instead of get_var because of funkiness with 0, false, null values
80                                 if ( is_object( $row ) ) {
81                                         $value = $row->option_value;
82                                         wp_cache_add( $option, $value, 'options' );
83                                 } else { // option does not exist, so we must cache its non-existence
84                                         $notoptions[$option] = true;
85                                         wp_cache_set( 'notoptions', $notoptions, 'options' );
86
87                                         /** This filter is documented in wp-includes/option.php */
88                                         return apply_filters( 'default_option_' . $option, $default );
89                                 }
90                         }
91                 }
92         } else {
93                 $suppress = $wpdb->suppress_errors();
94                 $row = $wpdb->get_row( $wpdb->prepare( "SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1", $option ) );
95                 $wpdb->suppress_errors( $suppress );
96                 if ( is_object( $row ) ) {
97                         $value = $row->option_value;
98                 } else {
99                         /** This filter is documented in wp-includes/option.php */
100                         return apply_filters( 'default_option_' . $option, $default );
101                 }
102         }
103
104         // If home is not set use siteurl.
105         if ( 'home' == $option && '' == $value )
106                 return get_option( 'siteurl' );
107
108         if ( in_array( $option, array('siteurl', 'home', 'category_base', 'tag_base') ) )
109                 $value = untrailingslashit( $value );
110
111         /**
112          * Filter the value of an existing option.
113          *
114          * The dynamic portion of the hook name, `$option`, refers to the option name.
115          *
116          * @since 1.5.0 As 'option_' . $setting
117          * @since 3.0.0
118          *
119          * @param mixed $value Value of the option. If stored serialized, it will be
120          *                     unserialized prior to being returned.
121          */
122         return apply_filters( 'option_' . $option, maybe_unserialize( $value ) );
123 }
124
125 /**
126  * Protect WordPress special option from being modified.
127  *
128  * Will die if $option is in protected list. Protected options are 'alloptions'
129  * and 'notoptions' options.
130  *
131  * @since 2.2.0
132  *
133  * @param string $option Option name.
134  */
135 function wp_protect_special_option( $option ) {
136         if ( 'alloptions' === $option || 'notoptions' === $option )
137                 wp_die( sprintf( __( '%s is a protected WP option and may not be modified' ), esc_html( $option ) ) );
138 }
139
140 /**
141  * Print option value after sanitizing for forms.
142  *
143  * @since 1.5.0
144  *
145  * @param string $option Option name.
146  */
147 function form_option( $option ) {
148         echo esc_attr( get_option( $option ) );
149 }
150
151 /**
152  * Loads and caches all autoloaded options, if available or all options.
153  *
154  * @since 2.2.0
155  *
156  * @return array List of all options.
157  */
158 function wp_load_alloptions() {
159         global $wpdb;
160
161         if ( !defined( 'WP_INSTALLING' ) || !is_multisite() )
162                 $alloptions = wp_cache_get( 'alloptions', 'options' );
163         else
164                 $alloptions = false;
165
166         if ( !$alloptions ) {
167                 $suppress = $wpdb->suppress_errors();
168                 if ( !$alloptions_db = $wpdb->get_results( "SELECT option_name, option_value FROM $wpdb->options WHERE autoload = 'yes'" ) )
169                         $alloptions_db = $wpdb->get_results( "SELECT option_name, option_value FROM $wpdb->options" );
170                 $wpdb->suppress_errors($suppress);
171                 $alloptions = array();
172                 foreach ( (array) $alloptions_db as $o ) {
173                         $alloptions[$o->option_name] = $o->option_value;
174                 }
175                 if ( !defined( 'WP_INSTALLING' ) || !is_multisite() )
176                         wp_cache_add( 'alloptions', $alloptions, 'options' );
177         }
178
179         return $alloptions;
180 }
181
182 /**
183  * Loads and caches certain often requested site options if is_multisite() and a persistent cache is not being used.
184  *
185  * @since 3.0.0
186  *
187  * @param int $site_id Optional site ID for which to query the options. Defaults to the current site.
188  */
189 function wp_load_core_site_options( $site_id = null ) {
190         global $wpdb;
191
192         if ( !is_multisite() || wp_using_ext_object_cache() || defined( 'WP_INSTALLING' ) )
193                 return;
194
195         if ( empty($site_id) )
196                 $site_id = $wpdb->siteid;
197
198         $core_options = array('site_name', 'siteurl', 'active_sitewide_plugins', '_site_transient_timeout_theme_roots', '_site_transient_theme_roots', 'site_admins', 'can_compress_scripts', 'global_terms_enabled', 'ms_files_rewriting' );
199
200         $core_options_in = "'" . implode("', '", $core_options) . "'";
201         $options = $wpdb->get_results( $wpdb->prepare("SELECT meta_key, meta_value FROM $wpdb->sitemeta WHERE meta_key IN ($core_options_in) AND site_id = %d", $site_id) );
202
203         foreach ( $options as $option ) {
204                 $key = $option->meta_key;
205                 $cache_key = "{$site_id}:$key";
206                 $option->meta_value = maybe_unserialize( $option->meta_value );
207
208                 wp_cache_set( $cache_key, $option->meta_value, 'site-options' );
209         }
210 }
211
212 /**
213  * Update the value of an option that was already added.
214  *
215  * You do not need to serialize values. If the value needs to be serialized, then
216  * it will be serialized before it is inserted into the database. Remember,
217  * resources can not be serialized or added as an option.
218  *
219  * If the option does not exist, then the option will be added with the option
220  * value, but you will not be able to set whether it is autoloaded. If you want
221  * to set whether an option is autoloaded, then you need to use the add_option().
222  *
223  * @since 1.0.0
224  * @since 4.2.0 The `$autoload` parameter was added.
225  *
226  * @param string      $option   Option name. Expected to not be SQL-escaped.
227  * @param mixed       $value    Option value. Must be serializable if non-scalar. Expected to not be SQL-escaped.
228  * @param string|bool $autoload Optional. Whether to load the option when WordPress starts up. For existing options,
229  *                              `$autoload` can only be updated using `update_option()` if `$value` is also changed.
230  *                              Accepts 'yes' or true to enable, 'no' or false to disable. For non-existent options,
231  *                              the default value is 'yes'.
232  * @return bool False if value was not updated and true if value was updated.
233  */
234 function update_option( $option, $value, $autoload = null ) {
235         global $wpdb;
236
237         $option = trim($option);
238         if ( empty($option) )
239                 return false;
240
241         wp_protect_special_option( $option );
242
243         if ( is_object( $value ) )
244                 $value = clone $value;
245
246         $value = sanitize_option( $option, $value );
247         $old_value = get_option( $option );
248
249         /**
250          * Filter a specific option before its value is (maybe) serialized and updated.
251          *
252          * The dynamic portion of the hook name, `$option`, refers to the option name.
253          *
254          * @since 2.6.0
255          *
256          * @param mixed $value     The new, unserialized option value.
257          * @param mixed $old_value The old option value.
258          */
259         $value = apply_filters( 'pre_update_option_' . $option, $value, $old_value );
260
261         /**
262          * Filter an option before its value is (maybe) serialized and updated.
263          *
264          * @since 3.9.0
265          *
266          * @param mixed  $value     The new, unserialized option value.
267          * @param string $option    Name of the option.
268          * @param mixed  $old_value The old option value.
269          */
270         $value = apply_filters( 'pre_update_option', $value, $option, $old_value );
271
272         // If the new and old values are the same, no need to update.
273         if ( $value === $old_value )
274                 return false;
275
276         /** This filter is documented in wp-includes/option.php */
277         if ( apply_filters( 'default_option_' . $option, false ) === $old_value ) {
278                 // Default setting for new options is 'yes'.
279                 if ( null === $autoload ) {
280                         $autoload = 'yes';
281                 }
282
283                 return add_option( $option, $value, '', $autoload );
284         }
285
286         $serialized_value = maybe_serialize( $value );
287
288         /**
289          * Fires immediately before an option value is updated.
290          *
291          * @since 2.9.0
292          *
293          * @param string $option    Name of the option to update.
294          * @param mixed  $old_value The old option value.
295          * @param mixed  $value     The new option value.
296          */
297         do_action( 'update_option', $option, $old_value, $value );
298
299         $update_args = array(
300                 'option_value' => $serialized_value,
301         );
302
303         if ( null !== $autoload ) {
304                 $update_args['autoload'] = ( 'no' === $autoload || false === $autoload ) ? 'no' : 'yes';
305         }
306
307         $result = $wpdb->update( $wpdb->options, $update_args, array( 'option_name' => $option ) );
308         if ( ! $result )
309                 return false;
310
311         $notoptions = wp_cache_get( 'notoptions', 'options' );
312         if ( is_array( $notoptions ) && isset( $notoptions[$option] ) ) {
313                 unset( $notoptions[$option] );
314                 wp_cache_set( 'notoptions', $notoptions, 'options' );
315         }
316
317         if ( ! defined( 'WP_INSTALLING' ) ) {
318                 $alloptions = wp_load_alloptions();
319                 if ( isset( $alloptions[$option] ) ) {
320                         $alloptions[ $option ] = $serialized_value;
321                         wp_cache_set( 'alloptions', $alloptions, 'options' );
322                 } else {
323                         wp_cache_set( $option, $serialized_value, 'options' );
324                 }
325         }
326
327         /**
328          * Fires after the value of a specific option has been successfully updated.
329          *
330          * The dynamic portion of the hook name, `$option`, refers to the option name.
331          *
332          * @since 2.0.1
333          *
334          * @param mixed $old_value The old option value.
335          * @param mixed $value     The new option value.
336          */
337         do_action( "update_option_{$option}", $old_value, $value );
338
339         /**
340          * Fires after the value of an option has been successfully updated.
341          *
342          * @since 2.9.0
343          *
344          * @param string $option    Name of the updated option.
345          * @param mixed  $old_value The old option value.
346          * @param mixed  $value     The new option value.
347          */
348         do_action( 'updated_option', $option, $old_value, $value );
349         return true;
350 }
351
352 /**
353  * Add a new option.
354  *
355  * You do not need to serialize values. If the value needs to be serialized, then
356  * it will be serialized before it is inserted into the database. Remember,
357  * resources can not be serialized or added as an option.
358  *
359  * You can create options without values and then update the values later.
360  * Existing options will not be updated and checks are performed to ensure that you
361  * aren't adding a protected WordPress option. Care should be taken to not name
362  * options the same as the ones which are protected.
363  *
364  * @since 1.0.0
365  *
366  * @param string         $option      Name of option to add. Expected to not be SQL-escaped.
367  * @param mixed          $value       Optional. Option value. Must be serializable if non-scalar. Expected to not be SQL-escaped.
368  * @param string         $deprecated  Optional. Description. Not used anymore.
369  * @param string|bool    $autoload    Optional. Whether to load the option when WordPress starts up.
370  *                                    Default is enabled. Accepts 'no' to disable for legacy reasons.
371  * @return bool False if option was not added and true if option was added.
372  */
373 function add_option( $option, $value = '', $deprecated = '', $autoload = 'yes' ) {
374         global $wpdb;
375
376         if ( !empty( $deprecated ) )
377                 _deprecated_argument( __FUNCTION__, '2.3' );
378
379         $option = trim($option);
380         if ( empty($option) )
381                 return false;
382
383         wp_protect_special_option( $option );
384
385         if ( is_object($value) )
386                 $value = clone $value;
387
388         $value = sanitize_option( $option, $value );
389
390         // Make sure the option doesn't already exist. We can check the 'notoptions' cache before we ask for a db query
391         $notoptions = wp_cache_get( 'notoptions', 'options' );
392         if ( !is_array( $notoptions ) || !isset( $notoptions[$option] ) )
393                 /** This filter is documented in wp-includes/option.php */
394                 if ( apply_filters( 'default_option_' . $option, false ) !== get_option( $option ) )
395                         return false;
396
397         $serialized_value = maybe_serialize( $value );
398         $autoload = ( 'no' === $autoload || false === $autoload ) ? 'no' : 'yes';
399
400         /**
401          * Fires before an option is added.
402          *
403          * @since 2.9.0
404          *
405          * @param string $option Name of the option to add.
406          * @param mixed  $value  Value of the option.
407          */
408         do_action( 'add_option', $option, $value );
409
410         $result = $wpdb->query( $wpdb->prepare( "INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s) ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)", $option, $serialized_value, $autoload ) );
411         if ( ! $result )
412                 return false;
413
414         if ( ! defined( 'WP_INSTALLING' ) ) {
415                 if ( 'yes' == $autoload ) {
416                         $alloptions = wp_load_alloptions();
417                         $alloptions[ $option ] = $serialized_value;
418                         wp_cache_set( 'alloptions', $alloptions, 'options' );
419                 } else {
420                         wp_cache_set( $option, $serialized_value, 'options' );
421                 }
422         }
423
424         // This option exists now
425         $notoptions = wp_cache_get( 'notoptions', 'options' ); // yes, again... we need it to be fresh
426         if ( is_array( $notoptions ) && isset( $notoptions[$option] ) ) {
427                 unset( $notoptions[$option] );
428                 wp_cache_set( 'notoptions', $notoptions, 'options' );
429         }
430
431         /**
432          * Fires after a specific option has been added.
433          *
434          * The dynamic portion of the hook name, `$option`, refers to the option name.
435          *
436          * @since 2.5.0 As "add_option_{$name}"
437          * @since 3.0.0
438          *
439          * @param string $option Name of the option to add.
440          * @param mixed  $value  Value of the option.
441          */
442         do_action( "add_option_{$option}", $option, $value );
443
444         /**
445          * Fires after an option has been added.
446          *
447          * @since 2.9.0
448          *
449          * @param string $option Name of the added option.
450          * @param mixed  $value  Value of the option.
451          */
452         do_action( 'added_option', $option, $value );
453         return true;
454 }
455
456 /**
457  * Removes option by name. Prevents removal of protected WordPress options.
458  *
459  * @since 1.2.0
460  *
461  * @param string $option Name of option to remove. Expected to not be SQL-escaped.
462  * @return bool True, if option is successfully deleted. False on failure.
463  */
464 function delete_option( $option ) {
465         global $wpdb;
466
467         $option = trim( $option );
468         if ( empty( $option ) )
469                 return false;
470
471         wp_protect_special_option( $option );
472
473         // Get the ID, if no ID then return
474         $row = $wpdb->get_row( $wpdb->prepare( "SELECT autoload FROM $wpdb->options WHERE option_name = %s", $option ) );
475         if ( is_null( $row ) )
476                 return false;
477
478         /**
479          * Fires immediately before an option is deleted.
480          *
481          * @since 2.9.0
482          *
483          * @param string $option Name of the option to delete.
484          */
485         do_action( 'delete_option', $option );
486
487         $result = $wpdb->delete( $wpdb->options, array( 'option_name' => $option ) );
488         if ( ! defined( 'WP_INSTALLING' ) ) {
489                 if ( 'yes' == $row->autoload ) {
490                         $alloptions = wp_load_alloptions();
491                         if ( is_array( $alloptions ) && isset( $alloptions[$option] ) ) {
492                                 unset( $alloptions[$option] );
493                                 wp_cache_set( 'alloptions', $alloptions, 'options' );
494                         }
495                 } else {
496                         wp_cache_delete( $option, 'options' );
497                 }
498         }
499         if ( $result ) {
500
501                 /**
502                  * Fires after a specific option has been deleted.
503                  *
504                  * The dynamic portion of the hook name, `$option`, refers to the option name.
505                  *
506                  * @since 3.0.0
507                  *
508                  * @param string $option Name of the deleted option.
509                  */
510                 do_action( "delete_option_$option", $option );
511
512                 /**
513                  * Fires after an option has been deleted.
514                  *
515                  * @since 2.9.0
516                  *
517                  * @param string $option Name of the deleted option.
518                  */
519                 do_action( 'deleted_option', $option );
520                 return true;
521         }
522         return false;
523 }
524
525 /**
526  * Delete a transient.
527  *
528  * @since 2.8.0
529  *
530  * @param string $transient Transient name. Expected to not be SQL-escaped.
531  * @return bool true if successful, false otherwise
532  */
533 function delete_transient( $transient ) {
534
535         /**
536          * Fires immediately before a specific transient is deleted.
537          *
538          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
539          *
540          * @since 3.0.0
541          *
542          * @param string $transient Transient name.
543          */
544         do_action( 'delete_transient_' . $transient, $transient );
545
546         if ( wp_using_ext_object_cache() ) {
547                 $result = wp_cache_delete( $transient, 'transient' );
548         } else {
549                 $option_timeout = '_transient_timeout_' . $transient;
550                 $option = '_transient_' . $transient;
551                 $result = delete_option( $option );
552                 if ( $result )
553                         delete_option( $option_timeout );
554         }
555
556         if ( $result ) {
557
558                 /**
559                  * Fires after a transient is deleted.
560                  *
561                  * @since 3.0.0
562                  *
563                  * @param string $transient Deleted transient name.
564                  */
565                 do_action( 'deleted_transient', $transient );
566         }
567
568         return $result;
569 }
570
571 /**
572  * Get the value of a transient.
573  *
574  * If the transient does not exist, does not have a value, or has expired,
575  * then the return value will be false.
576  *
577  * @since 2.8.0
578  *
579  * @param string $transient Transient name. Expected to not be SQL-escaped.
580  * @return mixed Value of transient.
581  */
582 function get_transient( $transient ) {
583
584         /**
585          * Filter the value of an existing transient.
586          *
587          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
588          *
589          * Passing a truthy value to the filter will effectively short-circuit retrieval
590          * of the transient, returning the passed value instead.
591          *
592          * @since 2.8.0
593          *
594          * @param mixed $pre_transient The default value to return if the transient does not exist.
595          *                             Any value other than false will short-circuit the retrieval
596          *                             of the transient, and return the returned value.
597          */
598         $pre = apply_filters( 'pre_transient_' . $transient, false );
599         if ( false !== $pre )
600                 return $pre;
601
602         if ( wp_using_ext_object_cache() ) {
603                 $value = wp_cache_get( $transient, 'transient' );
604         } else {
605                 $transient_option = '_transient_' . $transient;
606                 if ( ! defined( 'WP_INSTALLING' ) ) {
607                         // If option is not in alloptions, it is not autoloaded and thus has a timeout
608                         $alloptions = wp_load_alloptions();
609                         if ( !isset( $alloptions[$transient_option] ) ) {
610                                 $transient_timeout = '_transient_timeout_' . $transient;
611                                 if ( get_option( $transient_timeout ) < time() ) {
612                                         delete_option( $transient_option  );
613                                         delete_option( $transient_timeout );
614                                         $value = false;
615                                 }
616                         }
617                 }
618
619                 if ( ! isset( $value ) )
620                         $value = get_option( $transient_option );
621         }
622
623         /**
624          * Filter an existing transient's value.
625          *
626          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
627          *
628          * @since 2.8.0
629          *
630          * @param mixed $value Value of transient.
631          */
632         return apply_filters( 'transient_' . $transient, $value );
633 }
634
635 /**
636  * Set/update the value of a transient.
637  *
638  * You do not need to serialize values. If the value needs to be serialized, then
639  * it will be serialized before it is set.
640  *
641  * @since 2.8.0
642  *
643  * @param string $transient  Transient name. Expected to not be SQL-escaped. Must be
644  *                           45 characters or fewer in length.
645  * @param mixed  $value      Transient value. Must be serializable if non-scalar.
646  *                           Expected to not be SQL-escaped.
647  * @param int    $expiration Optional. Time until expiration in seconds. Default 0.
648  * @return bool False if value was not set and true if value was set.
649  */
650 function set_transient( $transient, $value, $expiration = 0 ) {
651
652         $expiration = (int) $expiration;
653
654         /**
655          * Filter a specific transient before its value is set.
656          *
657          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
658          *
659          * @since 3.0.0
660          * @since 4.2.0 Added `$expiration` parameter.
661          *
662          * @param mixed $value      New value of transient.
663          * @param int   $expiration Time until expiration in seconds.
664          */
665         $value = apply_filters( 'pre_set_transient_' . $transient, $value, $expiration );
666
667         if ( wp_using_ext_object_cache() ) {
668                 $result = wp_cache_set( $transient, $value, 'transient', $expiration );
669         } else {
670                 $transient_timeout = '_transient_timeout_' . $transient;
671                 $transient = '_transient_' . $transient;
672                 if ( false === get_option( $transient ) ) {
673                         $autoload = 'yes';
674                         if ( $expiration ) {
675                                 $autoload = 'no';
676                                 add_option( $transient_timeout, time() + $expiration, '', 'no' );
677                         }
678                         $result = add_option( $transient, $value, '', $autoload );
679                 } else {
680                         // If expiration is requested, but the transient has no timeout option,
681                         // delete, then re-create transient rather than update.
682                         $update = true;
683                         if ( $expiration ) {
684                                 if ( false === get_option( $transient_timeout ) ) {
685                                         delete_option( $transient );
686                                         add_option( $transient_timeout, time() + $expiration, '', 'no' );
687                                         $result = add_option( $transient, $value, '', 'no' );
688                                         $update = false;
689                                 } else {
690                                         update_option( $transient_timeout, time() + $expiration );
691                                 }
692                         }
693                         if ( $update ) {
694                                 $result = update_option( $transient, $value );
695                         }
696                 }
697         }
698
699         if ( $result ) {
700
701                 /**
702                  * Fires after the value for a specific transient has been set.
703                  *
704                  * The dynamic portion of the hook name, `$transient`, refers to the transient name.
705                  *
706                  * @since 3.0.0
707                  *
708                  * @param mixed $value      Transient value.
709                  * @param int   $expiration Time until expiration in seconds. Default 0.
710                  */
711                 do_action( 'set_transient_' . $transient, $value, $expiration );
712
713                 /**
714                  * Fires after the value for a transient has been set.
715                  *
716                  * @since 3.0.0
717                  *
718                  * @param string $transient  The name of the transient.
719                  * @param mixed  $value      Transient value.
720                  * @param int    $expiration Time until expiration in seconds. Default 0.
721                  */
722                 do_action( 'setted_transient', $transient, $value, $expiration );
723         }
724         return $result;
725 }
726
727 /**
728  * Saves and restores user interface settings stored in a cookie.
729  *
730  * Checks if the current user-settings cookie is updated and stores it. When no
731  * cookie exists (different browser used), adds the last saved cookie restoring
732  * the settings.
733  *
734  * @since 2.7.0
735  */
736 function wp_user_settings() {
737
738         if ( ! is_admin() || defined( 'DOING_AJAX' ) ) {
739                 return;
740         }
741
742         if ( ! $user_id = get_current_user_id() ) {
743                 return;
744         }
745
746         if ( is_super_admin() && ! is_user_member_of_blog() ) {
747                 return;
748         }
749
750         $settings = (string) get_user_option( 'user-settings', $user_id );
751
752         if ( isset( $_COOKIE['wp-settings-' . $user_id] ) ) {
753                 $cookie = preg_replace( '/[^A-Za-z0-9=&_]/', '', $_COOKIE['wp-settings-' . $user_id] );
754
755                 // No change or both empty
756                 if ( $cookie == $settings )
757                         return;
758
759                 $last_saved = (int) get_user_option( 'user-settings-time', $user_id );
760                 $current = isset( $_COOKIE['wp-settings-time-' . $user_id]) ? preg_replace( '/[^0-9]/', '', $_COOKIE['wp-settings-time-' . $user_id] ) : 0;
761
762                 // The cookie is newer than the saved value. Update the user_option and leave the cookie as-is
763                 if ( $current > $last_saved ) {
764                         update_user_option( $user_id, 'user-settings', $cookie, false );
765                         update_user_option( $user_id, 'user-settings-time', time() - 5, false );
766                         return;
767                 }
768         }
769
770         // The cookie is not set in the current browser or the saved value is newer.
771         $secure = ( 'https' === parse_url( site_url(), PHP_URL_SCHEME ) );
772         setcookie( 'wp-settings-' . $user_id, $settings, time() + YEAR_IN_SECONDS, SITECOOKIEPATH, null, $secure );
773         setcookie( 'wp-settings-time-' . $user_id, time(), time() + YEAR_IN_SECONDS, SITECOOKIEPATH, null, $secure );
774         $_COOKIE['wp-settings-' . $user_id] = $settings;
775 }
776
777 /**
778  * Retrieve user interface setting value based on setting name.
779  *
780  * @since 2.7.0
781  *
782  * @param string $name The name of the setting.
783  * @param string $default Optional default value to return when $name is not set.
784  * @return mixed the last saved user setting or the default value/false if it doesn't exist.
785  */
786 function get_user_setting( $name, $default = false ) {
787         $all_user_settings = get_all_user_settings();
788
789         return isset( $all_user_settings[$name] ) ? $all_user_settings[$name] : $default;
790 }
791
792 /**
793  * Add or update user interface setting.
794  *
795  * Both $name and $value can contain only ASCII letters, numbers and underscores.
796  * This function has to be used before any output has started as it calls setcookie().
797  *
798  * @since 2.8.0
799  *
800  * @param string $name The name of the setting.
801  * @param string $value The value for the setting.
802  * @return null|bool true if set successfully/false if not.
803  */
804 function set_user_setting( $name, $value ) {
805
806         if ( headers_sent() ) {
807                 return false;
808         }
809
810         $all_user_settings = get_all_user_settings();
811         $all_user_settings[$name] = $value;
812
813         return wp_set_all_user_settings( $all_user_settings );
814 }
815
816 /**
817  * Delete user interface settings.
818  *
819  * Deleting settings would reset them to the defaults.
820  * This function has to be used before any output has started as it calls setcookie().
821  *
822  * @since 2.7.0
823  *
824  * @param string $names The name or array of names of the setting to be deleted.
825  * @return null|bool true if deleted successfully/false if not.
826  */
827 function delete_user_setting( $names ) {
828
829         if ( headers_sent() ) {
830                 return false;
831         }
832
833         $all_user_settings = get_all_user_settings();
834         $names = (array) $names;
835         $deleted = false;
836
837         foreach ( $names as $name ) {
838                 if ( isset( $all_user_settings[$name] ) ) {
839                         unset( $all_user_settings[$name] );
840                         $deleted = true;
841                 }
842         }
843
844         if ( $deleted ) {
845                 return wp_set_all_user_settings( $all_user_settings );
846         }
847
848         return false;
849 }
850
851 /**
852  * Retrieve all user interface settings.
853  *
854  * @since 2.7.0
855  *
856  * @return array the last saved user settings or empty array.
857  */
858 function get_all_user_settings() {
859         global $_updated_user_settings;
860
861         if ( ! $user_id = get_current_user_id() ) {
862                 return array();
863         }
864
865         if ( isset( $_updated_user_settings ) && is_array( $_updated_user_settings ) ) {
866                 return $_updated_user_settings;
867         }
868
869         $user_settings = array();
870
871         if ( isset( $_COOKIE['wp-settings-' . $user_id] ) ) {
872                 $cookie = preg_replace( '/[^A-Za-z0-9=&_]/', '', $_COOKIE['wp-settings-' . $user_id] );
873
874                 if ( strpos( $cookie, '=' ) ) { // '=' cannot be 1st char
875                         parse_str( $cookie, $user_settings );
876                 }
877         } else {
878                 $option = get_user_option( 'user-settings', $user_id );
879
880                 if ( $option && is_string( $option ) ) {
881                         parse_str( $option, $user_settings );
882                 }
883         }
884
885         $_updated_user_settings = $user_settings;
886         return $user_settings;
887 }
888
889 /**
890  * Private. Set all user interface settings.
891  *
892  * @since 2.8.0
893  *
894  * @param array $user_settings
895  * @return null|bool
896  */
897 function wp_set_all_user_settings( $user_settings ) {
898         global $_updated_user_settings;
899
900         if ( ! $user_id = get_current_user_id() ) {
901                 return false;
902         }
903
904         if ( is_super_admin() && ! is_user_member_of_blog() ) {
905                 return;
906         }
907
908         $settings = '';
909         foreach ( $user_settings as $name => $value ) {
910                 $_name = preg_replace( '/[^A-Za-z0-9_]+/', '', $name );
911                 $_value = preg_replace( '/[^A-Za-z0-9_]+/', '', $value );
912
913                 if ( ! empty( $_name ) ) {
914                         $settings .= $_name . '=' . $_value . '&';
915                 }
916         }
917
918         $settings = rtrim( $settings, '&' );
919         parse_str( $settings, $_updated_user_settings );
920
921         update_user_option( $user_id, 'user-settings', $settings, false );
922         update_user_option( $user_id, 'user-settings-time', time(), false );
923
924         return true;
925 }
926
927 /**
928  * Delete the user settings of the current user.
929  *
930  * @since 2.7.0
931  */
932 function delete_all_user_settings() {
933         if ( ! $user_id = get_current_user_id() ) {
934                 return;
935         }
936
937         update_user_option( $user_id, 'user-settings', '', false );
938         setcookie( 'wp-settings-' . $user_id, ' ', time() - YEAR_IN_SECONDS, SITECOOKIEPATH );
939 }
940
941 /**
942  * Retrieve site option value based on name of option.
943  *
944  * @since 2.8.0
945  *
946  * @see get_option()
947  *
948  * @param string $option Name of option to retrieve. Expected to not be SQL-escaped.
949  * @param mixed $default Optional value to return if option doesn't exist. Default false.
950  * @param bool $use_cache Whether to use cache. Multisite only. Default true.
951  * @return mixed Value set for the option.
952  */
953 function get_site_option( $option, $default = false, $use_cache = true ) {
954         global $wpdb;
955
956         /**
957          * Filter an existing site option before it is retrieved.
958          *
959          * The dynamic portion of the hook name, `$option`, refers to the option name.
960          *
961          * Passing a truthy value to the filter will effectively short-circuit retrieval,
962          * returning the passed value instead.
963          *
964          * @since 2.9.0 As 'pre_site_option_' . $key
965          * @since 3.0.0
966          *
967          * @param mixed $pre_option The default value to return if the option does not exist.
968          */
969         $pre = apply_filters( 'pre_site_option_' . $option, false );
970
971         if ( false !== $pre )
972                 return $pre;
973
974         // prevent non-existent options from triggering multiple queries
975         $notoptions_key = "{$wpdb->siteid}:notoptions";
976         $notoptions = wp_cache_get( $notoptions_key, 'site-options' );
977
978         if ( isset( $notoptions[$option] ) ) {
979
980                 /**
981                  * Filter a specific default site option.
982                  *
983                  * The dynamic portion of the hook name, `$option`, refers to the option name.
984                  *
985                  * @since 3.4.0
986                  *
987                  * @param mixed $default The value to return if the site option does not exist
988                  *                       in the database.
989                  */
990                 return apply_filters( 'default_site_option_' . $option, $default );
991         }
992
993         if ( ! is_multisite() ) {
994
995                 /** This filter is documented in wp-includes/option.php */
996                 $default = apply_filters( 'default_site_option_' . $option, $default );
997                 $value = get_option($option, $default);
998         } else {
999                 $cache_key = "{$wpdb->siteid}:$option";
1000                 if ( $use_cache )
1001                         $value = wp_cache_get($cache_key, 'site-options');
1002
1003                 if ( !isset($value) || (false === $value) ) {
1004                         $row = $wpdb->get_row( $wpdb->prepare("SELECT meta_value FROM $wpdb->sitemeta WHERE meta_key = %s AND site_id = %d", $option, $wpdb->siteid ) );
1005
1006                         // Has to be get_row instead of get_var because of funkiness with 0, false, null values
1007                         if ( is_object( $row ) ) {
1008                                 $value = $row->meta_value;
1009                                 $value = maybe_unserialize( $value );
1010                                 wp_cache_set( $cache_key, $value, 'site-options' );
1011                         } else {
1012                                 $notoptions[$option] = true;
1013                                 wp_cache_set( $notoptions_key, $notoptions, 'site-options' );
1014
1015                                 /** This filter is documented in wp-includes/option.php */
1016                                 $value = apply_filters( 'default_site_option_' . $option, $default );
1017                         }
1018                 }
1019         }
1020
1021         /**
1022          * Filter the value of an existing site option.
1023          *
1024          * The dynamic portion of the hook name, `$option`, refers to the option name.
1025          *
1026          * @since 2.9.0 As 'site_option_' . $key
1027          * @since 3.0.0
1028          *
1029          * @param mixed $value Value of site option.
1030          */
1031         return apply_filters( 'site_option_' . $option, $value );
1032 }
1033
1034 /**
1035  * Add a new site option.
1036  *
1037  * Existing options will not be updated. Note that prior to 3.3 this wasn't the case.
1038  *
1039  * @since 2.8.0
1040  *
1041  * @see add_option()
1042  *
1043  * @param string $option Name of option to add. Expected to not be SQL-escaped.
1044  * @param mixed $value Optional. Option value, can be anything. Expected to not be SQL-escaped.
1045  * @return bool False if option was not added and true if option was added.
1046  */
1047 function add_site_option( $option, $value ) {
1048         global $wpdb;
1049
1050         wp_protect_special_option( $option );
1051
1052         /**
1053          * Filter the value of a specific site option before it is added.
1054          *
1055          * The dynamic portion of the hook name, `$option`, refers to the option name.
1056          *
1057          * @since 2.9.0 As 'pre_add_site_option_' . $key
1058          * @since 3.0.0
1059          *
1060          * @param mixed $value Value of site option.
1061          */
1062         $value = apply_filters( 'pre_add_site_option_' . $option, $value );
1063
1064         $notoptions_key = "{$wpdb->siteid}:notoptions";
1065
1066         if ( !is_multisite() ) {
1067                 $result = add_option( $option, $value );
1068         } else {
1069                 $cache_key = "{$wpdb->siteid}:$option";
1070
1071                 // Make sure the option doesn't already exist. We can check the 'notoptions' cache before we ask for a db query
1072                 $notoptions = wp_cache_get( $notoptions_key, 'site-options' );
1073                 if ( ! is_array( $notoptions ) || ! isset( $notoptions[$option] ) )
1074                         if ( false !== get_site_option( $option ) )
1075                                 return false;
1076
1077                 $value = sanitize_option( $option, $value );
1078
1079                 $serialized_value = maybe_serialize( $value );
1080                 $result = $wpdb->insert( $wpdb->sitemeta, array('site_id' => $wpdb->siteid, 'meta_key' => $option, 'meta_value' => $serialized_value ) );
1081
1082                 if ( ! $result )
1083                         return false;
1084
1085                 wp_cache_set( $cache_key, $value, 'site-options' );
1086
1087                 // This option exists now
1088                 $notoptions = wp_cache_get( $notoptions_key, 'site-options' ); // yes, again... we need it to be fresh
1089                 if ( is_array( $notoptions ) && isset( $notoptions[$option] ) ) {
1090                         unset( $notoptions[$option] );
1091                         wp_cache_set( $notoptions_key, $notoptions, 'site-options' );
1092                 }
1093         }
1094
1095         if ( $result ) {
1096
1097                 /**
1098                  * Fires after a specific site option has been successfully added.
1099                  *
1100                  * The dynamic portion of the hook name, `$option`, refers to the option name.
1101                  *
1102                  * @since 2.9.0 As "add_site_option_{$key}"
1103                  * @since 3.0.0
1104                  *
1105                  * @param string $option Name of site option.
1106                  * @param mixed  $value  Value of site option.
1107                  */
1108                 do_action( "add_site_option_{$option}", $option, $value );
1109
1110                 /**
1111                  * Fires after a site option has been successfully added.
1112                  *
1113                  * @since 3.0.0
1114                  *
1115                  * @param string $option Name of site option.
1116                  * @param mixed  $value  Value of site option.
1117                  */
1118                 do_action( "add_site_option", $option, $value );
1119
1120                 return true;
1121         }
1122         return false;
1123 }
1124
1125 /**
1126  * Removes site option by name.
1127  *
1128  * @since 2.8.0
1129  *
1130  * @see delete_option()
1131  *
1132  * @param string $option Name of option to remove. Expected to not be SQL-escaped.
1133  * @return bool True, if succeed. False, if failure.
1134  */
1135 function delete_site_option( $option ) {
1136         global $wpdb;
1137
1138         // ms_protect_special_option( $option ); @todo
1139
1140         /**
1141          * Fires immediately before a specific site option is deleted.
1142          *
1143          * The dynamic portion of the hook name, `$option`, refers to the option name.
1144          *
1145          * @since 3.0.0
1146          */
1147         do_action( 'pre_delete_site_option_' . $option );
1148
1149         if ( !is_multisite() ) {
1150                 $result = delete_option( $option );
1151         } else {
1152                 $row = $wpdb->get_row( $wpdb->prepare( "SELECT meta_id FROM {$wpdb->sitemeta} WHERE meta_key = %s AND site_id = %d", $option, $wpdb->siteid ) );
1153                 if ( is_null( $row ) || !$row->meta_id )
1154                         return false;
1155                 $cache_key = "{$wpdb->siteid}:$option";
1156                 wp_cache_delete( $cache_key, 'site-options' );
1157
1158                 $result = $wpdb->delete( $wpdb->sitemeta, array( 'meta_key' => $option, 'site_id' => $wpdb->siteid ) );
1159         }
1160
1161         if ( $result ) {
1162
1163                 /**
1164                  * Fires after a specific site option has been deleted.
1165                  *
1166                  * The dynamic portion of the hook name, `$option`, refers to the option name.
1167                  *
1168                  * @since 2.9.0 As "delete_site_option_{$key}"
1169                  * @since 3.0.0
1170                  *
1171                  * @param string $option Name of the site option.
1172                  */
1173                 do_action( "delete_site_option_{$option}", $option );
1174
1175                 /**
1176                  * Fires after a site option has been deleted.
1177                  *
1178                  * @since 3.0.0
1179                  *
1180                  * @param string $option Name of the site option.
1181                  */
1182                 do_action( "delete_site_option", $option );
1183
1184                 return true;
1185         }
1186         return false;
1187 }
1188
1189 /**
1190  * Update the value of a site option that was already added.
1191  *
1192  * @since 2.8.0
1193  *
1194  * @see update_option()
1195  *
1196  * @param string $option Name of option. Expected to not be SQL-escaped.
1197  * @param mixed $value Option value. Expected to not be SQL-escaped.
1198  * @return bool False if value was not updated and true if value was updated.
1199  */
1200 function update_site_option( $option, $value ) {
1201         global $wpdb;
1202
1203         wp_protect_special_option( $option );
1204
1205         $old_value = get_site_option( $option );
1206
1207         /**
1208          * Filter a specific site option before its value is updated.
1209          *
1210          * The dynamic portion of the hook name, `$option`, refers to the option name.
1211          *
1212          * @since 2.9.0 As 'pre_update_site_option_' . $key
1213          * @since 3.0.0
1214          *
1215          * @param mixed $value     New value of site option.
1216          * @param mixed $old_value Old value of site option.
1217          */
1218         $value = apply_filters( 'pre_update_site_option_' . $option, $value, $old_value );
1219
1220         if ( $value === $old_value )
1221                 return false;
1222
1223         if ( false === $old_value )
1224                 return add_site_option( $option, $value );
1225
1226         $notoptions_key = "{$wpdb->siteid}:notoptions";
1227         $notoptions = wp_cache_get( $notoptions_key, 'site-options' );
1228         if ( is_array( $notoptions ) && isset( $notoptions[$option] ) ) {
1229                 unset( $notoptions[$option] );
1230                 wp_cache_set( $notoptions_key, $notoptions, 'site-options' );
1231         }
1232
1233         if ( !is_multisite() ) {
1234                 $result = update_option( $option, $value );
1235         } else {
1236                 $value = sanitize_option( $option, $value );
1237
1238                 $serialized_value = maybe_serialize( $value );
1239                 $result = $wpdb->update( $wpdb->sitemeta, array( 'meta_value' => $serialized_value ), array( 'site_id' => $wpdb->siteid, 'meta_key' => $option ) );
1240
1241                 if ( $result ) {
1242                         $cache_key = "{$wpdb->siteid}:$option";
1243                         wp_cache_set( $cache_key, $value, 'site-options' );
1244                 }
1245         }
1246
1247         if ( $result ) {
1248
1249                 /**
1250                  * Fires after the value of a specific site option has been successfully updated.
1251                  *
1252                  * The dynamic portion of the hook name, `$option`, refers to the option name.
1253                  *
1254                  * @since 2.9.0 As "update_site_option_{$key}"
1255                  * @since 3.0.0
1256                  *
1257                  * @param string $option    Name of site option.
1258                  * @param mixed  $value     Current value of site option.
1259                  * @param mixed  $old_value Old value of site option.
1260                  */
1261                 do_action( "update_site_option_{$option}", $option, $value, $old_value );
1262
1263                 /**
1264                  * Fires after the value of a site option has been successfully updated.
1265                  *
1266                  * @since 3.0.0
1267                  *
1268                  * @param string $option    Name of site option.
1269                  * @param mixed  $value     Current value of site option.
1270                  * @param mixed  $old_value Old value of site option.
1271                  */
1272                 do_action( "update_site_option", $option, $value, $old_value );
1273
1274                 return true;
1275         }
1276         return false;
1277 }
1278
1279 /**
1280  * Delete a site transient.
1281  *
1282  * @since 2.9.0
1283  *
1284  * @param string $transient Transient name. Expected to not be SQL-escaped.
1285  * @return bool True if successful, false otherwise
1286  */
1287 function delete_site_transient( $transient ) {
1288
1289         /**
1290          * Fires immediately before a specific site transient is deleted.
1291          *
1292          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
1293          *
1294          * @since 3.0.0
1295          *
1296          * @param string $transient Transient name.
1297          */
1298         do_action( 'delete_site_transient_' . $transient, $transient );
1299
1300         if ( wp_using_ext_object_cache() ) {
1301                 $result = wp_cache_delete( $transient, 'site-transient' );
1302         } else {
1303                 $option_timeout = '_site_transient_timeout_' . $transient;
1304                 $option = '_site_transient_' . $transient;
1305                 $result = delete_site_option( $option );
1306                 if ( $result )
1307                         delete_site_option( $option_timeout );
1308         }
1309         if ( $result ) {
1310
1311                 /**
1312                  * Fires after a transient is deleted.
1313                  *
1314                  * @since 3.0.0
1315                  *
1316                  * @param string $transient Deleted transient name.
1317                  */
1318                 do_action( 'deleted_site_transient', $transient );
1319         }
1320
1321         return $result;
1322 }
1323
1324 /**
1325  * Get the value of a site transient.
1326  *
1327  * If the transient does not exist, does not have a value, or has expired,
1328  * then the return value will be false.
1329  *
1330  * @since 2.9.0
1331  *
1332  * @see get_transient()
1333  *
1334  * @param string $transient Transient name. Expected to not be SQL-escaped.
1335  * @return mixed Value of transient.
1336  */
1337 function get_site_transient( $transient ) {
1338
1339         /**
1340          * Filter the value of an existing site transient.
1341          *
1342          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
1343          *
1344          * Passing a truthy value to the filter will effectively short-circuit retrieval,
1345          * returning the passed value instead.
1346          *
1347          * @since 2.9.0
1348          *
1349          * @param mixed $pre_site_transient The default value to return if the site transient does not exist.
1350          *                                  Any value other than false will short-circuit the retrieval
1351          *                                  of the transient, and return the returned value.
1352          */
1353         $pre = apply_filters( 'pre_site_transient_' . $transient, false );
1354
1355         if ( false !== $pre )
1356                 return $pre;
1357
1358         if ( wp_using_ext_object_cache() ) {
1359                 $value = wp_cache_get( $transient, 'site-transient' );
1360         } else {
1361                 // Core transients that do not have a timeout. Listed here so querying timeouts can be avoided.
1362                 $no_timeout = array('update_core', 'update_plugins', 'update_themes');
1363                 $transient_option = '_site_transient_' . $transient;
1364                 if ( ! in_array( $transient, $no_timeout ) ) {
1365                         $transient_timeout = '_site_transient_timeout_' . $transient;
1366                         $timeout = get_site_option( $transient_timeout );
1367                         if ( false !== $timeout && $timeout < time() ) {
1368                                 delete_site_option( $transient_option  );
1369                                 delete_site_option( $transient_timeout );
1370                                 $value = false;
1371                         }
1372                 }
1373
1374                 if ( ! isset( $value ) )
1375                         $value = get_site_option( $transient_option );
1376         }
1377
1378         /**
1379          * Filter the value of an existing site transient.
1380          *
1381          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
1382          *
1383          * @since 2.9.0
1384          *
1385          * @param mixed $value Value of site transient.
1386          */
1387         return apply_filters( 'site_transient_' . $transient, $value );
1388 }
1389
1390 /**
1391  * Set/update the value of a site transient.
1392  *
1393  * You do not need to serialize values, if the value needs to be serialize, then
1394  * it will be serialized before it is set.
1395  *
1396  * @since 2.9.0
1397  *
1398  * @see set_transient()
1399  *
1400  * @param string $transient  Transient name. Expected to not be SQL-escaped. Must be
1401  *                           40 characters or fewer in length.
1402  * @param mixed  $value      Transient value. Expected to not be SQL-escaped.
1403  * @param int    $expiration Optional. Time until expiration in seconds. Default 0.
1404  * @return bool False if value was not set and true if value was set.
1405  */
1406 function set_site_transient( $transient, $value, $expiration = 0 ) {
1407
1408         /**
1409          * Filter the value of a specific site transient before it is set.
1410          *
1411          * The dynamic portion of the hook name, `$transient`, refers to the transient name.
1412          *
1413          * @since 3.0.0
1414          *
1415          * @param mixed $value Value of site transient.
1416          */
1417         $value = apply_filters( 'pre_set_site_transient_' . $transient, $value );
1418
1419         $expiration = (int) $expiration;
1420
1421         if ( wp_using_ext_object_cache() ) {
1422                 $result = wp_cache_set( $transient, $value, 'site-transient', $expiration );
1423         } else {
1424                 $transient_timeout = '_site_transient_timeout_' . $transient;
1425                 $option = '_site_transient_' . $transient;
1426                 if ( false === get_site_option( $option ) ) {
1427                         if ( $expiration )
1428                                 add_site_option( $transient_timeout, time() + $expiration );
1429                         $result = add_site_option( $option, $value );
1430                 } else {
1431                         if ( $expiration )
1432                                 update_site_option( $transient_timeout, time() + $expiration );
1433                         $result = update_site_option( $option, $value );
1434                 }
1435         }
1436         if ( $result ) {
1437
1438                 /**
1439                  * Fires after the value for a specific site transient has been set.
1440                  *
1441                  * The dynamic portion of the hook name, `$transient`, refers to the transient name.
1442                  *
1443                  * @since 3.0.0
1444                  *
1445                  * @param mixed $value      Site transient value.
1446                  * @param int   $expiration Time until expiration in seconds. Default 0.
1447                  */
1448                 do_action( 'set_site_transient_' . $transient, $value, $expiration );
1449
1450                 /**
1451                  * Fires after the value for a site transient has been set.
1452                  *
1453                  * @since 3.0.0
1454                  *
1455                  * @param string $transient  The name of the site transient.
1456                  * @param mixed  $value      Site transient value.
1457                  * @param int    $expiration Time until expiration in seconds. Default 0.
1458                  */
1459                 do_action( 'setted_site_transient', $transient, $value, $expiration );
1460         }
1461         return $result;
1462 }