C-IPC/client.c

#include "commands.h"
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <unistd.h>

#define send(queue_id, msgbuf_ptr)                                             \
  msgsnd(queue_id, msgbuf_ptr, sizeof(*(msgbuf_ptr)) - sizeof(long), 0)

static void cleanup_queue(int qid) {
  if (qid != -1) {
    msgctl(qid, IPC_RMID, NULL);
  }
}

int main(int argc, char *argv[]) {
  if (argc < 2) {
    fprintf(stderr, "Usage: %s <client_id>\n", argv[0]);
    return 1;
  }

  char *client_id = argv[1];

  int client_queue_id = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
  if (client_queue_id == -1) {
    perror("msgget(client) failed");
    return 1;
  }

  int server_queue_id = -1;
  const char *id_path = "/home/piotr/server_queue_id";
  FILE *f = fopen(id_path, "rb");

  if (fread(&server_queue_id, sizeof(int), 1, f) != 1) {
    fprintf(stderr, "Failed to read server queue id from %s\n", id_path);
    server_queue_id = -1;
  }
  fclose(f);

  msgbuf_t msg;
  memset(&msg, 0, sizeof(msgbuf_t));
  msg.mtype = Login;
  /* command field holds client id for login */
  strncpy(msg.command, client_id, COMMAND_LENGTH - 1);
  /* message field holds the client's queue id as string */
  snprintf(msg.message, MESSAGE_LENGTH, "%d", client_queue_id);

  if (msgsnd(server_queue_id, &msg, sizeof(msg) - sizeof(long), 0) == -1) {
    perror("msgsnd(login) failed");
    cleanup_queue(client_queue_id);
    return 1;
  }

  /* Wait for login response (server replies with mtype = Login) */
  msgbuf_t resp;
  ssize_t r =
      msgrcv(client_queue_id, &resp, sizeof(resp) - sizeof(long), Login, 0);
  if (r == -1) {
    perror("msgrcv(login response) failed");
    cleanup_queue(client_queue_id);
    return 1;
  }

  if (resp.stype != ACK_ACCEPTED) {
    fprintf(stderr, "Login rejected: code=%d\n", resp.stype);
    cleanup_queue(client_queue_id);
    return 1;
  }

  printf("Login accepted for id '%s'\n", client_id);

  /* Send a test message to the server */
  msgbuf_t test = {
      .mtype = Message,
      .sender = "the_only_one",
  };
  snprintf(test.message, MESSAGE_LENGTH, "Hello from %s", client_id);

  if (msgsnd(server_queue_id, &test, sizeof(test) - sizeof(long), 0) == -1) {
    printf("DEBUG: test.mtype = %u\n", test.mtype);
    perror("failed while sending a test message");
    cleanup_queue(client_queue_id);
    return 1;
  }

  printf("Sent test message to server: \"%s\"\n", test.message);

  /* Now wait for server forwarded message(s) and a signal ack.
     We'll wait until we've seen both a Message and a Signal ack or timeout. */
  int seen_message = 0;
  int seen_ack = 0;
  const int MAX_ITER = 10;

  // for (int i = 0; i < MAX_ITER && !(seen_message && seen_ack); ++i) {
  while (1) {
    msgbuf_t incoming;
    ssize_t got = msgrcv(client_queue_id, &incoming,
                         sizeof(incoming) - sizeof(long), 0, 0);
    perror("Got a message damn");
    if (got == -1) {
        perror("msgrcv(incoming) failed");

      if (errno == EINTR) {
        continue;
      }
      perror("msgrcv(incoming) failed");
      break;
    }

    switch (incoming.mtype) {
    case Message:
      printf("Received Message: \"%s\"\n", incoming.message);
      seen_message = 1;
      break;
    case Signal:
      printf("Received Signal: code=%d\n", incoming.stype);
      if (incoming.stype == ACK_ACCEPTED || incoming.stype == ACK_DELIVERED) {
        seen_ack = 1;
      }
      break;
    default:
      printf("Received unknown mtype=%ld stype=%d\n", (long)incoming.mtype,
             incoming.stype);
      break;
    }
  }

  if (!seen_message) {
    fprintf(stderr, "Did not receive forwarded message from server\n");
  }
  if (!seen_ack) {
    fprintf(stderr, "Did not receive ack from server\n");
  }

  /* Logout/cleanup: remove our queue */
  cleanup_queue(client_queue_id);
  printf("Client exiting\n");
  return 0;
}