Simulating wireless netowork using IPC

Dear all,

I am writing a tiny simulator for wireless networks in a PC(linux).

The network will consist of several nodes, and any one might send data to any other.

I thought of named pipes, but that might make the simulator more of a wired like feel.

In a wireless network, every packet(including unicast) is actually a broadcast with respect to the transmission medium. However only nodes within reception range will be able to receive the packet. To phrase that in IPC terms, there are several processes/threads, however data written by a particular process/thread is visible only to a subset of other processes. I should be able to control which nodes are part of this subset.

What is the best choice IPC to do the same?

Thanks

Do not use pipes. All network traffic, wireless or not, takes place on sockets.

On linux you can use local sockets, type PF_LOCAL. They are exactly the same as PF_INET sockets, only slightly simpler to configure, and they use a named file (like a FIFO). In terms of IPC, to "simulate" or actually engage a network, you must use sockets.

It sounds like you are trying to simulate the physical layer of wireless networks. In the simulation, you will have to simulate nodes not being visible to eachother - trying to enable that limitation in the actual IPC method would prove to be rather difficult. Use sockets (or other IPC methods), and either as part of the data sent across, or in a global map, you would have to define distance limitations. Meaning, each node would receive the data, but would have to decide if it should ignore it as it shouldn't be visible.

You want to simulate the fact that all hosts can "see" every packet, even those which are not destined for that host. The problem is that packets only have a momentary existence in reality. After they have been transmitted they vanish. So you are going to have to create some kind of data structure which queues up all the packets which are "on the air" at any given moment, allows all the hosts to have access to them, then somehow free them after an appropriate amount of time.

I suppose one way to do this would be to construct an "in flight" packet queue somewhere in shared memory. Each packet is queued into this shared area with some small lifetime. While the packet is in the buffer, a process (which simulates a host) can examine it, but it had better do it soon, because the buffer is continually getting flushed as packets expire.

It's going to depend on how accurate a representation of reality you want.