GNU/Linux on BadproG

UNIX & GNU/Linux - SSH - Communication between client and server

Thu, 17 Jan 2019 00:00:00 +0000

In this tutorial we are going to see how two computers can communicate with each other through the SSH protocol.

Why do we need SSH keys and how to use them?

We will use one computer as Server and another one as Client.

First of all

Ubuntu 18.04.01 (LTS): https://www.ubuntu.com/
openssh-server: directly from Ubuntu (more details in the tutorial)

Before starting we need some useful tools that we are going to install on Ubuntu:

UNIX & GNU/Linux - SSH - Generating the public and private keys with a CLI

Thu, 29 Jun 2017 00:00:00 +0000

Using SSH is helpful in many situations.

But before using it, it’s essential to have the famous public and private keys.

This SSH tutorial is for Windows and Linux users but feel free to inspire yourself for another operating system.

Let’s see that.

First of all

In this SSH tutorial we are going to use a CLI (Command Line Interface).

I’ve chosen Git Bash but of course you can use the CLI of your choice (Cygwin for example) on Windows or simply your usual terminal on Linux.

UNIX & GNU/Linux - Kernel - Hello world Linux kernel compilation

Mon, 12 Dec 2016 00:00:00 +0000

If you read this tutorial it’s because you are curious about how to compile a Linux kernel.

There is plenty of reasons you might want to learn this procedure.

Even if you are a beginner, you will understand each step for building your first Linux kernel.

First of all

To compile a Linux kernel, you have to have a Linux distribution installed on your computer.

So if you don’t know how, I recommend to start by using a virtual machine, such as VirtualBox.

UNIX & GNU/Linux - Gentoo - Basis for setting it up

Sun, 11 Dec 2016 00:00:00 +0000

In the Linux world, there are two types of distributions.

First the monolithic ones, such as Ubuntu, where you don’t have to set anything before using it.

Everything (or almost) is included to begin.

Second, the specific ones, that on calls meta-distributions, where you have to select only packages and options you want to have.

Of course, the first is easier to use for a current usage but there is no optimization at all.

UNIX & GNU/Linux - bash - Setting a profile with the Git prompt

Sun, 06 Nov 2016 00:00:00 +0000

You have downloaded and installed your Git Bash on Windows.

That’s a good thing.

But if you want to change your prompt as your favorite one, you have to create a file and add your own settings.

Let’s see this.

First of all

After downloading Git bash and installed it, if you launch it you’ll have a classic prompt.

To have something different, you have to create a new file .profile to override the default settings.

UNIX & GNU/Linux - Raspberry Pi - Set up for a connection with a desktop PC

Sun, 16 Oct 2016 00:00:00 +0000

Since its launch, the Raspberry Pi has a very huge impact in the world.

You have certainly one in your hands but maybe you don’t really know how to use it.

In this tutorial, we are going to see how to send commands directly from your PC without having a specific screen, keyboard and mouse connected onto the board.

It’s totally possible! For that the only thing to have is an Ethernet cable connected to your network.

UNIX & GNU/Linux - Tips and tricks - Having more than 4 workspaces with Ubuntu 13.04

Sun, 02 Jun 2013 00:00:00 +0000

With Ubuntu 13.04, you certainly found out that there is, by default, only one workspace.

If you want more, there are solutions.

First of all enable workspaces, then change (if you want) the number of workspaces.

Let’s see this in this tutorial.

Where to find it?

Click Settings > Appareance > Behavior > Enable workspaces.

You have now 4 workspaces.

But if you want more you have to install ccsm, the CompizConfig Settings Manager.

UNIX & GNU/Linux - LAMP - Installation

Mon, 04 Mar 2013 00:00:00 +0000

For a reason or for another, you need a server. You could install Apache, why not? But you want more! You want Apache2, PHP and MySQL in a bundle. For the same price we’re going to add phpMyAdmin.

Let’s see how to install LAMP and phpMyAdmin in this Ubuntu tutorial.

LAMP: Linux, Apache HTTP, MySQL, PHP

We have to download and install LAMP with the following command line in our terminal:

UNIX & GNU/Linux - Tips and tricks - Installing Google Chrome on Ubuntu

Sat, 02 Mar 2013 00:00:00 +0000

What would we do without Google? Who knows. But this is not the question. In this tutorial we will see how to install Google Chrome on Ubuntu 12.04.

It may seem easy like that, but it isn’t. And I’m a bit surprise about that. But anyway, let’s see this.

Downloading

Open your favorite terminal and if you have a 64-bit OS, type this:

wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb

If your system is a 32-bit (or if you don’t know) you have to type this:

UNIX & GNU/Linux - awk - Count number of words in a file and check a name in another

Sat, 27 Oct 2012 00:00:00 +0000

In this awk tutorial we’re going to see how to count words in a file and display it.

And in a second time, we will see how to check if a name, inside a file, is present in the first file.

Let’s check it.

Explanation

In the BEGIN pattern we specify the separator with the FS builtin variable. In our case, it will be the default one, the space character.

UNIX & GNU/Linux - awk - Read a file and computing the average of students' marks

Sat, 27 Oct 2012 00:00:00 +0000

The awk user command is made to read a file and check each column, one by one.

We need to compute the average of students’ marks and to display the total of their average.

Let’s go.

Explanation

In the BEGIN pattern we specify the separator with the FS builtin variable. In our case, it will be the default one: " " (the space character).

In the dev pattern, we are going to retrieve marks of each student and make an average of them.

UNIX & GNU/Linux - awk - Using getline to retrieve data

Sat, 27 Oct 2012 00:00:00 +0000

We’ve already played with awk, passing it a file, but we’re going now to see how to retrieve data from the user with the command line.

We would like to know what’s the name of the user.

Let’s ask him.

Explanation

The -f flag is normally to tell awk that we’re going to pass a file as argument. But if we don’t, the shell will wait for a file.
Instead of a file, we will give to awk a string that we’ll retrieve thanks to the getline function.

UNIX & GNU/Linux - awk - Using matching expressions and operators to find a pattern

Sat, 27 Oct 2012 00:00:00 +0000

The user command awk enables to check if an expression could be found in a file.

It’s a kind of regex, with classic operators, such as: **? . ***.

Let’s do it.

Explanation

We would like to find every line where there is an “e” followed by any character and a “4”.
For example, the following line matches the pattern.:

awdawekoodk d ekokd 93239 93994543z k

To find it, we have to use ($0 ~/e.4/) because we tell that we want that in each column of the file ($0), we would like to find the pattern “e.*4”.
For that we use the tilde (~) and slashes (/*) at the beginning and at the end of our pattern.

UNIX & GNU/Linux - awk - Using the FILENAME variable

Sat, 27 Oct 2012 00:00:00 +0000

With the awk FILENAME builtin variable, we are able to retrieve the name of the file passed as argument during the execution.

It will avoid us to use a regex command line. Sometimes interesting.

Let’s see this.

Explanation

In the example below, we’re going to retrieve the name of the file used as argument and display it. But only if we are scanning the first line.
For that, we’re going to use the FNR variable, also a awk builtin variable, to check where we are.
If we’re in the first line, we will display the file name.

UNIX & GNU/Linux - awk - Using NR to display line numbers before each line from a file

Fri, 26 Oct 2012 00:00:00 +0000

We have a file with customers inside.

We would like to display all the file with line numbers before each line.

Let’s see this in this awk tutorial.

Explanation

The NR variable is a awk builtin variable, to display the number (a sort of static variable).
The $0 represents every column separated by default by the space character.
The coma between will create a space character for our output.

All the code inside the dev statement, will be executed until there is no line.

UNIX & GNU/Linux - bash - Setting the colour prompt with PS1

Mon, 09 Jul 2012 00:00:00 +0000

You like your shell but you think that some colours would be better.

Let’s see how to set colours of the bash prompt with the PS1 variable.
Notice that this tutorial has been made with Ubuntu 12.
Some syntaxes may change depending on the operating system.

First of all, at your home directory, that you can have with the command “~/”, there is a configuration file named: .bashrc.

If you don’t see it, type this:

UNIX & GNU/Linux - gcc - Option -I for adding includes to the compilation

Mon, 04 Jun 2012 00:00:00 +0000

During the compilation step, we can add includes that will be added to the .o generated.

For that, we use the -I option (this is an uppercase “i”, standing for “include”) with the path to the includes we want to add.

Let’s suppose we want to add personal includes previously added in a directory.
So it can be something like that:

gcc -c -o main.o main.c -I"/home/soft/library/personal/include"

With a Makefile, we can use this example:

UNIX & GNU/Linux - gcc - Option -L for adding libraries during linking

Mon, 04 Jun 2012 00:00:00 +0000

We can add libraries during the linking step.
This tutorial is the same for g++ of course.

We use for that the -L option and add just after (without any space) the path of the libraries.
Libraries are generally prefixed with “lib” and suffixed with the .a extension.

Let’s suppose we previously created a library named libgreatone.a in /soft/personal/lib.
We have so: /soft/personal/lib/libgreatone.a.

OK, to call this lib, we have first to specify the path and then the name of this library witout the prefix “lib”.
For the first step, let’s use the -L option and for the second one use the -l (an “L” lowercase).
Notice that there is no space after the -L nor the -l option.

UNIX & GNU/Linux - System calls - Difference between fork() and vfork()

Tue, 01 May 2012 00:00:00 +0000

The fork() and vfork() syscalls are different.

The fork() syscall generates two identical processes with separate memory.
The vfork() syscall generates two processes that share the same memory.

With vfork() the parent will wait for the child terminates.
The parent inherites from the variables that the program is sharing.
So after the child was called, all variables modified inside the child will still be modified inside the parent.

Let’s see an example with this tutorial of both fork() and vfork() syscalls.

UNIX & GNU/Linux - System calls - Using wait()

Tue, 01 May 2012 00:00:00 +0000

The wait() syscall is often used with the fork() syscall.

Indeed, with the wait() syscall we can be sure that the child will be executed before the parent process.
In a trivial vision, this is like mutexes for threads.

It means that without the following line, the parent and the child will be executed at the same time:

wait(&status);

If you want to try it, change the line:

while (i < 10)

by this one on both parent and child loops:

UNIX & GNU/Linux - System calls - Using accept()

Thu, 19 Apr 2012 00:00:00 +0000

The accept() system call waits a connection from a client.

For the example above, we are going to take the nc tool (you can use telnet, it is the same).

If we reach the server through the nc connection, the server will shutdown.
But that’s what we want to do.

Let’s see it in this accept() tutorial.

Using accept()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my_socket(t_s *s)
{
s->name = "TCP";
s->domain = AF_INET;
s->type = SOCK_STREAM;
s->pe = getprotobyname(s->name);
s->fd = socket(s->domain, s->type, s->pe->p_proto);
check_error(s->fd, -1);
}
void my_bind(t_s *s, int port)
{
s->sockfd = s->fd;
s->addr.sin_family = s->domain;
s->addr.sin_addr.s_addr = INADDR_ANY;
s->addr.sin_port = htons(port);
s->addrlen = sizeof(s->addr);
s->bindValue = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
check_error(s->bindValue, -1);
}
void my_listen(t_s *s, int backlog)
{
s->listenValue = listen(s->sockfd, backlog);
check_error(s->listenValue, -1);
}
void my_accept(t_s *s)
{
s->addrlenAccept = sizeof(s->addrAccept);
s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
check_error(s->acceptValue, -1);
}
int main(int ac, char *av[])
{
t_s s;
check_arg(ac, ARG_SIZE);
my_socket(&s);
my_bind(&s, atoi(av[1]));
my_listen(&s, BACKLOG);
my_accept(&s);
debug(&s);
check_error(close(s.acceptValue), -1);
check_error(close(s.fd), -1);
return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t_s *s)
{
printf("\n===== socket() =====\n");
printf("domain = %d\n", s->domain);
printf("type = %d\n", s->type);
printf("fd = %d\n", s->fd);
printf("name = %s\n", s->name);
printf("p_proto = %d\n", s->pe->p_proto);
printf("\n===== bind() =====\n");
printf("sockfd = %d\n", s->sockfd);
printf("sin_family = %d\n", s->addr.sin_family);
printf("sin_addr.s_addr = %d\n", s->addr.sin_addr.s_addr);
printf("sin_port = %d\n", s->addr.sin_port);
printf("addrlen = %d\n", s->addrlen);
printf("bindValue = %d\n", s->bindValue);
printf("\n===== listen() =====\n");
printf("listenValue = %d\n", s->listenValue);
printf("\n===== accept() =====\n");
printf("addrlenAccept = %d\n", s->addrlenAccept);
printf("acceptValue = %d\n\n", s->acceptValue);
}
void check_error(int test, int error)
{
if (test == error)
{
fprintf(stderr, "ERROR: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
}
void check_arg(int ac, int number)
{
if (ac < number)
{
printf("Usage: ./server [PORT]\n");
exit(EXIT_FAILURE);
}
}

h.h

#ifndef H_H_
#define H_H_
#include 
/**
* Define
*/
#define ARG_SIZE 2
#define BACKLOG 10
#define BUF_SIZE 255
/**
* Structure
*/
typedef struct mystruct
{
/* socket */
int domain;
int type;
int fd;
char *name;
struct protoent *pe;
/* bind */
int sockfd;
socklen_t addrlen;
struct sockaddr_in addr;
int bindValue;
/* listen */
int listenValue;
/* accept */
int acceptValue;
socklen_t addrlenAccept;
struct sockaddr_in addrAccept;
} t_s;
/**
* Prototype
*/
void debug(t_s *);
void check_error(int, int);
void check_arg(int, int);
#endif /* H_H_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

UNIX & GNU/Linux - System calls - Using bind()

Thu, 19 Apr 2012 00:00:00 +0000

The bind() system call function is used with socket().

It assigns the address of the second argument to the file descriptor retrieved by socket().
Of course before using bind(), we must have a valid fd generated by socket().

Using bind()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my_socket(t_s *s)
{
    s->name    = "TCP";
    s->domain    = AF_INET;
    s->type    = SOCK_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p_proto);
    check_error(s->fd, -1);
}
void my_bind(t_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin_family        = s->domain;
    s->addr.sin_addr.s_addr = INADDR_ANY;
    s->addr.sin_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check_error(s->bindValue, -1);
}
int main(int ac, char *av[])
{
    t_s s;
    check_arg(ac, 2);
    my_socket(&s);
    my_bind(&s, atoi(av[1]));
    debug(&s);
    check_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p_proto = %d\n", s->pe->p_proto);
    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin_family = %d\n", s->addr.sin_family);
    printf("sin_addr.s_addr = %d\n", s->addr.sin_addr.s_addr);
    printf("sin_port = %d\n", s->addr.sin_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n\n", s->bindValue);
}
void check_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}
void check_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT_FAILURE);
    }
}

h.h

#ifndef H_H_
#define H_H_
#include 
/**
 * Structure
 */
typedef struct mystruct
{
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;
    int sockfd;
    socklen_t addrlen;
    struct sockaddr_in addr;
    int bindValue;
} t_s;
/**
 * Prototype
 */
void debug(t_s *);
void check_error(int, int);
void check_arg(int, int);
#endif /* H_H_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Result

===== socket() =====
domain = 2
type = 1
fd = 3
name = TCP
p_proto = 6
===== bind() =====
sockfd = 3
sin_family = 2
sin_addr.s_addr = 0
sin_port = 34835
addrlen = 16
bindValue = 0

Good job! 😈

UNIX & GNU/Linux - System calls - Using listen()

Thu, 19 Apr 2012 00:00:00 +0000

The listen() system call is designed to tell that a socket is ready to accept incoming connection.

Of course, we need first implementing the socket() and bind() system calls.

We are talking here about the server side.

Let’s see how to use the listen() system call with this tutorial.

Using listen()

server.c

/* server.c */
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void my_socket(t_s *s)
{
s->name = "TCP";
s->domain = AF_INET;
s->type = SOCK_STREAM;
s->pe = getprotobyname(s->name);
s->fd = socket(s->domain, s->type, s->pe->p_proto);
check_error(s->fd, -1);
}
void my_bind(t_s *s, int port)
{
s->sockfd = s->fd;
s->addr.sin_family = s->domain;
s->addr.sin_addr.s_addr = INADDR_ANY;
s->addr.sin_port = htons(port);
s->addrlen = sizeof(s->addr);
s->bindValue = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
check_error(s->bindValue, -1);
}
void my_listen(t_s *s, int backlog)
{
s->listenValue = listen(s->sockfd, backlog);
check_error(s->listenValue, -1);
}
int main(int ac, char *av[])
{
t_s s;
check_arg(ac, ARG_SIZE);
my_socket(&s);
my_bind(&s, atoi(av[1]));
my_listen(&s, BACKLOG);
debug(&s);
check_error(close(s.fd), -1);
return 0;
}

debug.c

/* debug.c */
#include 
#include 
#include 
#include 
#include 
#include "h.h"
void debug(t_s *s)
{
printf("\n===== socket() =====\n");
printf("domain = %d\n", s->domain);
printf("type = %d\n", s->type);
printf("fd = %d\n", s->fd);
printf("name = %s\n", s->name);
printf("p_proto = %d\n", s->pe->p_proto);
printf("\n===== bind() =====\n");
printf("sockfd = %d\n", s->sockfd);
printf("sin_family = %d\n", s->addr.sin_family);
printf("sin_addr.s_addr = %d\n", s->addr.sin_addr.s_addr);
printf("sin_port = %d\n", s->addr.sin_port);
printf("addrlen = %d\n", s->addrlen);
printf("bindValue = %d\n", s->bindValue);
printf("\n===== listen() =====\n");
printf("listenValue = %d\n\n", s->listenValue);
}
void check_error(int test, int error)
{
if (test == error)
{
fprintf(stderr, "ERROR: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
}
void check_arg(int ac, int number)
{
if (ac < number)
{
printf("Usage: ./server [PORT]\n");
exit(EXIT_FAILURE);
}
}

h.h

#ifndef H_H_
#define H_H_
#include 
/**
* Define
*/
#define ARG_SIZE 2
#define BACKLOG 10
/**
* Structure
*/
typedef struct mystruct
{
int domain;
int type;
int fd;
char *name;
struct protoent *pe;
int sockfd;
socklen_t addrlen;
struct sockaddr_in addr;
int bindValue;
int listenValue;
} t_s;
/**
* Prototype
*/
void debug(t_s *);
void check_error(int, int);
void check_arg(int, int);
#endif /* H_H_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Result

===== socket() =====
domain = 2
type = 1
fd = 3
name = TCP
p_proto = 6
===== bind() =====
sockfd = 3
sin_family = 2
sin_addr.s_addr = 0
sin_port = 34835
addrlen = 16
bindValue = 0
===== listen() =====
listenValue = 0

Great! 😱

UNIX & GNU/Linux - System calls - Using socket()

Thu, 19 Apr 2012 00:00:00 +0000

The socket() system call function will help us to create an end point.

This end point will allow for example to connect a client to a server.
Indeed, both of them (client and server) will have a socket() system call function on their implementation.

In this tutorial of socket() we are going to see how to create a socket for a client and for a server.

Let’s see first of all with the server snippet.

UNIX & GNU/Linux - System calls - Using read()

Tue, 10 Apr 2012 00:00:00 +0000

We are going to use the read() function to read on the standard input from our favorite shell.

So each time you will write something then type ENTER, the text written will be display on the shell.

Let’s see this, with this tiny tutorial of the read() function with a C example.

#include 
#include 
#include 
#include 
#include 
#define BUF_SIZE         1024
void empty_buf(char *buf)
{
    int i;
    i = 0;
    while (buf[i])
    {
        buf[i] = '\0';
        ++i;
    }
    buf[i] = '\0';
}
int main(void)
{
    int gogogo;
    int fd;
    char *buf;
    buf = malloc(sizeof(*buf) * BUF_SIZE + 1);
    if (buf == NULL)
    {
        fprintf(stderr, "Error: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
    fd = 0;
    gogogo = 1;
    while (gogogo)
    {
        read(fd, buf, BUF_SIZE);
        printf("buf = %s\n", buf);
        empty_buf(buf);
    }
    exit(EXIT_SUCCESS);
}

Good job. 😜

UNIX & GNU/Linux - System calls - Using gettimeofday()

Thu, 22 Mar 2012 00:00:00 +0000

The system call function gettimeofday() is a really helpful one.

Indeed, we can retrieve milliseconds of the time.

But in this tutorial, we are going to see how to generate random numbers every millisecond.

Here the code:

#include 
#include 
#include 
#include 
#include 
int my_random()
{
    double seed;
    struct timeval  tv;
    gettimeofday(&tv, NULL);
    seed = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
    srand(seed);
    usleep(10000);
    return (rand() % 255);
}
int main ()
{
    int i = 0;
    while (i < 10)
    {
        printf("R = %d\n", my_random());
        ++i;
    }
    return (0);
}

Nice example of random every millisecond.

UNIX & GNU/Linux - System calls - Using semget()

Wed, 21 Mar 2012 00:00:00 +0000

Today a tutorial to learn how to use semget(), semctl() and semop() system calls.

What are these functions?

They help to share data and control access to these data.
One calls them semaphore.

We can for example use them to access a data from different process.

In the example below, we will create two process with the same code, except for the sb.sem_op value.

For the first program the value will be 1 and for the second, this value will be -1.

UNIX & GNU/Linux - System calls - Using time()

Wed, 22 Feb 2012 00:00:00 +0000

It is sometimes useful to display the current date in your terminal.
For that the time() system call function is the best one.
Let’s see an example within this tiny tutorial of C programming language:

// main.c
#include 
#include 
int main () {
time_t myTime;
time(&myTime);
printf("The time is: %s", ctime(&myTime));
return 0;
}

Compiling and executing.
And the result is:

$ The time is: Wed Feb 22 14:36:43 2012

All simply!

UNIX & GNU/Linux - Emacs - Auto-completion with Auto-complete

Tue, 03 May 2011 00:00:00 +0000

We all agree, without any auto-completion, write always the same functions is really annoying.
A guy named Tomohiro Matsuyama has created an auto-completion plugin, really helpful.

Let’s install it together in this tutorial.
First of all, download the latest auto-complete’s version.

We have now to extract it:

$ tar xjf auto-complete-1.3.1.tar.bz2

Open a new file with Emacs:

$ emacs badprog

Wihtin, type ALT + X and write load-file.

Type RETURN.

And write it:

UNIX & GNU/Linux - User commands - Using info

Fri, 08 Apr 2011 00:00:00 +0000

The info user command is designed to display all information about a command.

It is more detailled than the man user command with several menu.

For example you can go throw a menu and click ENTER to enter in this menu:

$ info open

In this info you can see this:

* Menu:
* Linked Channels:: Dealing with channels sharing a file position.
* Independent Channels:: Dealing with separately opened, unlinked channels.
* Cleaning Streams:: Cleaning a stream makes it safe to use
another channel.

Put your cursor on:

UNIX & GNU/Linux - System calls - Using stat()

Thu, 07 Apr 2011 00:00:00 +0000

The system call stat function is designed to retrieve statistics of a file or a directory.

Simply add the path of your file or directory in the first parameter, then the variable of type struct stat in the second parameter.

The function stat returns 0 on success and -1 on error.

Let’s try an example of the system call stat function:

#include 
#include 
#include 
#include 
#include 
#include 
int main(int c, char *v[])
{
struct stat *buf;
buf = malloc(sizeof(*buf));
if (stat(v[1], buf) == 0)
{
printf("buf->st_dev = %d\n", buf->st_dev);
printf("buf->st_ino = %d\n", buf->st_ino);
printf("buf->st_mode = %d\n", buf->st_mode);
printf("buf->st_nlink = %d\n", buf->st_nlink);
printf("buf->st_uid = %d\n", buf->st_uid);
printf("buf->st_gid = %d\n", buf->st_gid);
printf("buf->st_rdev = %d\n", buf->st_rdev);
printf("buf->st_size = %d\n", buf->st_size);
printf("buf->st_blksize = %d\n", buf->st_blksize);
printf("buf->st_blocks = %d\n", buf->st_blocks);
printf("buf->st_atime = %d\n", buf->st_atime);
printf("buf->st_mtime = %d\n", buf->st_mtime);
printf("buf->st_ctime = %d\n", buf->st_ctime);
}
return (0);
}

You are now ready to create a file, named hello.bp (the extension is free of course).

UNIX & GNU/Linux - User commands - Using man

Thu, 07 Apr 2011 00:00:00 +0000

The man of Linux can help us to find some helpful information of functions.
This manual is splitted into eight parts.

General commands
System calls
C or other language library functions
Special files (usually devices, those found in /dev) and drivers
File formats and conventions
Games and screensavers
Miscellaneous
System administration commands and daemons

For example, to see the man of the open() function, you can use the:

$ man 2 open

UNIX & GNU/Linux - User commands - Using wc

Sun, 27 Mar 2011 00:00:00 +0000

The user command wc is a GNU/Linux tool written by Paul Rubin and David MacKenzie.

It helps us to display the number of lines, words and bytes counted in one or several files.

Let’s see an example of the user command wc by executing this command in our favourite terminal:

$ wc -l *

It will display the number of lines in all files present in the current directory.

You can combine all flags at the same time and the result will be displayed in different colums:

UNIX & GNU/Linux - User commands - Using grep

Tue, 22 Mar 2011 00:00:00 +0000

Maybe you sometimes asked yourself how to find a part of a code inside all your files.
But how to find this part of code?
We can use the grep user command to display this part of a code.

We can moreover display this code in color.

Let’s see an example of the grep user command.

The line below has to be typed directly in your favourite shell:

$ grep --color main *

The result is the code “main” in red and the file where the code is found (in purple).

UNIX & GNU/Linux - User commands - Using fs

Fri, 18 Mar 2011 00:00:00 +0000

To set ACL correctly, you can use the fs user command.

Let’s take an example to set the ACL:

$ fs setacl path/until/directory name command

If we want to see ACL list, let’s execute this with the la (for l ist a cl):

$ fs la path/until/directory

To remove all the ACL rights for the user system:anyuser we have to write it (sa for s eta cl):

$ fs sa directory system:anyuser none

UNIX & GNU/Linux - System calls - Using execve()

Sun, 06 Mar 2011 00:00:00 +0000

The execve() system call function is used to execute a binary executable or a script.
The function returns nothing on success and -1 on error.

The first parameter must be the path of a binary executable or a script.
The second must be an array of pointers on a character (char *myArray[]), and the last pointer must be set to NULL.
The third parameter must be an environment.

Using the execve() syscall

First example

/**
* Badprog.com
* main.c
*/
#include 
#include 
#include 
#include 
#include 
int main()
{
int e;
char *envp[] = { NULL };
char *argv[] = { "/bin/ls", "-l", NULL };
e = execve("/bin/ls", argv, envp);
if (e == -1)
fprintf(stderr, "Error: %s\n", strerror(errno));
return 0;
}

Compiling

gcc main.c -o execve-me ; ./execve-me

Ouput

The output is a classic ls -la:

UNIX & GNU/Linux - Emacs - Phases of the Moon

Wed, 23 Feb 2011 00:00:00 +0000

Yes it really exits!
You can see, with Emacs, the phase of the Moon for the next 12 weeks.

Make an ALT + X and write this:

lunar-phases

Result:

Tuesday, January 4, 2011: New Moon 10:05am (CET)
Wednesday, January 12, 2011: First Quarter Moon 12:33pm (CET)
Wednesday, January 19, 2011: Full Moon 10:19pm (CET)
Wednesday, January 26, 2011: Last Quarter Moon 2:03pm (CET)
Thursday, February 3, 2011: New Moon 3:33am (CET)
Friday, February 11, 2011: First Quarter Moon 8:20am (CET)
Friday, February 18, 2011: Full Moon 9:33am (CET)
Friday, February 25, 2011: Last Quarter Moon 12:32am (CET)
Friday, March 4, 2011: New Moon 9:48pm (CET)
Sunday, March 13, 2011: First Quarter Moon 12:46am (CET)
Saturday, March 19, 2011: Full Moon 7:07pm (CET)
Saturday, March 26, 2011: Last Quarter Moon 1:12pm (CET)

Enjoy!

UNIX & GNU/Linux - Emacs - Display number lines

Tue, 15 Feb 2011 00:00:00 +0000

If you want to see number of lines in Emacs, you have to activate it.

Let’s start this tiny tutorial:

Open Emacs, click ALT + X and write linum-mode then type RETURN.

Well done, it works!

To deactivate it, just retype this command.

UNIX & GNU/Linux - gdb - With Emacs

Mon, 14 Feb 2011 00:00:00 +0000

To start gdb, we have to add the -g flag at the compilation time.
So it is easy to add it in a Makefile. We are also using the Emacs IDE for running gdb.
Note that the code below does not work because we want to see the segmentation fault with gdb.

Let’s create a main.c file in our gdb mini tutorial:

#include 
#include 
int main(int c, char *v[])
{
char *string; int i;
i = 0;
while (i < strlen(v[1]))
{
printf("%c", string[i]);
i++;
}
return (0);
}

Let see an example of the gdb using:

UNIX & GNU/Linux - tcsh - Setting prompt with country flags

Mon, 14 Feb 2011 00:00:00 +0000

If you have always dreamed to change the classic prompt of your favorite Shell, it is time to see how to do it. Open your tcsh’s config that you can find in your home, it is called .tcshrc and inside, modify the line:

set prompt='(%n@%m %h)'

set prompt='<%T %/%B%{\033[1;31m%}>%{\033[0m%}%b'

Open a new terminal or juste write “. .bashrc” on your terminal, and miracle, you have now the time, your current path and a > in red and bold!

UNIX & GNU/Linux - System calls - Using open()

Thu, 03 Feb 2011 00:00:00 +0000

The open() system call function is used to open a file.
We have to pass the pathname of the file we want to open, then a flag in the second parameter. This second one has to be a flag among the following ones:
O_RDONLY, O_WRONLY or O_RDWR.

An important thing is that this function will always return a non negative integer on success.
This return value will be used by others functions, such as read() or write() for example, as a file descriptor.
As all system calls, if the function returns -1, it will mean that an error has occurred. Errors are POSIX standard.
The value 0, 1 and 2 are already reserved by the system, so if we open a new file that exists, its integer value will be 3 or more.
Let’s see why.
Write it successively on your favourite terminal:
ls -la /dev/ stdin
ls -la /dev/stdout
ls -la /dev/stderr

UNIX & GNU/Linux - Tips and tricks - Change the screen resolution

Thu, 03 Feb 2011 00:00:00 +0000

The command to change the screen resolution is xrandr, To see all size available for your screen:

$ xrandr

To choose the another one resolution just use the -s option with the resolution, for example:

$ xrandr -s 800x600

UNIX & GNU/Linux - gcc - Commands -v

Wed, 02 Feb 2011 00:00:00 +0000

With the -v command of the gcc, you can see all programs invoked by the compiler. Let’s try with an example of the -v command:

gcc -v

Result (certainly different on your system):

Using built-in specs.
Target: i686-redhat-linux
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-languages=c,c++,objc,obj-c++,java,fortran,ada --enable-java-awt=gtk --disable-dssi --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre --enable-libgcj-multifile --enable-java-maintainer-mode --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --disable-libjava-multilib --with-ppl --with-cloog --with-tune=generic --with-arch=i686 --build=i686-redhat-linux
Thread model: posix
gcc version 4.4.4 20100503 (Red Hat 4.4.4-2) (GCC)

UNIX & GNU/Linux - tar - The xvf command

Wed, 02 Feb 2011 00:00:00 +0000

The xvf command of the tar tool allows to extract files from a file with the .tgz extension, in the current folder. Let’s see an example of the xvf command:

$ tar xvf /home/login/Downloads/myArchive.tgz

It will extract all files present in the archive into the current directory in a new directory with the name of the first directory of the archive file.

UNIX & GNU/Linux - Tips and tricks - Change keyboard language

Sun, 30 Jan 2011 00:00:00 +0000

An easy way to change the keyboard language on Linux is to write this command on your favourite terminal:

setxkbmap lang

Where lang is the language you want. As an example to change the keyboard in french:

setxbmap fr

Or for an american keyboard:

setxbmap us

UNIX & GNU/Linux - System calls - Using tgetflag()

Thu, 20 Jan 2011 00:00:00 +0000

The tgetflag() function is a Linux system call function. It is designed to be used with the getenv() and tgetent() functions.
The tgetflag() function returns a boolean value: 1 on success or 0 on fail.

With the tgetflag() function, we have to put an only one string parameter. You have to use the two letters of the appropriate termcaps. You can find all of them in the Boolean Capabilities of the termcap manual.

UNIX & GNU/Linux - System calls - Using getenv()

Wed, 19 Jan 2011 00:00:00 +0000

The getenv() function is a Linux system call function.

It is designed to know what is the name of an environment variable.

The main use is for the “TERM” variable. Let’s see an example of the getenv() function:

/*
** Made by BadproG.com
*/
#include 
int main()
{
const char *name;
name = "TERM";
printf("My terminal is %s.\n", getenv(name));
return (0);
}

UNIX & GNU/Linux - System calls - Using tgetent()

Wed, 19 Jan 2011 00:00:00 +0000

The tgetent() function is a Linux system call function. It is designed to be used with other termcap functions such as:

tgetflag
tgetnum
tgetstr
tgoto
tputs

With the tgetent() function, we stock in the first parameter (a buffer pointer), the capabilities of the second parameter (the environment variable retrieved by the getenv() function).
This function returns 1 on success, 0 if there is not a such description and -1 if the terminfo database is not found.

UNIX & GNU/Linux - System calls - Using tgetnum()

Wed, 19 Jan 2011 00:00:00 +0000

The tgetnum() function is a Linux system call function. It is designed to be used with the getenv() and tgetent() functions.
If the description of the terminal is not found, most probably because there is no result in the tgetent() function, the tgetnum() one will return -1.

With the tgetnum() function, we have to put an only one string parameter. You have to use the two letters of the appropriate termcaps. You can find all of them in the Numeric capabilities of the termcap manual.

UNIX & GNU/Linux - System calls - opendir()

Tue, 11 Jan 2011 00:00:00 +0000

The opendir() system call function is used to open a directory and to return a pointer on this directory.
Let’s take an example of the using of the opendir system call function.

First, we have to create two files: a directory named hello and file name world.

mkdir hello

touch world

And now let’s create the main.c file:

/*
** Made by BadproG.com
*/
#include 
#include 
#include 
#include 
int main(int c, char *v[])
{
DIR *myDirectory;
myDirectory = opendir(v[1]);
if (c == 2)
{
if (myDirectory)
{
puts("OK the folder is opened.");
/*
** closedir
*/
if (closedir(myDirectory) == 0)
puts("The directory is now closed.");
else
puts("The directory can not be closed.");
}
else if (errno == ENOENT)
puts("This directory does not exist.");
else if (errno == ENOTDIR)
puts("This file is not a directory.");
else if (errno == EACCES)
puts("You do not have the right to open this folder.");
else
puts("That's a new error, check the manual.");
}
else
puts("Sorry we need exactly 2 arguments.");
return (0);
}

Let’s try:

UNIX & GNU/Linux - System calls - readdir()

Tue, 11 Jan 2011 00:00:00 +0000

The readdir() system call function is used to read into a directory.
The function returns a pointer to a dirent structure. This structure contains five fields but only two are POSIX standard, this is the d_name and the d_ino member.
That’s the first we will use in our readdir() example.

Before starting, let’s create some files. We need a folder named hello.
In the hello directory, let’s create three new files: a folder named one and two files named girl and boy.

UNIX & GNU/Linux - tcsh - Builtin commands source

Fri, 07 Jan 2011 00:00:00 +0000

In this tutorial we will see what is the source builtin command.
We will set the prompt of our tcsh as example.

Let’s go.
We can change the prompt with a script. But without modifying the .tcshrc file. It means that each new terminal you will open will be with the default shell config, in this case .tcshrc.

Let’s make a classic script by creating a new file named tcshScript.
Let’s open it and write this inside:

UNIX & GNU/Linux - make - Makefile

Thu, 06 Jan 2011 00:00:00 +0000

A Makefile has to be named Makefile with the first letter in capitalize.

There can be only one such file.
It is called with the make tool.
To use it simply write make on your terminal and it will execute the rules in your Makefile.

Using a Makefile is really helpful.
It automates tasks you have to do.
Let us take some examples:

In this first example, the Variables section contains 3 variables.

UNIX & GNU/Linux - System call functions

Mon, 03 Jan 2011 00:00:00 +0000

List of Linux system call functions.
These functions need one or more appropriate headers for each one of them.

These headers can be found in this directory on your operating system: /usr/include/

And if you want to learn more of them, just write man 2 theNameOfTheFunction on your favorite shell.

Example:

$ man 2 open

Why 2?
Because it is the number chosen for the system call functions.

UNIX & GNU/Linux - System calls - fork()

Mon, 03 Jan 2011 00:00:00 +0000

The fork() function is a Linux system call function.
It is used to make a new identical process from another one.

The original process becoming the parent and the new process becoming its child. The both are alive at the same time.

But when the fork() function is called, both process will terminate with the same end.

Let us see an example of the fork() function with 3 fonctions:

/*
** Made by BadproG.com
*/
#include 
void begin()
{
puts("#############");
puts("### BEGIN ###");
puts("#############");
}
void ending()
{
puts("##############");
puts("### ENDING ###");
puts("##############");
}
int main()
{
begin();
puts("Here the neutral code");
fork();
puts("Here the code after fork()");
ending();
}

We compile: