Lets see a simple process creating example:

#include <stdio.h>
int main()
{
    switch (fork())
    {
        case -1:
            printf("Failed to create new process\n");
            return -1;
        case 0:
            printf("Child running\n");
            execvp(.. load child ...)
            break;
        default:
            printf("Parent running\n");
            wait();
            break;
    }

    return 0;
}

This is the most common process creating pattern. Now what does fork do? It creates a child as an exact parent copy, with the same file descriptors, same stack, same stack and data segments. But most of the times, immediately after fork, the child will load a new image: its own code. So why do we need all the exact fork does?

For child processes that need to start as fast as possible, the solution is vfork: it creates the child without copying the parent segments. So faster. But safer?.. The trick here is that using vfork the child will share the file descriptors, the data, stack and text with the parent until it will load its own image.  So any changes in the child will imediately affect the parent.

Here’s a short example:

#include <stdio.h>
int a = 1;

int main()
{
    switch (vfork())
    {
        case -1:
            printf("Failed to create new process\n");
            return -1;
        case 0:
            printf("Child running\n");
            a = 2 *a;
            execvp(... child...);
            break;
        default:
            sleep(1);
            printf("Parent running - %d\n", a);
            wait();
            break;
    }

    return 0;
}

The output:

Child running
Parent running - 2

So use it, but use it wisely!

• Qt – is is a crossplatform toolkit used for developing GUI used, for exmaple, with KDE, Opera or Skype. It uses C++ and offers bindings for languages such as Pascal, Php, Ruby or Phyton. It can be used an all major platforms. I personally loved it and found it very intuitive and Java-like (the naming helps a lot).
  For documentation, I used C++ GUI Programming with Qt 4, 2nd Edition, Prentice Hall.
• Gtk is developed in C, with bindings for C++, Java, C#, Php, Python and others. All thought it was designed for X11, it can run also in Windows environments. I found it difficult to use, with very few examples online andwith very few relevand documentation sources. I used Foundations of GTK+ Development, Apr. 2007, Apress.

I think more relevant would be to offer some examples. So let’s se how the classical “Hello World!” looks with both Qt and Gtk.

For now, the Qt versions. I personally enjoyed working work Qt, I find it very simillar to Java – the OOP helps a lot. The main probleme: there is no Qt binding for C. VLC has solved this probleme: they have the GUI in Qt and the “functionalities” in C. But the process is difficult and for small projects, I don’t think it worths considerring manual binding.

Qt Hello World

First thing to notice is that everything in Qt is a widget – this is the base clase. Of course, there is also the QObject class, but we are concerned with graphical objects.

#include <QApplication>
#include <QMainWindow>
#include <QLabel>
#include <QPushButton>
#include <QHBoxLayout>

int main(int argc, char *argv[])
{
        QWidget *mainWindow = new QWidget;
        QPushButton *okButton;
        QLabel *helloLabel;
        QApplication app(argc, argv);

        // Set window properties
        mainWindow->setWindowTitle("Say Hello Back!");
        mainWindow->setFixedHeight(175);
        mainWindow->setFixedWidth(200);
        mainWindow->move(800, 150);

        // Create a horizontal box for holding the content
        QHBoxLayout *lh = new QHBoxLayout;

        // Create the label and the button
        helloLabel = new QLabel("Hello World!");
        okButton = new QPushButton("Bye");
        okButton->setFixedSize(100, 30);

        // An an "action handler" for the button
        QObject::connect(okButton,
           SIGNAL(clicked()), &app, SLOT(quit()));

        // Add content to the layout box
        lh->addWidget(helloLabel);
        lh->addWidget(okButton);

        // Set the window's layout
        mainWindow->setLayout(lh);

        // Show the window
        mainWindow->show();
        return app.exec();
}

Qt offert a tool for creating projects and generating makefile: qmake. To obtain an executable from the above example:

// It creates a project -
// the name is given by the directory's name
>qmake -project 

// Generate Makefile
>qmake --makefile

// Compile sources
make

// Run....
./<ProjectName>

The result for the above example:

Qt Sample Screenshot

First, let”s define the region. These is done in Form_Load event handler. Simply duble click the form and the handler will be automatically added.  So to create a new region, use something similar to the following lines of code:

 // Create a graphical path, containing the points that describe 
 // the desired form
 GraphicsPath gp = new GraphicsPath();
            gp.AddPolygon(new Point[] { new Point(220, 17),
                new Point(280, 100), new Point(380, 100),
                new Point(350, 200), new Point(420, 270),
                new Point(320, 300), new Point(310, 400),
                new Point(220, 360), new Point(130, 400),
                new Point(120, 300), new Point(20, 270),
                new Point(90, 200), new Point(60, 100),
                new Point(160, 100)
            });

            // Set the form's region to the already defined graphical path
            this.Region = new Region(gp);

This code defines a star form. The result can be seen in the following screenshot. The buttons for close, minimize and help have been placed manually.

Custom form shape demo

What is Ipapi?

Ipapi is an API provided by Microsoft for network programming. The official page on MSDN is:

http://msdn.microsoft.com/en-us/library/aa366073(VS.85).aspx

It is destinated for C/C++ programmers. Ipapi provides the neccesary functions, procedures and structures to get information about the network configurations and change them. There are available several types of operations:

• retrieving information about network configuration
• managing network adapters, interfaces and IPs
• using ARP
• using ICMP
• routing
• get  notification for network events
• get information about TCP and UDP

Example 1: get information about network adapters I’ve used some functions provided by Ipapi to list all of my network interfaces and, based on user option, to scan a LAN and detect used IPs.

Ipapi works with some specific structures. One of them is called IP_ADAPTER_INFO. This structure contains information discribing a network adapter. The full description of the structure is avaialble here: 

http://msdn.microsoft.com/en-us/library/aa366062.aspx

To get information about the local network interfaces Ipapi has the function GetAdaptersInfo, witch return a IP_ADAPTER_INFO, witch will point to another adapter, if the local machine has more than one adapter. The code for getting information about an adapter is presented bellow:

PIP_ADAPTER_INFO pAdapterInfo = NULL;
PIP_ADAPTER_INFO pAdapter = NULL;
DWORD dwRetVal = 0;
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
// Allocate memory for the adapter info structure
pAdapterInfo = (IP_ADAPTER_INFO *) malloc(sizeof (IP_ADAPTER_INFO));
if (pAdapterInfo == NULL) {
	printf("Error allocating memory needed to call GetAdaptersinfo\n");
	return 1;
}

// Test if method is available and get buffer size
if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
	free(pAdapterInfo);
	pAdapterInfo = (IP_ADAPTER_INFO *) malloc(ulOutBufLen);
	if (pAdapterInfo == NULL) {
		printf("Error allocating memory needed to call GetAdaptersinfo\n");
		return 1;
	}
}

// Get adapters info and iterate them
if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) {
        pAdapter = pAdapterInfo;
        while (pAdapter) {
			// Do printing stuff
			.....
            pAdapter = pAdapter->Next;
        }
} else {
	printf("GetAdaptersInfo failed with error: %d\n", dwRetVal);
}

Example 2: scan IPs from LAN

Assuming that the network adapters info was revealed, one might be interested to know witch ips are used in one’s LAN. A simple method for doing this would be to compute all possible IPs inside the land and, for each IPs, send an ARP request. If the IP is used, then the corresponding machine will issue an ARP response.
In order to perform a scan, we must know the network mask and the network address. Ussing the previous example, we can find out the netmask and the local IP:

char *pMask = pAdapter->IpAddressList.IpMask.String;
char *pIp = pAdapter->IpAddressList.IpAddress.String

By converting these strings to numerical values and then applying bit-level operation, we can find out the LAN address. Using the netmask and the LAN address, we can iterate all possible IPs from the LAN and send arp requests. In order to do so, we can use a method provided by Ipapi: SendArp, like in the following sample code:

 // Input data:
IPAddr DestIp, IPAddr SrcIp;

DWORD dwRetVal =0;
ULONG MacAddr[2];
ULONG PhysAddrLen = 6;
BYTE *bPhysAddr = NULL;
UINT i = 0;

// Clear the memory zone for the MAC address
memset(&MacAddr, 0xff, sizeof (MacAddr));
// Send the ARP request for the DestIp IP, from the SrcIp. If the Ip is used, then
// the corresponding MAC address will be stored in MacAddr and the size of
// the MAC in PhysAddLen
dwRetVal = SendARP(DestIp, SrcIp, &MacAddr, &PhysAddrLen);

// If the function SendARP is successful - that is if the IP is used, then print the MAC address
if (dwRetVal == NO_ERROR) {
	// The destination IP is used - print the corresponding MAC address
	bPhysAddr = (BYTE *) & MacAddr;
	if (PhysAddrLen) {
		for (i = 0; i < (int) PhysAddrLen; i++) {
			if (i == (PhysAddrLen - 1))
				printf("\t%.2X\n", (int) bPhysAddr[i]);
			else
				printf("\t%.2X-", (int) bPhysAddr[i]);
		}
	}
}

What is SSL?

SSL is a security protocol, that works on a TCP/IP data stream. Used with HTTP at application level, the result is HTTPS – that is HTTP secure. SSL is used to secure the communication between to entities, such as a client and a server, by encrypting the data send between them. Usually, only the server needs to authenticate, so the client is sure to whom is is communicating. To get even more secure, both entities must authenticate. At this point A Public Key Infrastructure – or PKI – is required, unless the client uses TLS-PKS or Secure Remove Password protocols. So SSL ensures secure communication accross Internet.

SSL phases

Usually, when a client and a server communicate using SSL, some steps must be followed:

1. negotiate the encryption details – the “handshake” – such as the cipher or authentication codes
   
2. exchange keys and authentication – usually using public key algorithms
   
3. exchange data using the already agreed on encryption algorithm

So at phase two the server and the client must authenticate each other. If, for example, the client receives the server’s authentication details, how can it establish that the server really is who it claims it is? Well, this is done using PKI.

What is PKI ans how it works?

PKI is a hierarchical organization of the web. The purpose is to confirm that a given entity on the web is who it claims it is. The same model used on the Web can be applied at a proper scale on all kind of networks.

To approach the problem bottom up, consider that a client and a server begin communicate using SSL. At some point the server sends the client its authentication data – a digital certificate. How can the client can verify that the server is who is claims it is? Well, the client can question the certification authority wich released the server’s certificate. But how can the certification authority’s identity can be check? Simply, by advancing one step furter. How far can this go on? Until the client reaches a certification authority it trust.
At top level there are several major certification authorities. These server do not release individual certifications, but they release certificates for other certification authorities. To provide hierachical compatibily, some commom standards must be used. Currently, one of the must popular certificate format is X.509. The general format of an X.509 certificate is the following:

• Certificate
  • Version
  • Serial Number
  • Algorithm ID
  • Issuer
  • Validity
    • Not Before
    • Not After
  • Subject
  • Subject Public Key Info
    • Public Key Algorithm
    • Subject Public Key
  • Issuer Unique Identifier (Optional)
  • Subject Unique Identifier (Optional)
  • Extensions (Optional)
    • …
• Certificate Signature Algorithm
• Certificate Signature

Make your own PKI using X.509 certificates

It is possible to create small scale PKI using OpenSSL – this is an open source implementation for SSL and TLS (Transport Layer Security) protocols. This library is available for Unix-like operating systems, but also for Microsoft Windows. To create a PKI-like structure, first it must be established the trusted certification authority – by launching a request for a certificate. In the following example it is used a RSA encriptyion algorithm, with a 1024 bytes key. The result is a private key for the certification authority stored in CA_key.key and a certification request, stored in CA_certificate_request.

openssl req -new -newkey rsa:1024 -nodes
        -out CA_certificate_request.csr
        -keyout CA_key.key -batch

Because the certification authority is at the top of the hierachy, it’s certificate must be signed by itself. The following command signes a certificate using the request and the key generated at the previous step. The result is an X.509 certificate for the certification authority:

openssl x509 -trustout -signkey CA_key.key
        -days 365 -req
        -in CA_certificate_request.csr 
        -out CA.pem

Next, the certification authority can emit a certificate for the authorization server. The following command created a request for a certificate using the rsa algorithm. The authorization server can be described by an alias. It uses the AS_pass password. The certificate will be stored in a keystore – the authorization server’s certificate collection. To access the keystore, it is provided a password – AS_store_pass. The result will be a certificate request: AS_certificate_request.

keytool -certreq -keyalg rsa -alias AS_alias
        -keypass AS_pass -keystore AS_kyestore
        -storepass AS_store_pass
        -file AS_certificate_request

After lauching the certificate request, the certification authority must sign the server’s certificate. To create the certificate, we must provide the certification authority ow certificate – CA_certificate, its key – CA_key, its given serial number: CA_serial, the request for the authorization server’s cerficicate: AS_certificate_request. The result will be a an authorization certificate for the authorization server, available for 365 days.

openssl x509 -CA CA_certificate -CAkey CA_key
        -CAserial CA_serial -req
        -in AS_certificate_request -out AS_certificate
        -days 365

Finally, the authorization server’s certificate must be imported into its keystore.

keytool -import -alias AS_alias -keypass AS_pass
        -keystore AS_ks -storepass AS_store_pass
        -trustcacerts -file AS_certificate.

So we have a certification authority witch created an authorization certificate for an authorization server. The authorization server also has a keystore, which contains both the server’s certicate and the certification authority’s.

VANET (Vehicular ad-hoc newtork)

Definition

VANETs are a form of mobile ad-hoc networks destinated to ensure communication between passengers inside a vehicle, between vehicles or between vehicles and fixed equipment, known as roadside equipment. To ensure connectivity, nowdays a small electronic device is places inside the vehicle. It’s purpose is to ensure connectivity for the pessengers without a server or any complicated configuration settings. Using this device, the vehicle becomes a node in an ad-hoc network. Besides the regular Internet connectivity, VANETs can assure some additional services, such as traffic information.

Due to the fact that the vehicles are continously moving, VANETs have the same problems like MANs, but in VANETs the vehicles must follow a given road, some some adjustments can be made in order to improve the communication in VANETs.

An advanced form of VANETs are Intelligent VANET (InVANET), that uses a great range of modern solution in order to offer the best performance for VANETs: implementations for 802.11b/g, WiMax 802.16, Bluetoth or ZigBee.

Solutions

Due to the fact that vehicles follow a path, devices such as GPS can be used to improve VANET traffic and message passing decisions.Together with VANET, they form an intelligente transportation system.

For communication VANETs are using position-based routing and Mobile Ipv6, to ensure continuity and reachability. Because current implementations for Mobile IPv6 and mobile ad-hoc networks exist, in order to get better performance for VANETs, there can be used solutions for optimizing communication mode (direct in-vehicle, vehicle-to-vehicle, and vehicle-to-roadside communication) and provides dynamic switching between vehicle-to-vehicle and vehicle-to-roadside communication mode during a communication session in case that more than one communication mode is simultaneously available.

Standards

802.11p is a standardisation draft, extending 802.11 in order to optimize it for creating ITS. The standard offer solution for improving communication performance between vehicles and vehicles and roadside equipment. 802.11p uses the licensed ITS band of 5.9 GHz (5.85-5.925 GHz)

Organizations

From 2004 till 2007, ACM hold each year a workshop on VANETs.

Communication protocol design

VANET protocols use two types of channels: PublicSafety Channel and Critical Safety Channel.

The following document from UCLA provides some recommandation about VANET implementation and communication primitives: http://www.cse.sc.edu/research/isl/docs/genericVanetAppProtocol.pdf. There is no standard VANET protocol, VANET uses communication primitives recommanded for DSRC (dedicated short range communication). Each message has a priority and a duration. There are different types of messages:

• basic safety messages – it is send through broadcast to all surounding vehicles.
• common safety messages – a vehicle may request information about another vehicle by sending a common safety message and the reply will be a basic safety message
• probe – contains state information broadcasted to all vehicles.
• emergency vehicle alert – this message is broadcasted by an emergency vehicle to vehicles surounding it

I consider the following paper to be considerably enterresting and I recommend it: Protocol Arhitecture for VANET.

Conclusion

I consider VANETs to be a good research subject. Considerring that everyone wants to be online 24/7 and that we are always moving, VANETs are a good way to improve oour online experience while getting from one place to another. Traffic jam, accidents, all these can be avoided by building VANET bases ITS.

One of the problems I’ve been confronted to was hot to install MPI. I consider the followig document to be extremely useful (I’ve tryed it, it worked like a charm): Installing MPI in Linux.

For a list of available MPI routines check this out:
http://www-unix.mcs.anl.gov/mpi/www/www3/.

So here it is:

• The Site
• The Blog

Now, the challenge is to find the best way so that the site could be easilly found by google seach for the keywords “interfete web” (that is web interfaces in english).  I hope we’ll lear some SEO techniques and get some visible results soon.

Today I’ve started a little ANTLR tutorial. I need to get used to using ANTLR for one of my homeworks, for the compilers class. I use the following link:

http://javadude.com/articles/antlrtut/

I am still at the lexer part and I’ve encountered a problem. First, the tutorial uses ” for quotes and the ANTLR version I’m using (1.2.1) uses simple quotes. The problmes was related to the CHARLIT rule:

CHARLIT
  : '\''! . '\''!
  ;

Because I was writting a parser grammar, I couldn’t use ! to ignore simple quotes, so I constantly got the following error message:

(133): XL.g: illegal option output
Consult the console for more information.

The console was empty, so no hints there… So in order to ignore simple quotes I’ve added a protected rule (for protected rules the lexer doesn’t create tokens):

protected QUOTE
    :    '\''
    ;

and I’ve added a filtering option:

options {
    filter=QUOTE;
}

So now my chars literal rule looks like this:

CHARLIT
    : QUOTE ~(QUOTE) QUOTE
    ;

Next step: string literals:)

Anyway, the point is that I fill I’ve come a long way. I am much more confident in my C# programming abillities. I’ll have the chance to prove it today.