1. stdin/stdout

1.1 Sending Data to all Clients — stdout

#include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h>

int main() { int fd; char *myfifo = "/tmp/wspipein.fifo"; const char *msg = "Message to broadcast";

fd = open(myfifo, O_WRONLY); write(fd, msg, strlen(msg)); close(fd);

return 0; }

Note: You can send as many bytes PIPE_BUF can hold. If a message is greater than PIPE_BUF, it would send the rest on a second message or third, and so on. See strict mode below for more control over messages.

1.2 Receiving Data from Clients — stdin

Receiving data can be as simple as doing a # cat /tmp/wspipeout.fifo or you can do it in the language of your choice. See examples below.

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

static void read_message (int fd, fd_set set) { int bytes = 0; char buf[PIPE_BUF] = { 0 };

FD_ZERO (&set); FD_SET (fd, &set);

if ((select (fd + 1, &set, NULL, NULL, NULL)) < 1) exit (1); if (!FD_ISSET (fd, &set)) return;

if (read (fd, buf, PIPE_BUF) > 0) printf ("%s0, buf); }

int main (void) { fd_set set; char *fifo = "/tmp/wspipeout.fifo"; int fd = 0;

if ((fd = open (fifo, O_RDWR | O_NONBLOCK)) < 0) exit (1); while (1) read_message(fd, set);

return 0; }

Note: Make sure the reader in your application is set as non-blocking to get a constant feed.

Tip If you need to know which client sent the message, for example, in a chat application, please see the strict mode below.

2. Strict Mode

2. Data Format

The message header is a fixed-size header. The first 12 bytes (uint32_t) are packed in network byte order and contain the "meta-data" of the message we are sending/receiving. The rest of it is the actual message.

0 1 2 3 +---------------------------------------------+ | Client Socket Id (listener) | +---------------------------------------------+ | Message Type (binary: 0x2 / text: 0x1) | +---------------------------------------------+ | Payload length | +---------------------------------------------+ | Payload Data | +---------------------------------------------+

2.1 Sending Data — Strict Mode

Once the header has been written to the pipe, you may now write the message.

First, start the server in strict-mode.

# gwsocket --strict-mode #include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h>

size_t pack_uint32(void* buf, uint32_t val) { uint32_t v32 = htonl(val); memcpy(buf, &v32, sizeof(uint32_t)); return sizeof(uint32_t); }

int main() { char *p = calloc (sizeof(uint32_t) * 3, sizeof(char)), *ptr; const char *msg = "Message to broadcast"; const char *fifo = "/tmp/wspipein.fifo"; int fd;

ptr = p; ptr += pack_uint32(ptr, 0); ptr += pack_uint32(ptr, 0x01); ptr += pack_uint32(ptr, strlen(msg));

fd = open(fifo, O_WRONLY); write(fd, p, sizeof(uint32_t) * 3); write(fd, msg, strlen(msg)); close(fd); free (p);

return 0; }

2.2 Receiving Data from Clients — Strict Mode

First, start the server in strict-mode.

# gwsocket --strict-mode #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <limits.h> #include <int.h>

static size_t unpack_uint32 (const void *b, uint32_t * val) { uint32_t v32 = 0; memcpy (&v32, b, sizeof (uint32_t)); *val = ntohl (v32); return sizeof (uint32_t); }

static void read_message (int fd, fd_set set) { int bytes = 0; uint32_t size = 0, listener = 0, type = 0; char hdr[PIPE_BUF] = { 0 }, buf[PIPE_BUF] = {0}; char *ptr = NULL;

FD_ZERO (&set); FD_SET (fd, &set);

if ((select (fd + 1, &set, NULL, NULL, NULL)) < 1) exit (1); if (!FD_ISSET (fd, &set)) return;

if (hdr[0] == ' ') { if (read (fd, hdr, sizeof (uint32_t) * 3) < 1) return; }

ptr = hdr; ptr += unpack_uint32(ptr, &listener); ptr += unpack_uint32(ptr, &type); ptr += unpack_uint32(ptr, &size);

if (read (fd, buf, size) < 1) return;

printf ("client: %d, msg: %s0, listener, buf); }

int main (void) { fd_set set; char *fifo = "/tmp/wspipeout.fifo"; int fd = 0;

if ((fd = open (fifo, O_RDWR | O_NONBLOCK)) < 0) exit (1); while (1) read_message(fd, set);

return 0; }

Note: If you read/write to a stream, be aware that they do not necessarily read/write the full amount of data you have requested. Your application will need to handle the case where only a single byte is read or written. Examples above do not handle this.