Letou nhà cái đánh giá

Let’s take a look at how WordPress handles it

Let’s take a look at how WordPress handles it

Want to get more articles like this one.
Join my newsletter WordPress for the adventurous: Entry points.
To master WordPress, you have to be able to look at it from unusual perspectives.
It’s exploring these perspectives that gives you that next level understanding.
You’re able to view problems from another angle.
This can give you unique insights that affect how you approach problems and design solutions for WordPress.
The angle we’re going to explore in this article is the concept of the entry point.
Let’s take a look at how WordPress handles it.
What is an entry point?.
The entry point is the piece of code that controls the entry to a program or a larger piece of code.
It could be a function.
It could be a file that’s read from top to bottom.
Each language has its own take on the concept of the entry point.
In PHP, the entry point is always the first file that the web server accesses.
It reads it from top to bottom and executed in that order.
The web server configuration determines the PHP entry point.
You could limit to a single file or it could be any file accessed directly.
That flexibility is also a weakness when you’re trying to secure a PHP application.
In the context of WordPress, .

An entry point is a PHP file that initiates the loading of WordPress

WordPress has a surprising amount of entry points

A lot of them exist to handle specific tasks which you’ll see later.
It’s all about security.

WordPress entry points are a potential security vulnerability

Some entry point vulnerabilities are with PHP and your web server configuration.
That’s why a lot of WordPress hardening recommendations are about securing the files on your server.

You want to make sure that you limit the access to WordPress files

Some WordPress security issues are deliberate attempts to abuse these entry points and your lack of understanding about them.
Hackers can use them for brute-force attacks like the ones you see on “wp-login.php” or “xmlrpc.php”.
These attacks are attempts to gain access to your admin console.

WordPress entry points are also vulnerable to denial-of-service attacks

Each individual entry point is vulnerable to those attacks.
A lot of these issues come from a simple lack of knowledge.

It’s not that WordPress itself isn’t secure

It’s that you can’t take extra steps to secure what you don’t know about.
Going over entry points.
The goal here isn’t to bore you with an extensive list of entry points.
You can find most of them by searching WordPress for files that require “wp-load.php” or “admin.php”.

Those are the bootstrap files for the frontend and the admin of WordPress

There’s some exceptions to that rule like “xmlrpc.php”.
That said, you’ll get a good overview using those two search parameters.
The default entry points.
The default entry points to WordPress are the “index.php” files.
This isn’t by accident.
The WordPress server configuration says that the default file for PHP to process is “index.php”.
Your server uses that default file when it doesn’t receive a request for a file.
It doesn’t have to be a PHP file.
It could be any file.
So let’s say you’re requesting “/wp-admin”.
Your browser address bar isn’t pointing to a file.
That means you’re using “index.php” in the “wp-admin” folder as the entry point.
Simple as that.
“index.php” files are powerful for that reason.
That’s why it’s always a good idea to put an empty “index.php” file in your plugins.
You can leave it empty or add the well known “Silence is golden.” inside.
Task based entry points.
WordPress uses a lot of entry points for tasks.
That’s where it gets a bit hairy.
There’s a lot of tasks and each has its own entry point.
That’s why listing them isn’t useful to you.
What’s more interesting is the types of tasks that these entry points take care of.
Cron.
Good old WordPress cron… The internet contains countless threads of WordPress cron not running, missed schedule errors and other issues.
The goal was to offer a way to schedule jobs for installations that couldn’t control the cron jobs on their server.
WordPress implements cron using a custom entry point.
Whenever someone loads a page, WordPress will send an asynchronous request to “wp-cron.php”.
“wp-cron.php” checks for scheduled cron jobs and runs them.
The issue is that you need someone to visit your site for WordPress cron to run.
This isn’t consistent.
That’s where understanding that entry point interaction was useful.
The solution to the issue was to create a server level cron job to run “wp-cron.php”.
This guaranteed that WordPress cron jobs would run at a regular interval.
Using the Upgrade API.
Upgrade API you say.

WordPress has an API for dealing with installing and upgrading WordPress

It’s found in the “wp-admin/includes/upgrade.php”.

The API contains functions like “wp_install” for installing a WordPress blog

It also has useful helper functions for interacting with the MySQL database.
One of them is “dbDelta”.
You use it when you want to maintain a database table with your plugin.
The API isn’t loaded by default.
Only special entry points that deal with installing and upgrading WordPress use it.
That includes the network install as well.
Admin pages.
Each WordPress admin page is an entry point.
There’s over 70 of admin pages in WordPress if you include all the network ones.
That makes for a ridiculous amount of entry points.
Why are each of them an entry point.
That’s a question I wasn’t able to find an answer to.
There’s an API for administration menus.
WordPress core doesn’t seem to use it though.
Regardless, this is why it’s important to take extra care to secure “/wp-admin”.
Compromising any of these files would compromise your WordPress installation.
External interactions.
There’s entry points dedicated to communicating with WordPress.
These include systems like: XML-RPC.
Post via Email.
Trackbacks.
AJAX.
Commenting.
The noteworthy one is XML-RPC.
It’s used by almost every app or service that interacts with WordPress.
The unique issue with it is that you need to log into WordPress for each call made to the XML-RPC API.
There’s no cookie that WordPress can use to keep you authenticated.
So for every command, your username and password is sent in plain text to your WordPress site.
That makes you vulnerable to man-in-the-middle attacks.

That’s unless you use a SSL certificate on your WordPress site

Authentication layer.
WordPress uses a few entry points for its authentication layer.
The most known is “wp-login.php” which is the WordPress login page.
There’s also “wp-activate.php” and “wp-signup.php” when you enable user registration.
These entry points (“wp-login.php” usually) are often the target of brute-force attacks.
That’s why there’s a lot of plugins to deal with this issue.
You can also protect “wp-login.php” at the web server level to help with the issue.
Another way to look at WordPress security.
It’s often misunderstood how WordPress security works.
You follow a list of recommendations and don’t twice about it.
Looking at WordPress entry points can help you make sense of some of these recommendations.
It’s all about that other angle.
Sometimes looking at things from another angle can give you the understanding you need.
Tweet.
#Entry Point # #WordPress for the Adventurous Designing a class: WordPress AJAX handler Spying on WordPress with the proxy pattern.


we’re sure that post implements WP_Post_Interface

Want to learn object-oriented programmming.
Get my free course Using inheritance with WordPress.
As a WordPress developer, you’re always looking for ways to better reuse your code between projects.
Your time is valuable and you don’t want to reinvent the wheel each time you start a new project.
Object-oriented programming can help you with that.
In a previous post, I covered why you should learn it.
Now it’s time to take things further by going over the main feature for code reuse.
You’ve probably heard about it before.
It’s called “inheritance“.
Inheritance, what’s that?.
Inheritance is about maximizing the code reuse between your classes.
It allows you to create a hierarchy between your classes.
That hierarchy creates a “is-a” relationship between your classes.
That’s why a lot of examples follow the formula: class Car extends Vehicle (Car is a Vehicle).
class Dog extends Animal (Dog is an Animal).
They aren’t practical examples, but they highlight that relationship.
The take away from those examples is that you need to learn to see the relationship between your classes.
Once that happens, you’ll be able to leverage inheritance to create reusable code for your projects.
Visibility revisited.
When I covered encapsulation, I mentioned three possible access levels for properties and methods.
Public.
Private.
Protected.
“Public” meant that anyone could access the property or method.
Meanwhile, “Private” meant the opposite.
You could only access it internally.
It’s time to flesh out those definitions a bit more.
When using inheritance, defining a property or method as private restricts it to the class that defined it.
Its children can’t access it.
Meanwhile, protected grants access to the entire class hierarchy.
This means that child classes can access it.
The inheritance toolkit.
Before going ahead with a practical example, let’s go over some of the tools that you can use with inheritance.
A good understanding of that toolkit will allow you to leverage inheritance to its full potential.
Interfaces.
Interfaces are the most basic tool in your inventory.
You should see an interface as a contract.
By implementing an interface, your class agrees to implement specific methods.
You can only define public methods in an interface.
By only offering a contract, you let others worry about the implementation.
All that you care about is that the methods in your contract exist.
Let’s look at a small example.
interface Post_Interface { /** * Get the CSS class.
* * @return string */ public function get_class(); /** * Get the post type.
* * @return string */ public function get_type(); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 interface Post_Interface      * Get the CSS class.
get_class        * Get the post type.
get_type The Post_Interface represents a small contract for WordPress posts.
It has two methods: get_class and get_type.
Any class that implements Post_Interface will need to have these methods.
Built-in PHP interfaces.
PHP is full of useful interfaces that you can use to make your life easier.
For example, Countable allows you to pass your object to the built-in count function.

Class Posts implements Countable

{ /** * @var Post_Interface[] */ protected $posts; //.
public function count() { return count($this->posts); } } $posts = new Posts(); $num_posts = count($posts); 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Posts implements Countable      * @var Post_Interface[] $posts     count count posts   $posts Posts   $num_posts count $posts The Posts class above contains multiple instances of Post_Interface objects.

Because Posts implements the Countable interface, we can pass Posts to the count function

This gives us an easy way to get the total number of  Post_Interface objects in Posts

Interface inheritance.
Interfaces can also inherit from other interfaces.
That’s the case with the built-in interface Traversable.
Traversable allows you to use your object in a foreach loop, but you can’t use it directly.
You need to implement either Iterator or IteratorAggregate which are its child interfaces.
class Posts implements IteratorAggregate { /** * @var array */ protected $posts; //.
public function getIterator() { return new ArrayIterator($this->posts); } } $posts = new Posts(); foreach ($posts as $post) { // Do stuff } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Posts implements IteratorAggregate $posts     getIterator ArrayIterator posts   $posts Posts   foreach $posts as // Do stuff This example shows our Posts  class implementing the IteratorAggregate.
There’s just a small problem.
We can’t have our getIterator return our posts array as is.
That’s because of the IteratorAggregate contract.
It says that getIterator needs to return an object implementing a Traversable interface.
Lucky for us, there’s a PHP class designed to turn an array into a Traversable object.
That’s why getIterator returns an instance of ArrayIterator.
It’s a class that turns an array into Traversable object.
Now, .

We can loop through the posts in our Posts class

Implementing multiple interfaces.
While a class can only have one parent class, it can implement as many interfaces as it wants.
This is a powerful feature of interfaces.
You can have a single class fulfill as many contracts as it wants.
class Posts implements Countable, IteratorAggregate { /** * @var array */ protected $posts; //.
Public function count() { return count($this->posts); } public function getIterator() { return new ArrayIterator($this->posts); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Posts implements Countable IteratorAggregate $posts     count count posts   getIterator ArrayIterator posts For example, .

Our Posts class now implements both Countable and IteratorAggregate

This lets you pass a Posts object inside the count function and in a foreach loop. Both will work.
Abstract classes.
Let’s say you want to reuse your code in your classes, but each class has just a tiny difference between how they behave.
You could implement it partially, but the other classes would need to do the rest of the work. That’s what abstract classes do.
They partially implement the logic in a class, but leave some details for the child classes.
Abstract methods are the methods that a child class needs to implement.
They function the same way as a method defined in an interface.
The one difference is that you can define an abstract method as protected.
You can view an abstract class as an interface where you already coded some of the logic.
You should know that, because they are incomplete, you can’t instantiate abstract classes.
abstract class Abstract_Post implements Post_Interface { /** * @var int */ protected $id; /** * Get the CSS class.
* * @return type */ public function get_class() { return $this->get_type().
”-”.
$this->id; } abstract public function get_type(); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Abstract_Post implements Post_Interface      * @var int        * Get the CSS class.
* @return type get_class get_type.
”-”.
get_type In the case of the Abstract_Post class shown above, we know some common details for all classes.
Every post will have a post ID.
It will also output its CSS class the same way.
get_class concatenates the post type and its ID together.
But we don’t know its post type yet.
That’s why get_type uses the abstract keyword.
It lets us use get_type in get_class without the need to code it.
We’ll leave that to the concrete classes.
Concrete classes.
Concrete classes are the classes that your code will end up using.
They might implement one or more interfaces and/or extend an abstract class.
The important thing is that you can instantiate these classes.

Class Attachment extends Abstract_Post { /** * Get the post type

* * @return string */ public function get_type() { return ”attachment”; } } $attachment = new Attachment(); $attachment->get_class(); 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Attachment Abstract_Post      * Get the post type.
get_type ”attachment”   $attachment Attachment   $attachment get_class Now, it’s time to code the get_type method.
For our Attachment class, we make it return attachment.
It’s the same value as the existing WordPress post type.
Because we’ve completed our class, we can instantiate it and use it.
Overriding methods.
Here is a scenario: You defined a method in your parent class.
It works for 90% of the use cases, but not in that one child class.
What can you do.
Well, you can override the method.
You override a method by defining that method again in a child class.
Doing so replaces the old one and allows you to add that custom logic you wanted.
class Video extends Attachment { /** * Get the post type.
* * @return string */ public function get_type() { return ”video”; } } 1 2 3 4 5 6 7 8 9 10 11 12 Video Attachment      * Get the post type.
get_type ”video” In our Video class, we overrode our get_type method.
Instead of returning attachment, it’ll return video.
The parent method is still available if you want to use it.
All you need to do is use the parent keyword.
This is useful when you only want to alter the output of the parent method.
class Picture extends Attachment { /** * Get the post type.
* * @return string */ public function get_type() { return ”picture-”.
parent::get_type(); } } 1 2 3 4 5 6 7 8 9 10 11 12 Picture Attachment      * Get the post type.
get_type ”picture-”.
parent :: get_type In this final example, the get_type method for the Picture class won’t return attachment.
Instead, it’ll return picture-attachment.
attachment comes from our call to parent::get_type().
Final keyword.
There might be some cases where you don’t want others to extend your class or override your method. That’s where the final keyword comes in.
It prevents someone from extending a class or overriding a method.
There’s rarely a case for a class to be final, but you might see final methods in some cases.
You generally use a final method when the method is crucial to the functioning of a class.
In that case, overriding the method might have dire consequences.
Making sure you get the right type of object.
How can you make sure that you are receiving the correct type of object in your code.
You don’t want errors because someone didn’t give you the correct object.
Let’s look at two options available to you so you don’t get errors in your code.
Type hinting.
Type hinting is a useful tool when using inheritance.
It allows you to force a function or method to accept only a specific type as a parameter.
This saves you the need to do the validation in your code.
That said, receiving an invalid parameter will cause a fatal error in PHP.
/** * Save post to the database.
* * @param WP_Post_Interface $post */ function save_post(WP_Post_Interface $post) { // You are sure $post implements WP_Post_Interface } 1 2 3 4 5 6 7 8 9 * Save post to the database.
* @param WP_Post_Interface $post save_post WP_Post_Interface // You are sure $post implements WP_Post_Interface Validating in your code.
You can also check the object type in your code as well.
PHP has two ways for you to do it.
You can use either the is_a function or the instanceof operator.
This is how WordPress likes to do it since it allows for defensive coding.
Using this form of validation prevents PHP fatal errors.
/** * Save post to the database.
* * @param mixed $post */ function save_post($post) { // You are not sure $post implements WP_Post_Interface if (!$post instanceof WP_Post_Interface) { return; } // You are sure $post implements WP_Post_Interface } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 * Save post to the database.

* @param mixed $post save_post // You are not sure $post implements WP_Post_Interface

instanceof WP_Post_Interface // You are sure $post implements WP_Post_Interface The point of the above example is to show the before and after state within our save_post method.
Before our instanceof check, our post variable could be anything.
But after it, we’re sure that post implements WP_Post_Interface.
What should you check?.
That’s the better question to ask.
Is it the correct class or just an interface.
While it’s up to you, using interfaces for validation allows for the most flexibility.
When you’re validating a class, you’re telling them how to interact with your code.
You’re asserting more control over it as a result.
They have to use your class or they can’t do anything.
Validating using an interface allows others to build what they want.
You’re not forcing them to use your classes.
You just want them to use the contract that you created.
A practical example with WP_Widget.
WordPress widgets are an excellent showcase on how to use inheritance.
There is a clear relationship between the WP_Widget class and all its children.
That distinct relationship allows for a large amount of code reuse.
You can see the impact of it by the small size of the child classes.
How it currently works.
To develop your own custom widget, you need to extend the WP_Widget class and add your own logic.
WordPress expects you to override the widget method.
Otherwise, it will throw a fatal error.
class WP_Test_Widget extends WP_Widget { public function widget($args, $instance) { echo ”test”; } } 1 2 3 4 5 6 7 WP_Test_Widget WP_Widget widget $args $instance ”test” You can find more information about making widgets in the codex.
Leveraging inheritance.
As an exercise, let’s rewrite parts of the code to use inheritance.
This should give you a good idea of how to use the tools described earlier.
Defining an interface.

Let’s start by defining the interface WP_Widget_Interface

You want to create a baseline contract for all widgets in WordPress.
By doing so, we establish which methods WordPress deems necessary for a widget class.

Interface WP_Widget_Interface { /** * Register the widget

*/ public function register(); /** * Echo the widget content.
* * @param array $args * @param array $instance */ public function widget($args, $instance); } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 interface WP_Widget_Interface      * Register the widget.
* Echo the widget content.
* @param array $args      * @param array $instance widget $args $instance You’ll notice that the interface has only two methods.
This isn’t a mistake.
You want to limit the interface to required methods only.
The only public methods that WordPress uses are register and widget.
All other methods are internal.
It is worth noting that some methods need to be public due to the nature of the callback system.
That said, they should not be part of the interface.
WordPress does not need to be aware of them for you to fulfill your contract.
Taking a look at WP_Widget.
Now that we have defined an interface for widgets, let’s take a better look at the WP_Widget class.
Let’s rework it while maintaining the behaviour expected by WordPress.
Managing property and method visibility.
WP_Widget uses only public methods and properties.
The documentation defines private methods as methods meant for internal use.
We’re going to rework the visibility of the methods and properties.
That’s because we want them to follow encapsulation principles.
This means that only a few functions are public.
There’s the register and widget methods.
We defined those in the interface.
Also, you have the three callback methods which should also be public.
All other methods are for internal use only.
This means that you should define those methods as “protected”.
This goes for the properties as well.
Using an abstract class.
The WP_Widget class is an ideal candidate for an abstract class.
WordPress expects each child object to implement its own widget method.
By using an abstract class, we’re deferring the need to implement the method to the child class.
No need to use a “die”.
Using the final keyword.
WP_Widget documentation highlights methods that shouldn’t be overridden but leaves it at that.
We’re going to use the final keyword to lock down those methods.
We are, again, formalizing a behaviour that WordPress expects.
The result.
You can see the result below.
This isn’t an exact copy of all the methods.
It highlights the changes discussed earlier.
abstract class Abstract_WP_Widget implements WP_Widget_Interface { /** * @var array */ protected $widget_options; /** * @var string */ protected $id_base; /** * @var string */ protected $name; /** * @var array */ protected $control_options; /** * @var bool */ protected $number = false; /** * @var bool */ protected $id = false; /** * @var bool */ protected $updated = false; /** * Constructor * * @param type $id_base * @param type $name * @param type $widget_options * @param type $control_options */ public function __construct( $id_base, $name, $widget_options = array(), $control_options = array() ) { } /** * {@inheritdoc} */ final public function register() { } /** * Generate the actual widget content.
*/ final public function display_callback($args, $widget_args = 1) { } /** * Generate the control form.
*/ final public function form_callback($widget_args = 1) { } /** * Deal with changed settings.
* * @param mixed $deprecated Not used.
*/ final public function update_callback($deprecated = 1) { } /** * Echo the settings update form.
* * @param array $instance Current settings */ protected function form($instance) { } /** * Constructs name attributes for use in form() fields.
* * @param string $field_name * * @return string */ protected function get_field_name($field_name) { } /** * Constructs id attributes for use in form() fields.
* * @param string $field_name * * @return string */ protected function get_field_id($field_name) { } /** * Update a widget instance.
* * @param array $new_instance * @param array $old_instance * * @return array */ protected function update($new_instance, $old_instance) { } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 Abstract_WP_Widget implements WP_Widget_Interface      * @var array $widget_options      * @var string $id_base      * @var string      * @var array $control_options      * @var bool $number false      * @var bool false      * @var bool $updated false        * Constructor      * @param type $id_base      * @param type $name      * @param type $widget_options      * @param type $control_options $id_base $widget_options $control_options        * {@inheritdoc} final        * Generate the actual widget content.
final display_callback $args $widget_args 1        * Generate the control form.
final form_callback $widget_args 1        * Deal with changed settings.
* @param mixed $deprecated Not used.
final update_callback $deprecated 1        * Echo the settings update form.
* @param array $instance Current settings $instance        * Constructs name attributes for use in form() fields.
* @param string $field_name      * get_field_name $field_name        * Constructs id attributes for use in form() fields.
* @param string $field_name      * get_field_id $field_name        * Update a widget instance.
* @param array $new_instance      * @param array $old_instance update $new_instance $old_instance Changing the validation in WordPress.
We have a proper interface for widgets.
We can make changes to the_widget function.
Instead of validating based on the WP_Widget class, we will use the interface.
Function the_widget($widget, $instance = array(), $args = array()) { global $wp_widget_factory; $widget_obj = $wp_widget_factory->widgets[$widget]; if ( !is_a($widget_obj, .

”WP_Widget_Interface”) ) return; //

$widget_obj->widget($args, $instance); } 1 2 3 4 5 6 7 8 9 10 11 the_widget $widget $instance $args global $wp_widget_factory   $widget_obj $wp_widget_factory widgets $widget.
Is_a $widget_obj ”WP_Widget_Interface” $widget_obj widget $args $instance Meanwhile, .

WP_Widget_Factory should also validate an object to see if it’s a WP_Widget

It doesn’t.
That’s a bug I submitted to Trac.
Here is a possible way we could handle it.
class WP_Widget_Factory { var $widgets = array(); function register($widget_class) { $widget_obj = new $widget_class(); if ( !is_a($widget_obj, ”WP_Widget_Interface”) ) return; $this->widgets[$widget_class] = $widget_obj; } //.
} 1 2 3 4 5 6 7 8 9 10 11 12 13 14 WP_Widget_Factory var $widgets   $widget_class $widget_obj $widget_class.
is_a $widget_obj ”WP_Widget_Interface”   widgets $widget_class $widget_obj   It comes down to practice.
Inheritance is one of the most powerful features of object-oriented programming.
The amount of time you save with the code reuse is incredible.
That said, it can also be the hardest thing to grasp for newcomers.
Being able to see the relationship between your classes takes time and practice.
So keep at it.
Tweet.
#Abstract class #Inheritance #Interface #Object-oriented Programming #PHP #Widget API # The first thing you should learn from object-oriented programming Polymorphism and WordPress: Abstract classes.


Hogyan irányíthatom át a látogatókat HTTPS protokollra

English.
Magyar.
Tudásbázis.
Portál kezdőlap.
Tudásbázis.
Kategóriák.
70 Domain regisztráció 2 Számlafizetői fiók regisztrációja 3 Számlázás 13 Tanúsítványok 139 Tárhely 2 Viszonteladóknak 15 VPS   Kategóriák.
Domain regisztráció (70) Számlafizetői fiók regisztrációja (2) Számlázás (3) Tanúsítványok (13) Tárhely (139) Viszonteladóknak (2) VPS (15) Kategóriák.
Domain regisztráció (70) Domain regisztrációval kapcsolatos kérdések Számlafizetői fiók regisztrációja (2) Számlafizetői fiók regisztrációjával kapcsolatos kérdések Számlázás (3) Számlázással kapcsolatos kérdések Tanúsítványok (13) Tanúsítvány megrendeléssel kapcsolatos kérdések Tárhely (139) Webtárhellyel kapcsolatos beállítási útmutatók Viszonteladóknak (2) VPS (15) VPS (Virtual Private Server) szolgáltatással kapcsolatos kérdések Legnépszerűbb cikkek.
Hogyan irányíthatom át a látogatókat HTTPS protokollra.
Abban az esetben ha érvényes tanúsítvány lett beállítva a domain névnél akkor javasolt a.
DotRoll ingyenes tárhely Amennyiben domaint vesz a DotRoll Kft-től, ingyenesen kap egy 50 MB-os statikus tárhelyet.
Ez azt.
Egyedi PHP verzió beállítása könyvtáranként A cPanel felületen a PHP verzió választás menüpontban ki lehet választani, hogy mi legyen az.
FTP használata Total Commanderrel A képen megadott adat illusztráció.

Az Ön tényleges beállításait az adminisztrációs felületen

.hu átregisztráció Átregisztrációt csak a domain név tulajdonosa kezdeményezhet.
Átregisztráció elindításához a.
Címkefelhő.
Website Builder DNS SSL .hu regcheck FTP SMTP regisztráció .htaccess IMAP .hu CSR HTTPS PHP POP3 SPAM HTTP SSH cPanel Plesk DKIM SQL SPF Számlázás Outlook Express Redis domain Outlook 2000 Outlook 2013 DMARC átadás Outlook 2010 Outlook 2007 Joomla Átirányítás Google Parkoltatott domain CentOS Stopbadware tech csere phpMyAdmin adatforgalom Mac reboot tömeges domain átadás Kiegészítő domain Debian 9 Biztonság MariaDB 10.2 Repository Gmail Python URL WordPress Infrastruktúra mysqldump cronjob CentOS 6 MariaDB 10.1 TortoiseSVN admin csere CSF karakterkódolás SNI gzip domain átadás Jelszó módosítás Redmine Tűzfal szolgáltatás átadás SVN tulajdonos csere Ubuntu PTR .eu tar Biztonságimentés Szürkelistázás OSX Névszerver Search Console Debian iPhone Safebrowsing NodeJS awstats inode   Ügyfélszolgálat.
Hibajegyeim   Tudásbázis   Letöltések   Hibajegy létrehozása Szerzői jog által védett © 2020 DotRoll Kft.
Minden jog fenntartva.

| Áraink az ÁFÁ-t NEM tartalmazzák

| Betöltés… Betöltés… Bezár Küldés Adjon meg egy 8 és 64 közötti számot a jelszó hosszához Jelszó hosszúság Generált jelszó Új jelszó generálása Bezár Másolás vágólapra és beszúrás.