11_tcp_ping_pong.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
// Example 11 -- TCP ping-pong over loopback.
//
// Where example 09 is a single echo, this is a sustained request/response loop:
// the client sends "ping" and waits for "pong" before sending the next one, for
// several rounds. Because each side waits for the other's reply, the two fibers
// alternate through the reactor -- one is always parked in an IO call while the
// other runs -- and the stream never coalesces messages, so every server read
// sees exactly one "ping".
//
// It is the canonical shape of a connection handler: accept (or connect), then
// loop reading a request and writing a response until the peer hangs up (a read
// of 0 bytes) or the exchange is done.
 
#include <arpa/inet.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
 
#include <serene/rt/fiber/io.h>
#include <serene/runtime.h>
 
#define ROUNDS 4000
 
typedef struct {
  int listener;
} server_args_t;
 
typedef struct {
  uint16_t port; // network byte order
} client_args_t;
 
static void set_nonblock(int fd) {
  int fl = fcntl(fd, F_GETFL, 0);
  (void)fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}
 
static srn_fiber_result_t server(srn_context_t *ctx, void *arg) {
  (void)ctx;
  server_args_t *s         = arg;
  srn_io_accept_result_t a = srn_fiber_accept(s->listener, nullptr, 0);
  if (HAS_ERROR(a)) {
    printf("server: accept failed: %s\n", a.maybe_error->msg);
    return nullptr;
  }
  int conn = a.fd;
 
  // Read a request, write a response, repeat until the peer closes.
  for (int i = 0; i < ROUNDS; i++) {
    char buf[16]           = {0};
    srn_io_size_result_t r = srn_fiber_read(conn, buf, sizeof(buf) - 1, -1);
    if (HAS_ERROR(r) || r.count == 0) {
      printf("server: peer closed after %d rounds\n", i);
      break;
    }
    buf[r.count] = '\0';
    printf("server: round %d got \"%s\", replying \"pong\"\n", i, buf);
    (void)srn_fiber_write(conn, "pong", 4, -1);
  }
 
  close(conn);
  return nullptr;
}
 
static srn_fiber_result_t client(srn_context_t *ctx, void *arg) {
  (void)ctx;
  client_args_t *c = arg;
  int fd           = socket(AF_INET, SOCK_STREAM, 0);
  if (fd < 0) {
    perror("socket");
    return nullptr;
  }
  set_nonblock(fd);
 
  struct sockaddr_in to = {.sin_family = AF_INET, .sin_port = c->port};
  to.sin_addr.s_addr    = htonl(INADDR_LOOPBACK);
 
  srn_error_t *err = srn_fiber_connect(fd, (struct sockaddr *)&to, sizeof(to));
  if (err != nullptr) {
    printf("client: connect failed: %s\n", err->msg);
    close(fd);
    return nullptr;
  }
 
  // Send a ping, wait for the pong, then send the next one.
  for (int i = 0; i < ROUNDS; i++) {
    (void)srn_fiber_write(fd, "ping", 4, -1);
    char buf[16]           = {0};
    srn_io_size_result_t r = srn_fiber_read(fd, buf, sizeof(buf) - 1, -1);
    if (HAS_ERROR(r) || r.count == 0) {
      printf("client: peer closed after %d rounds\n", i);
      break;
    }
    buf[r.count] = '\0';
    printf("client: round %d sent \"ping\", got \"%s\"\n", i, buf);
  }
 
  close(fd);
  return nullptr;
}
 
int main(void) {
  SERENE_RUNTIME_INIT_WITH_SCHED(engine, sched, nullptr);
  srn_context_t *ctx = srn_context_make(engine);
 
  int lst              = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in a = {.sin_family = AF_INET};
  a.sin_addr.s_addr    = htonl(INADDR_LOOPBACK);
  if (lst < 0 || bind(lst, (struct sockaddr *)&a, sizeof(a)) != 0 || listen(lst, 4) != 0) {
    perror("listener setup");
    return 1;
  }
  set_nonblock(lst);
  socklen_t al = sizeof(a);
  if (getsockname(lst, (struct sockaddr *)&a, &al) != 0) {
    perror("getsockname");
    return 1;
  }
 
  server_args_t s = {lst};
  client_args_t c = {a.sin_port};
  (void)srn_fiber_spawn(ctx, server, &s);
  (void)srn_fiber_spawn(ctx, client, &c);
 
  srn_sched_run(sched, 1);
  close(lst);
 
  srn_context_release(ctx);
  SERENE_RUNTIME_SHUTDOWN(engine);
  return 0;
}