Lire/Écrire struct la méthode fifo en C

Je suis en train de passer entre les structures des processus à l'aide des canaux nommés. Je me suis coincé en essayant d'ouvrir le tuyau de non-blocage de la mode. Voici mon code pour l'écriture de la fifo:

void writeUpdate() {
    //Create fifo for writing updates:
    strcpy(fifo_write, routing_table->routerName);
    //Check if fifo exists:
    if(access(fifo_write, F_OK) == -1 )
        fd_write = mkfifo(fifo_write, 0777);
    else if(access(fifo_write, F_OK) == 0) {
        printf("writeUpdate: FIFO %s already exists\n", fifo_write);
        //fd_write = open(fifo_write, O_WRONLY|O_NONBLOCK);
    }
    fd_write = open(fifo_write, O_WRONLY|O_NONBLOCK);
    if(fd_write < 0)
        perror("Create fifo error");
    else {
        int num_bytes = write(fd_write, routing_table, sizeof(routing_table));
        if(num_bytes == 0)
            printf("Nothing was written to FIFO %s\n", fifo_write);
        printf("Wrote %d bytes. Sizeof struct: %d\n", num_bytes,sizeof(routing_table)+1);
        }
    close(fd_write);
   }

routing_table est un pointeur de ma structure, il est alloué, donc il n'y a pas de prob avec le nom de la fifo ou qch comme ça.
Si j'ouvre la fifo sans l'option O_NONBLOCK, il écrit qch pour la première fois, mais ensuite il bloque parce que je vais avoir des problèmes de lecture de la struct trop. Et après la première fois, la première fifo est créé, mais d'autres fifo apparaissent, nommée '.', '..'.
Avec option O_NONBLOCK ensemble, il crée le fifo, mais jette toujours un message d'erreur: "rien de tel appareil ou de l'adresse'. Une idée de pourquoi cela se produit? Merci.

EDIT: Ok, si je suis clair, maintenant, sur l'ouverture de la fifo, mais j'ai un autre problème, en fait la lecture/écriture de la structure de la fifo était ma question de départ. Mon code pour lire la struct:

void readUpdate() {
struct rttable *updateData;
allocate();

strcpy(fifo_read, routing_table->table[0].router);

//Check if fifo exists:
if(access(fifo_read, F_OK) == -1 )
    fd_read = mkfifo(fifo_read, 777);
else if(access(fifo_read, F_OK) == 0) {
    printf("ReadUpdate: FIFO %s already exists\n Reading from %s\n", fifo_read, fifo_read);        
}
fd_read = open(fifo_read, O_RDONLY|O_NONBLOCK);
int num_bytes = read(fd_read, updateData, sizeof(updateData));
close(fd_read);
if(num_bytes > 0) {
    if(updateData == NULL)
        printf("Read data is null: yes");
    else
        printf("Read from fifo: %s %d\n", updateData->routerName, num_bytes);

    int result = unlink(fifo_read);
    if(result < 0)
        perror("Unlink fifo error\n");
    else {
        printf("Unlinking successful for fifo %s\n", fifo_read);
        printf("Updating table..\n");
        //update(updateData);
        print_table_update(updateData);
    }
} else
    printf("Nothing was read from FIFO %s\n", fifo_read);
}

Il ouvre la fifo et essaie de lire, mais il semble que rien n'est dans la fifo, bien que dans writeUpdate la première fois qu'il dit qu'il a écrit 4 octets (ce qui semble mal aussi). À la lecture, la première fois autour d'elle imprime 'a' et puis num_bytes est toujours <=0.
J'ai regardé autour et ne se trouve que cet exemple, avec une simple lecture/écriture, est-il qch plus nécessaire lors de l'écriture d'une structure?

Mon struct ressemble à ceci:

typedef struct distance_table {
char dest[20];       //destination network
char router[20];     //via router..
int distance;
} distance_table;

typedef struct rttable {
char routerName[10];
char networkName[20];
struct distance_table table[50];
int nrRouters;
} rttable;

struct rttable *routing_table;