Передача указателя через сигнал

char *basket_mem_base;
int basket_shmid;
key_t basket_key;
pid_t ourPid;                                                       // наш PID
 
char* SharedMemoryAllocate (key_t key, int size, int *id)
{
    char *addr;
 
    *id = shmget (key, size, IPC_CREAT | 0666);
    if (*id < 0)
    {
        perror ("Error allocating shared memory block");
        exit (1);
    }
 
    addr = shmat (*id, NULL, 0);
    if (!addr)
    {
        perror ("Error attaching shared memory block");
        exit (2);
    }
 
    return addr;
}
 
void Randomize (void)
{
    struct tm randtime;
    int seed;
 
    mktime (&randtime);
    seed = randtime.tm_sec + randtime.tm_min + randtime.tm_hour;
 
    srand (seed);
}
 
void StartBasketMon (key_t key, int size, pid_t pid)
{
    pid_t npid;
 
    char *argBas[10];
    char tempKey[10];
    char tempPid[10];
    char tempSize[10];
 
    sprintf (tempKey, "0x%x", key);
    sprintf (tempPid, "%d", pid);
    sprintf (tempSize, "%d", size);
 
    argBas[0] = BASKETMON_NAME;
    argBas[1] = "-shk";
    argBas[2] = tempKey;
    argBas[3] = "-shs";
    argBas[4] = tempSize;
    argBas[5] = "-pid";
    argBas[6] = tempPid;
    argBas[7] = (char *)0;
 
    npid = fork ();
    if (npid == 0)
        execv (BASKETMON_PATH, argBas);
}
 
void workSig_Handler (int sig, siginfo_t *siginfo, void *context)
{
    sigset_t s_set;
    char *p;
 
    if (sigemptyset (&s_set)) return;
 
    if (sigaddset (&s_set, SIGUSR1)) return;
 
    if (sigprocmask (SIG_BLOCK, &s_set, NULL)) return;
 
    // Собственно сам обработчик
    printf ("Получен сигнал SIGUSR1.\n");
    printf ("Отправил PID: %d UID: %d\n", siginfo->si_pid, siginfo->si_uid);
    printf ("Приаттачен указатель на область в памяти. [%p].\n", siginfo->si_ptr);
 
    p = siginfo->si_ptr;
 
    printf ("%s", p);
 
    if (sigprocmask (SIG_UNBLOCK, &s_set, NULL)) return;
}
 
int main (int argc, char *argv[])
{
    struct sigaction work_sig;
 
    bzero (&work_sig, sizeof (struct sigaction));
    work_sig.sa_sigaction = &workSig_Handler;
    work_sig.sa_flags = SA_SIGINFO;
    sigaction (SIGUSR1, &work_sig, NULL);
 
    // Генерируем ключ
    Randomize ();
    basket_key = rand ();
 
    // Узнаем свой пид
    ourPid = getpid ();
 
    // Создаем область памяти
    basket_mem_base = SharedMemoryAllocate (basket_key, sizeof (plate_t) * MAXPLATE, &basket_shmid);
    *basket_mem_base = 0;
 
    // Запускаем монитор корзины
    StartBasketMon (basket_key, sizeof (plate_t) * MAXPLATE, ourPid);
 
    while (1)
    {
        printf ("нихрена не делаем\n");
        sleep (1);
    }
 
    return 0;
}

key_t key;
int sh_size;
pid_t pid;
 
char *shared_mem_base;
int shmid;
 
void GetSharedMemory (key_t key, int size)
{
    // Подключаемся к нашей области памяти
    shmid = shmget (key, size, 0666);
    if (shmid < 0)
    {
        perror ("Get memory error");
        exit (3);
    }
 
    shared_mem_base = shmat (shmid, NULL, 0);
}
 
int main (int argc, char *argv[])
{
    int n;
 
    // Парсим ключики
    for (n = 1; n < argc; n++)
    {
        if (strcmp (argv[n], "-shk") == 0)
        {
            // Ключ указывающий ключ к общей памяти
            sscanf (argv[n+1], "%x", &key);
            n++;
        }
        else if (strcmp (argv[n], "-shs") == 0)
        {
            // Ключ указывающий на размер общей памяти
            sh_size = atoi (argv[n+1]);
            n++;
        }
        else if (strcmp (argv[n], "-pid") == 0)
        {
            // Ключ указывающий на ПИД родительского процесса
            pid = atoi (argv[n+1]);
            n++;
        }
    }
 
    // Подключаем область общей памяти, для общения с ядром
    GetSharedMemory (key, sh_size);
 
    while (1)
    {
        union sigval value;
        sleep (10);
        strcpy (shared_mem_base, "А вот вам данные из другого процесса.\n");
        value.sival_ptr = shared_mem_base;
        sigqueue (pid, SIGUSR1, value);
    }
 
    return 0;
}