In this article, we will use a user called User on a machine called machine, simple enough?

Adding User to sudoers

For added security, we will avoid working with the root user. Therefore, we need a user capable of executing administrative commands. To do that, we’ll just add User to the sudoers

[User@machine ~]$ su -
[Root@machine ~]# visudo

Add the following line at the end of the file

User ALL=(ALL) ALL 

or to sudo without password prompt (not recommended)

User ALL=(ALL) NOPASSWD: ALL

That’s it, we can now use sudo to execute administrative commands!

VNC Server

For remote desktop access, we will use the VNC server for it’s cross platform abilities. Note: VNC connections are not encrypted so don’t use it on public networks.

[User@machine ~]$ sudo yum install vnc-server vnc
[User@machine ~]$ sudo vi /etc/sysconfig/vncservers

Edit the file so it contains:

VNCSERVERS="1:User"
VNCSERVERARGS[1]="-geometry 1024x768 -depth 16"

Set the vnc password for the user (this should be different than the password for the local/ssh login):

[User@machine ~]$ vncpasswd

Set the services:

[User@machine ~]$ sudo service vncserver restart
[User@machine ~]$ sudo chkconfig vncserver on

FTP Server

If you want to access your files remotely and transfer them to other machines, you’ll need to install an FTP server

 [User@machine ~]$ sudo yum install vsftpd
[User@machine ~]$ sudo chkconfig vsftpd on
[User@machine ~]$ sudo vi /etc/vsftpd/vsftpd.conf

change from

anonymous_enable=YES

to

anonymous_enable=NO

uncomment both lines bellow

write_enable=YES
local_enable=YES

Set the services:

[User@machine ~]$ sudo service vsftpd restart

SSH

Finally, to administer your server through the console remotely, you need ssh

[User@machine ~]$ sudo yum install ssh-server
[User@machine ~]$ sudo service sshd start
[User@machine ~]$ sudo chkconfig sshd on

Lets secure the server:

[User@machine ~]$ sudo vi /etc/ssh/sshd_config

Add the following lines at the end of the file:

LoginGraceTime 30

(or if you’re paranoid, use 15. This is the amount of time you have to login)

PermitRootLogin no
AllowUsers User

Now restart the service and you are done

[User@machine ~]$ sudo service sshd restart

End note

Obviously, you’ll need to set up your server to let those services through. Keep in mind that VNC runs on port 590x where x is the number in the

VNCSERVERS="1:User"

line. Also, here’s a little bonus; how to encrypt your VNC sessions: just run (in the terminal):

ssh -f -L 25901:127.0.0.1:5901 User@ip -p 22 sleep 10; vncviewer 127.0.0.1:25901:1

Hope you liked the tutorial! Questions, as usual in the comments and I will do my best to answer them. Stay tuned, I have more tutorials coming in the next few weeks!

Cross-compiling is compiling for a different architecture than the one you are currently working on. If it’s your first time doing that kind of work, it can rapidly become frustrating since there is no “silver bullet” method. In this post, I will try to explain a method that should work for most embedded device provided that the manufacturer has a toolchain readily available.

What you will need:

• A computer with a Linux distribution (I used Fedora 7 [it's old but it worked] )
• A compiler and the necessary libraries
• The toolchain for the processor
• Not necessary but will make you  life easier: a development environment (such as Eclipse)

Let’s take a look at the 4 items previously listed. First, the Linux distribution; it’s not 100% required but it will make your life a lot easier since most toolchains (patience, we’ll get to what it is soon) are compiled for Linux.

The compiler that is most often used is GCC, a great compiler, free (free as in speech and free as in beer) and readily available of all (or almost) Linux distributions. You can get the Tarballs off their website at http://gcc.gnu.org/ or just use the package manager in you environment. I would suggest installing the required libraries for the code you are compiling at this point if it’s not already done.

Toolchains, what are they? Toolchains are simply a set of compilers and libraries build to run on a certain architecture and compile for another. You will usually be able to get them from the manufacturer’s website or from the community. You will most likely find them packaged in Tarballs.

Finally, the development environment is useful because it let’s you consolidate and organize your code into neat folders and let’s you easily manage build options. With some addons, Eclipse will even let you sync a project directly from a SVN!

Architecture, what’s that?

Throughout this article, I will often refer to the ARM architecture and the x86 (also known as i386 or i486 or i686). The architecture simply refers to the CPU “design” and it’s a quick way of knowing what compiled code will work with which CPUs. The differences between each architecture and the reason for such differences is way beyond the scope of this article. Just keep in mind that when you select a compiler, an application or Linux distribution for you computer, you’ll probably be looking for the i386 (most Linux distributions will but different versions for i386 and i686, newer PCs run with i386) or the x86_64 (or x64) if you have a 64 bit processor. Note that i386 will work on 64 bit processor the the opposite is not true!

Let’s get started

First let’s assume that you have you environment set up, that you have some basic knowledge of Linux and that your code compiles on you current processor. Let’s also assume you’re not using some obscure libraries that you don’t have the source code for. Finally, I’ll assume that you have ROOT privileges on your system.

First step of the cross-compiling process is to locate the toolchain and download it to your home directory.

Next step is to extract it. If it’s a tarball, just execute the following command:

tar -xzf crosstool.tar

Once you have the content of the toolchain in a folder somewhere, we need to make it usable. This is where most people go their own ways. I found a very simple and effective way of using the toolchain and I’m sharing it because I think the other methods are more trouble than they are worth.

To get the toolchain working, let’s start by making a backup or our compilers. Execute the following commands in the console:

cp /usr/bin/gcc /usr/bin/gcc.bak

cp /usr/bin/g++ /usr/bin/g++.bak

Now that we have the backup done, we’ll remove the originals by running the following commands:

rm /usr/bin/gcc

rm /usr/bin/g++

And finally, we need a way of letting the OS think that we still have the compilers there, so we’ll add two symbolic links that will point to the toolchain’s compilers

ln -s /path/to/crosstool/bin/crosstool-name-gcc /usr/bin/gcc      
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gcc /usr/bin/gcc

ln -s /path/to/crosstool/bin/crosstool-name-gpp /usr/bin/gpp               
ex: ln -s /home/test/arm-none-linux-gnueabi/bin/arm-none-linux-gnueabi-gpp /usr/bin/gpp

Now that, we have some shinny new compilers, let’s test them with something simple. We’ll make a short “Hello World” program and compile it for your embedded device architecture. Type into a new file somewhere:

#include <stdio.h>

int main(void) {

       printf("Hello World!\n");

       return 0;

}

and save it as hello.c.

To compile, you can simply type the following command (assuming that you are executing that command from the same folder that contains the file):

gcc hello.c -o hello.arm

You should look for errors here, if it succeeds, you should not get anything back and you will be able to see the file in your current folder.

Finally, to confirm that you have a working environment, we will look at the file properties by executing the command:

file hello.arm

if the output specifies the embedded device’s processor, you should be fine. It should look like:

hello.arm: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.4.17, not stripped

In part two of this tutorial, we will look at getting the original compilers back in and some advanced method for larger application compiling. Even though I am not an expert on the subjet, feel free to post your issues and questions and I will do my best to find and provide answers!