c/c++ linux programming by examples

Callback function is hard to trace, but sometimes it is very useful. Especially when you are designing libraries. Callback function is like asking your user to gives you a function name, and you will call that function under certain condition.

For example, you write a callback timer. It allows you to specified the duration and what function to call, and the function will be callback accordingly. “Run myfunction() every 10 seconds for 5 times”

Or you can create a function directory, passing a list of function name and ask the library to callback accordingly. “Callback success() if success, callback fail() if failed.”

Lets look at a simple function pointer example

void cbfunc()
{
    printf("called");
}

int main ()
{
     /* function pointer */
    void (*callback)(void *);

    /* point to your callback function */
    callback=(void *)cbfunc;

   /* perform callback */
   callback();

   return 0;
}

How to pass argument to callback function?
Observered that function pointer to implement callback takes in void *, which indicates that it can takes in any type of variable including structure. Therefore you can pass in multiple arguments by structure.

typedef struct _myst
{
    int a;
    char b[10];
}myst;

void cbfunc(myst *mt)
{
    fprintf(stdout,"called %d %s.",mt->a,mt->b);
}

int main()
{

    /* func pointer */
    void (*callback)(void *);

    //param
    myst m;
    m.a=10;
    strcpy(m.b,"123");

    /* point to callback function */
    callback = (void*)cbfunc;

    /* perform callback and pass in the param */
    callback(&m);

    return 0;

}

curl is a command line tool for transferring files with URL syntax, supporting FTP, FTPS, HTTP, HTTPS, SCP, SFTP, TFTP, TELNET, DICT, LDAP, LDAPS and FILE. curl supports SSL certificates, HTTP POST, HTTP PUT, FTP uploading, HTTP form based upload, proxies, cookies, user+password authentication (Basic, Digest, NTLM, Negotiate, kerberos…), file transfer resume, proxy tunneling and a busload of other useful tricks.

Quote from http://curl.haxx.se/

Advantages of using libcurl:

You do not need to read up RFC to code for HTTP post or ftp client, you just need to download libcurl-dev and try it out.

Let me show you one of the simple example source code from curl official site.

/*****************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ | |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             ___|___/|_| ______|
 *
 * $Id: simple.c,v 1.6 2004/08/23 14:22:52 bagder Exp $
 */

#include <stdio.h>
#include <curl/curl.h>

int main(void)
{
  CURL *curl;
  CURLcode res;

  curl = curl_easy_init();
  if(curl) {
    curl_easy_setopt(curl, CURLOPT_URL, "curl.haxx.se");
    res = curl_easy_perform(curl);

    /* always cleanup */
    curl_easy_cleanup(curl);
  }
  return 0;
}

Check out the libcurl tutorial and the sample source codes.

From my previous post, create your own time stamp, I have introduced a way to construct your own time stamp.

Recently I found a better way, and with this function, you can create a better time stamp, yet the way of construct the time stamp is far more simple compared to my previous post.

#include<stdio.h>
#include<time.h>

int main()
{
    char timestamp[100];
    time_t mytime;
    struct tm *mytm;
    mytime=time(NULL);
    mytm=localtime(&mytime);

    strftime(timestamp,sizeof timestamp,"%a, %d %b %Y %H:%M:%S %z",mytm);

    printf("%s\n",timestamp);

    return 0;
}

Yes, that’s it, and the output is show as below:

Wed, 26 Sep 2007 23:54:50 +0800

Sometimes you need to construct a structure which the variables in the structure is not specified in bytes, instead bits. It may occur when you wanna construct some field of a binaries packets for examples Point Code field in Called address of TCAP packet.

One of the point code format length is 14 bits, consist of 3 parts (x,y,z). Where x is 3 bits, y is 8 bits, and z again 3 bits. How we suppose feed the x,y,z to form a 2 bytes data? 2 bytes is 16 bits, that means 14 bits padding with 2 bits ZERO.

One of the common solution is write a function with 3 params (x,y,z) to perform shifting bits and returns a 2 bytes characters array. But it is tedious to write such function and the complexity will grows if the number of params increases.

Therefore, bit specific structure is used instead. To construct a bit specific structure, there are few things have to be taken care precisely.
1. Variable type used
2. Whether to use __attribute__((packed)) or not.

Lets look at the definition of the ERRORNOUS PointCode structure:

typedef struct
{
     char      x:3,
               y:8,
               z:3;
}PointCode;

The way of define bit specific structure is correct, but the outcome will be errornous.

PointCode pc;
printf("%d ",sizeof(pc));

The sizeof(pc) will return 3 bytes instead of two bytes. Reason is because, the structure uses variable type that is not large enough to store a 2 bytes data.

Second attempt will be still ERRORNOUS where we uses unsigned long instead of char.

typedef struct
{
     unsigned long       x:3,
                         y:8,
                         z:3;
}PointCode;

unsigned long is 4 bytes, after storing the data, the remaining 2 bytes will be padded with 0. Therefore the sizeof will return 4 bytes, which is not what we wanted, what we want is 2 bytes.

The CORRECT definition at last:

typedef struct
{
     unsigned long    x:3,
                      y:8,
                      z:3;
}__attribute__((packed)) PointCode;

With __attribute__((packed)), it tells the compiler to packed the data, now it returns exactly 14 bits, and sizeof will return 2 bytes. You may want to verify the correctness of the data.

PointCode PC;
memset(&pc,0,sizeof(pc));

pc.x=1;
pc.y=2;
pc.z=3;

unsigned char* ptr=(unsigned char*)&pc;

printf("size(%d) payload: (%X %X) ",sizeof(pc), *ptr, *(ptr+1));

A simple challenge for c/c++ fans, use only 2 variable and 2 for loop to print a pascal triangle looks as bellow

        1
       121
      12321
     1234321
    123454321
   12345654321
  1234567654321
 123456787654321
12345678987654321

My solution:

#include<stdio.h>
#include<stdlib.h>

void piramid(int const c)
{
    int x,y;
    for(y=0; y<c; y++)
    {
        for(x=0; x<c-(1+y)+((y*2)+1); x++)
        {
            if(x<(c-(y+1)))printf(" ");
            else
            {
                if(x-(c-(y+2))>y+1) printf("%d",(2*y)+2-(x-(c-(y+2)) ));
                else printf("%d",(x-(c-(y+1))+1 ));
            }
        }
        printf("\n");
    }
}

int main(int argc, char* argv[])
{
    if (argc==2)
    {

        if (atoi(argv[1])>9 || atoi(argv[1])<=1)
        {
            printf("Insert range within 2 to 9, ig. %s 9n",argv[0]);
            return 1;
        }
        piramid(atoi(argv[1]));
    }
    else
        printf("Insert range within 2 to 9, ig. %s 9n",argv[0]);
    return 0;
}

This is an interesting quest given by my friend who working in Intel, during our conversation online.

How to swap two variables ?

Let say A=123 and B=546, how to swap them. So this is a quest, be smart enough not to give a plain solution like create a temporary variable to swap them. First of all my answer sounds a bit stupid. I say if I coded in python,

A,B=B,A

Okay that is not the expecting answer. Before you look at the solution bellow, maybe you would like to try to figure out.

Hint: use logic XOR, no additional variable is needed.

Solution:

A=A XOR B;
B=A XOR B;
A=A XOR B;

Explanation:
XOR is known as exclusive disjunction where the nature of XOR is when 1 XOR 0 will equal to 1 but when 1 XOR 1 will becomes 0. Another important behavior of XOR is when (a XOR b) XOR b will resulting a.

So lets look back at the solution, you will find A XOR B seems to become “something else”, where this “something else” will return A if we XOR B and return B if we XOR A. So first line, A=(A XOR B). Secondly B = (A XOR B) XOR B = A, where we replace the original A into (A XOR B). Last line, A= ( A XOR B) XOR A = B. Seems at second line B already become A, so we replace B as A.

Interesting isn’t it? Look at it few times, if you can’t get it.

Singleton is one of the common design pattern used to make a class object exist only one instant. I have read some books illustrate the implementation of singleton, I found it all complicated. I have tried to come out a very simple example on singleton class, bellow is my outcome.

#include<stdio.h>
class singleton
{
    public:
    void print()
    {
        printf("hello\n");
    }
    int a;
}singleton;

int main()
{
    //singleton s;  #cannot define a new instant like this anymore.
    singleton.a=5;
    printf("a=%d\n",singleton.a);
    singleton.print();

    return 0;
}

With the class name and the object name appear the same, you make that class object singleton. Which means you can’t instantiate a new object using the name singleton anymore. The way to access the function and variables of a singleton object is direct.

This is my initial idea of how to make singleton simple.

Don’t know whether you aware of the example code at Tap the interrupt signal, I am using sleep(1) within endless loop at the first sample of code.

The example of the code is to illustrate the tapping Interrupt signal while I hit control+c and ignores the termination of the program. When I hit control+c, I discover a problem. the sleep process elapse straight away although its not yet pass a second where it support to sleep for one second.

It happens to usleep function as well, where both sleep and usleep doesn’t seems to be a good sleep function to use. And I discover a better sleep function from time.h. That is nanosleep. Refers to nanosleep man page, it briefly state that it can cater the problem by storing the remaining time at second param, and with that you can use the remaining to to call nanosleep again.

That means, its not like sleep or usleep, you can use it straight away. Well, I have write a wrapper for miliseconds sleep. With the signal tap handler function in sample code, use to test for usleep and my own msleep.

#include<stdio.h>
#include<time.h>
#include<signal.h>

void sigfunc(int sig_no)
{

}

int __nsleep(const struct timespec *req, struct timespec *rem)
{
    struct timespec temp_rem;
    if(nanosleep(req,rem)==-1)
        __nsleep(rem,&temp_rem);
    else
        return 1;
}

int msleep(unsigned long milisec)
{
    struct timespec req={0},rem={0};
    time_t sec=(int)(milisec/1000);
    milisec=milisec-(sec*1000);
    req.tv_sec=sec;
    req.tv_nsec=milisec*1000000L;
    __nsleep(&req,&rem);
    return 1;
}

int main()
{
    struct sigaction sa={0};
    sa.sa_handler=&sigfunc;
    sigaction(SIGINT, &sa,NULL);

    int a=0;
    scanf("%d",&a);

    for (;;)
    {
        printf("testing...\n");
        if (a==1)
            msleep(1000);
        else
            usleep(1000000);
    }
    return 1;
}

__nsleep is a wrapper for nanosleep, the reason I want to do that wrapper is because I want to make a recursive call to nanosleep. If nanosleep is intercept by signal, it will return -1 and the second param will store the remaining time. With that, I call __nsleep recursively passing the second param as first param now. The second param will be a temp timespac structure variable.

I create another wrapper msleep accepting millisecond, in timespec structure, you can either gives value in nanosecond or second. One thing to be aware is tv_nsec cannot go beyond 999999999, which is 1 second. If beyond that, you have to put it into tv_sec.

Updates:
I found __nsleep() is redundant, and I have a better idea without using recursive and __nsleep at all, instead, directly create a msleep.

int msleep(unsigned long milisec)
{
    struct timespec req={0};
    time_t sec=(int)(milisec/1000);
    milisec=milisec-(sec*1000);
    req.tv_sec=sec;
    req.tv_nsec=milisec*1000000L;
    while(nanosleep(&req,&req)==-1)
         continue;
    return 1;
}

Store back the remaining time to req, If getting return value -1, continue to sleep. Better and cleaner isn’t it? :D

When you hit control+c, you are actually send a SIGINT ( Interrupt signal ) to your program. By default, your program will be terminated after receiving SIGINT. But you can change the way of handling Interrupt signal.

Some of the application tends to ignore SIGINT. You can easily do that with sigaction.

#include<stdio.h>
#include<signal.h>
void bypass_sigint(int sig_no)
{

}
int main()
{

    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = &bypass_sigint;
    sigaction(SIGINT, &sa,NULL);

    while(1)
    {
        sleep(1);
        printf("do nothing \n ");
    }
    return 0;
}

#include<stdio.h>
#include<signal.h>
#include<string.h>

struct sigaction osa;

void bypass_sigint(int sig_no)
{
    printf("I tap SIGINT and returns back \n");
    sigaction(SIGINT,&osa,NULL);
    kill(0,SIGINT);
}

int main()
{

    struct sigaction sa,osa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = &bypass_sigint;
    sigaction(SIGINT, &sa,&osa);

    while(1)
    {
        sleep(1);
        printf("do nothing \n ");
    }
    return 0;
}