MySQL won't start because of AppArmor

Kelvin Wahome — Tue, 17 Sep 2024 12:14:19 +0000

AppArmor is a Linux security module that provides mandatory access control (MAC) for programs. It works by enforcing security policies that restrict how applications interact with the system, helping to protect against potential vulnerabilities and malicious behavior. Each application is assigned a security profile that specifies which files, network resources, and other system resources it can access.

MySQL Workbench when installed as a Snap package on Ubuntu, it operates under the confinement of AppArmor. This confinement can sometimes block necessary services and interactions, leading to issues such as inability to connect to MySQL or errors related to authentication.

Solution

Connect Required Snap Interfaces

Snap applications, like MySQL Workbench, operate within a confined environment and often require additional permissions to function correctly. To resolve access issues, you may need to connect specific Snap interfaces. Open your terminal and run the following commands:

snap connect mysql-workbench-community:password-manager-service
snap connect mysql-workbench-community:ssh-keys
snap connect mysql-workbench-community:cups-control

These commands grant MySQL Workbench the necessary permissions to interact with services such as password management, SSH keys, and printing controls.

Conclusion

By connecting the necessary Snap interfaces you can resolve common access issues with MySQL Workbench on Ubuntu. These steps should help you restore full functionality and ensure smooth operation of your database management tasks.

If you encounter further issues or have additional questions, feel free to leave a comment or reach out for support.

Building Your Own Shell in C: A Journey into Command-Line Magic

Kelvin Wahome — Sat, 29 Jul 2023 20:20:14 +0000

Today, I want to take you on an exciting journey into the world of command-line magic by creating your very own shell in the C programming language. Shells are an integral part of any operating system, allowing users to interact with the system using text commands. By building a simple shell from scratch, you'll gain a deeper understanding of how shells work and how they execute commands.

Lets Get in it

How does shell works?
A shell reads user input, interprets the commands, and executes them by forking child processes. The standard C library provides functions like fork(), exec(), and wait() that help us achieve this.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

#define MAX_INPUT_LENGTH 100

int main() {
    char input[MAX_INPUT_LENGTH];
    char* args[MAX_INPUT_LENGTH];
    int status;

    while (1) {
        printf("YourShell$ ");
        fgets(input, sizeof(input), stdin);

        /*Tokenize the input*/
        char* token = strtok(input, " \n");
        int i = 0;
        while (token != NULL) {
            args[i] = token;
            token = strtok(NULL, " \n");
            i++;
        }
        args[i] = NULL; /*Null-terminate the argument list*/

        if (strcmp(args[0], "exit") == 0) {
            printf("Exiting the shell...\n");
            break;
        }

        pid_t pid = fork();
        if (pid < 0) {
            perror("Fork error");
        } else if (pid == 0) {
            /*Child process*/
            if (execvp(args[0], args) == -1) {
                perror("Execution error");
                exit(EXIT_FAILURE);
            }
        } else {
            /*Parent process*/
            wait(&status);
        }
    }

    return 0;
}

How does this work

The program sets up a loop to keep the shell running until the user types "exit."
It prompts the user for input and reads the command from the standard input using fgets().
The input is then tokenized into arguments using strtok() and stored in the args array.
The shell checks if the command is "exit"; if so, it exits the loop.
If not, it forks a child process using fork().
In the child process, the command is executed using execvp(), which searches for the command in the system's PATH and runs it.
The parent process waits for the child to complete using wait().

Let's do it!!

To compile it we use gcc

gcc simple_shell.c -o myshell

Now we can execute this by :

./myshell

Conclusion

That's it. That's how shell works. Is it not interesting how the command line works?😃
Of course, there's a lot more you can add to make it more feature-rich and robust, but this serves as an excellent starting point to dive deeper into the world of shells and command-line interfaces.

If you have any questions or want to share your experiences, drop a comment below. I'd love to hear your thoughts!

Stay curious, keep coding, and until next time, happy hacking! 🚀

Big Thanks to ALX SE for introducing me to this fascinating world.

Forem: Kelvin Wahome