Abhai Sasidharan - Pass on what you have learned

What's a zombie process in Linux?

abhai — Mon, 23 Oct 2023 19:26:40 +0000

What's a zombie process in Linux? abhai Mon, 10/23/2023 - 19:26

In Linux, a zombie process is a state that a child process enters when it has finished executing, but its exit status has not yet been collected by its parent process. Zombie processes are essentially dead processes that are waiting for their parent process to retrieve their exit status.

When a process terminates in Linux, it doesn't immediately disappear from the process table. Instead, it becomes a zombie process until the parent process acknowledges the child's termination and retrieves its exit status. Once the parent process collects the exit status, the zombie process is removed from the process table, and its resources are released.

Zombie processes are typically harmless and consume very little system resources. However, if a parent process fails to collect the exit status of its child processes, a large number of zombie processes can accumulate and potentially lead to issues. To prevent this, it's important for the parent process to regularly call the wait() system call or one of its variants (e.g., waitpid()) to collect the exit status of its child processes and clean up zombie processes. To test this, in c you can create a child process using fork() and run it for 60 seconds. After running the c program, if you look at your system monitor (or top, htop commands) you'll see your zombie there. It's supposed to be dead, but it isn't, hence zombie.

In most cases, well-written programs and system utilities properly handle child processes, preventing zombie processes from becoming a problem.

Funny Drupal modules that help us deal with the insane learning curve!

abhai — Mon, 23 Oct 2023 16:16:33 +0000

Funny Drupal modules that help us deal with the insane learning curve! abhai Mon, 10/23/2023 - 16:16

What is patch level in git and composer?

abhai — Fri, 20 Oct 2023 19:25:11 +0000

What is patch level in git and composer? abhai Fri, 10/20/2023 - 19:25

You might have seen the command "patch -p2" or an entry in composer.json when using cweagans/composer-patches like the following.

"patchLevel": {
"drupal/core": "-p2"
}

In the command "patch -p2," the "-p2" flag specifies the patch level.

The "patch" command is used to apply changes, or patches, to source code files. The "-p" flag followed by a number tells the patch command how many directory levels to strip from the file paths mentioned in the patch file.

Here's what it means in more detail:

"-p0" (or simply "patch" with no "-p" flag) means that the patch file contains file paths starting from the root directory. In other words, the patch file specifies the full path to the files to be patched.
"-p1" means that the patch file contains file paths starting from one level above the root directory. This is often used when the patch file was created using the "diff" command with the "-u" or "-p" option.
"-p2" means that the patch file contains file paths starting from two levels above the root directory. This is commonly used when the patch file was generated in a directory that is two levels above the directory where the patch should be applied.

The choice of the patch level depends on how the patch file was generated and the directory structure of the project you are applying the patch to. Using the correct patch level is important to ensure that the patch is applied to the correct files with the correct paths.

So in the above example, the core folder is usually two folders inside the project root (<project_root>/docroot/core) which is why core patch level is mentioned as -p2.

Distro-Hopping: A fun way to find the perfect Linux desktop

abhai — Thu, 19 Oct 2023 16:32:22 +0000

Distro-Hopping: A fun way to find the perfect Linux desktop abhai Thu, 10/19/2023 - 16:32

Setting up Drupal on ddev for drupal core contributions

abhai — Thu, 28 Sep 2023 09:12:45 +0000

Setting up Drupal on ddev for drupal core contributions abhai Thu, 09/28/2023 - 09:12

How to correctly set Content-Security-Policy headers?

abhai — Mon, 19 Jun 2023 03:55:05 +0000

How to correctly set Content-Security-Policy headers? abhai Mon, 06/19/2023 - 03:55

Setting the Content-Security-Policy (CSP) header correctly is an essential step in enhancing the security of your web application. The CSP header allows you to define a policy that restricts the types of content that can be loaded by a web page, thereby mitigating risks such as cross-site scripting (XSS) and data injection attacks. Here's a general guide on how to correctly set CSP headers:

Understand your application's requirements: Before setting the CSP header, it's important to understand how your application functions and the resources it needs to load. This will help you create an effective policy without breaking the functionality of your web pages. If you need to allow a script from abh.ai, make sure that domain is one you trust, then add it into one of the directives mentioned below. An example of your default-src header value would look like this when using seckit module.
```
default-src: '''self'' ''unsafe-inline'' ''unsafe-eval'' *.sharethis.com:* *.cloudflare.com:* *.google-analytics.com:* *.googletagmanager.com:* *.gstatic.com:* *.googleapis.com:* *.fontawesome.com:* *.addtoany.com:* *.disqus.com:* *.facebook.com:* *.facebook.net:* *.google.com:* *.linkedin.com:* *.twitter.com:* *.abh.ai:* *.youtube.com:* *.vimeo.com:* *.instagram.com *.newrelic.com:* *.nr-data.net:* *.jquery.js:* *.chosen.css:* unpkg.com:* *.openstreetmap.org:* cdn.jsdelivr.net:* data:'
```
Define a policy: Start by deciding what types of content are allowed to be loaded on your web pages. The CSP header consists of various directives that you can use to define your policy. Some commonly used directives include:
- `default-src`: Specifies the default sources for content such as scripts, stylesheets, images, fonts, etc.
- `script-src`: Determines the sources from which JavaScript can be executed.
- `style-src`: Specifies the sources from which stylesheets can be loaded.
- `img-src`: Determines the sources from which images can be loaded.
- `font-src`: Specifies the sources from which fonts can be loaded.
- `connect-src`: Determines the sources to which the web page can make network requests (AJAX, WebSocket, etc.).
- `frame-src`: Specifies the sources from which frames or iframes can be loaded.
- `media-src`: Determines the sources from which audio or video content can be loaded.
These directives can be further modified with additional options, such as `'self'` (the same origin), `'unsafe-inline'` (allowing inline scripts/styles), `'unsafe-eval'` (allowing eval), or specific domains or sources.
Testing and refining: Once you have defined your initial policy, test your web application thoroughly to ensure all required resources are allowed and no unintended content is being loaded. Modern browsers provide console warnings or errors that can help identify any violations.
Implementing the CSP header: There are multiple ways to implement the CSP header, depending on your server environment. Here are a few common approaches:
- Server-side configuration: If you have control over your server configuration, you can set the CSP header directly. The method may vary depending on your web server (e.g., Apache, Nginx, IIS). Consult the documentation for your specific server software to learn how to configure headers.

- Middleware or framework: Many web frameworks and middleware provide functionality to set HTTP headers, including the CSP header. Consult the documentation for your framework to learn how to set headers programmatically.

- Content Security Policy HTTP header: You can set the CSP header directly in your web application's code. For example, in PHP, you can use the `header()` function to set the header.
Monitor and update: Regularly monitor your web application's functionality and logs to ensure the CSP policy is not causing any issues. As your application evolves, you may need to update the policy to accommodate new features or content sources. You can also checkout browser console for any CSP related errors. Usually the browser like Firefox or Chrome will give recommendations on how to fix it as well.

Remember that CSP is a powerful security feature, but it should not be the sole defense mechanism. It is crucial to implement other security practices, such as input validation and output encoding, to provide comprehensive protection against web vulnerabilities.

It's worth noting that the CSP specification has evolved over time, so it's essential to refer to the latest documentation and browser support information when implementing CSP headers.

What does the final keyword do in PHP?

abhai — Sat, 03 Jun 2023 18:30:34 +0000

What does the final keyword do in PHP? abhai Sat, 06/03/2023 - 18:30

In PHP, the `final` keyword is used to restrict the inheritance and overriding of methods and classes. Here's what it does in different contexts:

Final methods: When you declare a method as `final` within a class, it means that the method cannot be overridden by any subclass that extends that class. It effectively prevents the subclass from redefining the method implementation.
```
<?php
class ParentClass {
    final public function someMethod() {
        // Method implementation
    }
}
class ChildClass extends ParentClass {
    // This will cause an error since overriding final method is not allowed
    public function someMethod() {
        // New method implementation
    }
}
```
In the above example, the `someMethod()` in the `ParentClass` is declared as `final`, which means that the `ChildClass` cannot override it. If the `ChildClass` tries to override the `someMethod()` method, it will result in an error.
Final classes: When you declare a class as `final`, it means that the class cannot be extended by any other class. In other words, it prevents inheritance from that class.
```
<?php
final class FinalClass {
    // Class implementation
}
class ChildClass extends FinalClass {
    // This will cause an error since extending a final class is not allowed
}
```
In the above example, the `FinalClass` is declared as `final`, which means that no other class can extend it. If a class tries to extend the `FinalClass`, it will result in an error. The `final` keyword is useful when you want to ensure that a method or a class should not be modified or extended, providing a level of control over the inheritance and method overriding in your PHP code.

The final keyword is also relevant in other OO programming languages like Java, C# and C++.

What are the types of inheritance in PHP?

abhai — Sat, 03 Jun 2023 18:23:06 +0000

What are the types of inheritance in PHP? abhai Sat, 06/03/2023 - 18:23

In PHP, there are three types of inheritance:

Single inheritance: Single inheritance refers to the concept of a class inheriting properties and methods from a single parent class. In PHP, a class can extend only one parent class using the `extends` keyword. The derived class, also known as the child class, inherits all the public and protected properties and methods of the parent class.
```
<?php
class ParentClass {
    // properties and methods
}
class ChildClass extends ParentClass {
    // properties and methods
}
```
Multiple inheritance (achieved through interfaces): Multiple inheritance refers to the concept of a class inheriting properties and methods from multiple parent classes. However, PHP does not support multiple inheritance directly between classes. Instead, PHP supports multiple inheritance through interfaces. An interface defines a contract that a class must adhere to by implementing its methods.
```
<?php
interface Interface1 {
    // methods
}
interface Interface2 {
    // methods
}
class ChildClass implements Interface1, Interface2 {
    // properties and methods
}
```
By implementing multiple interfaces, a class can inherit and implement the methods defined in those interfaces. This allows for achieving a form of multiple inheritance in PHP.
It's important to note that PHP supports only single class inheritance but allows implementing multiple interfaces, providing a way to achieve similar functionality to multiple inheritance.
Multi-level inheritance: Multi-level inheritance refers to the concept of a class inheriting properties and methods from a parent class, which itself has inherited from another parent class. In this type of inheritance, a class extends a class that has already extended another class.
```
<?php
class GrandParentClass {
// properties and methods
}
class ParentClass extends GrandParentClass {
// properties and methods
}
class ChildClass extends ParentClass {
// properties and methods
}
```
In the above example, the ChildClass inherits properties and methods from both the ParentClass and the GrandParentClass. It forms a chain where the ChildClass indirectly inherits the properties and methods from the GrandParentClass through the ParentClass.

Multi-level inheritance allows classes to inherit and extend the functionality of multiple classes in a hierarchical manner. The child class can access the properties and methods of both its immediate parent class and its ancestor classes.

In PHP, a class can directly extend only one parent class. However, through multi-level inheritance, a class can indirectly inherit from multiple classes similar to multiple inheritance through interfaces.

Why is Drupal perfect for non-profits and NGOs?

abhai — Wed, 31 May 2023 17:54:36 +0000

Why is Drupal perfect for non-profits and NGOs? abhai Wed, 05/31/2023 - 17:54

How proper SEO and the Drupal CMS helped my article be a Google featured snippet

abhai — Tue, 30 May 2023 06:47:26 +0000

How proper SEO and the Drupal CMS helped my article be a Google featured snippet abhai Tue, 05/30/2023 - 06:47

Abhai Sasidharan - Pass on what you have learned

What's a zombie process in Linux?

Tags

Funny Drupal modules that help us deal with the insane learning curve!

What is patch level in git and composer?

Tags

Distro-Hopping: A fun way to find the perfect Linux desktop

Setting up Drupal on ddev for drupal core contributions

How to correctly set Content-Security-Policy headers?

Tags

What does the final keyword do in PHP?

Tags

What are the types of inheritance in PHP?

Tags

Why is Drupal perfect for non-profits and NGOs?

How proper SEO and the Drupal CMS helped my article be a Google featured snippet