Чат (Сервер|Клиент) с UDP протоколом

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
 
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
 
/* SETTINGS */
 
#define MAX_CLIENTS 10
 
#define PORT 64546
#define BUFFLENGTH 256
 
#define WELCOME_MSG "Welcome, You have successfully connected to the server!"
 
typedef struct
{
  int active;
  unsigned short id, port;
  struct sockaddr_in data;
} member;
 
int main(int argc, char ** argv)
{
  char msg[BUFFLENGTH];
  socklen_t len;
 
  member members[MAX_CLIENTS];
 
  int sockfd, n;
  struct sockaddr_in server_addr, client_addr;
 
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  {
    perror("An error occurred while creating socket");
    return EXIT_FAILURE;
  }
 
  memset(&server_addr, 0x00, sizeof(server_addr));
 
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  server_addr.sin_port = htons(PORT);
 
  if (bind(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)))
  {
    perror("An error occurred while binding socket");
    return EXIT_FAILURE;
  }
 
  for (;;)
  {
    len = sizeof(client_addr);
    n = recvfrom(sockfd, msg, BUFFLENGTH, 0, (struct sockaddr *) &client_addr, &len);
 
    msg[n] = 0;
 
    printf("Received (IP: %s:%d): %s", inet_ntoa(client_addr.sin_addr), (int) ntohs(client_addr.sin_port), msg);
 
    sendto(sockfd, msg, n, 0, (struct sockaddr *) &client_addr, sizeof(client_addr));
  }
 
  close(sockfd);
  return EXIT_SUCCESS;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
 
/* SETTINGS */
 
#define MAX_CONNECTIONS 10
 
#define PORT 64546
#define BUFFLENGTH 256
 
#define LENGTH 20
 
int main(int argc, char ** argv)
{
  if (argc != 2)
  {
    printf("Usage: %s <ip> <port>\n", argv[0]);
    return EXIT_FAILURE;
  }
 
  char username[LENGTH];
 
  int sockfd, n;
  struct sockaddr_in server_addr, client_addr;
 
  char send[BUFFLENGTH];
  char recv[BUFFLENGTH];
 
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  {
    perror("An error occurred while creating socket");
    return EXIT_FAILURE;
  }
 
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  server_addr.sin_port = htons(PORT);
 
  while (fgets(send, BUFFLENGTH, stdin) != NULL)
  {
    if (sendto(sockfd, send, strlen(send), 0, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1)
    {
 
    }
    n = recvfrom(sockfd, recv, BUFFLENGTH, 0, NULL, NULL);
    recv[n] = 0;
    fputs(recv, stdout);
  }
 
  return EXIT_SUCCESS;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
#include <netinet/in.h>
#include <arpa/inet.h>
 
#include <sys/types.h>
#include <sys/socket.h>
 
/* SETTINGS */
 
#define PORT 64546
#define BUFFLENGTH 256
 
#define LENGTH 20
 
int main(int argc, char ** argv)
{
  if (argc != 3)
  {
    printf("Usage: %s <ip> <username>\n", argv[0]);
    return EXIT_FAILURE;
  }
 
  char username[LENGTH];
  strcpy(username, argv[2]);
 
  int sockfd, n;
  struct sockaddr_in server_addr;
 
  char send[BUFFLENGTH];
  char recv[BUFFLENGTH];
 
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  {
    perror("An error occurred while creating socket");
    return EXIT_FAILURE;
  }
 
  memset(&server_addr, 0, sizeof(server_addr));
 
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  server_addr.sin_port = htons(PORT);
 
  sendto(sockfd, username, LENGTH, 0, (struct sockaddr *) &server_addr, sizeof(server_addr));
 
  pid_t pid;
 
  if ((pid = fork()) < 0)
  {
    perror("An error occurred while forking");
    return EXIT_FAILURE;
  }
  else if (pid == 0)
  {
    for (;;)
    {
      n = recvfrom(sockfd, recv, BUFFLENGTH, 0, NULL, NULL);
      recv[n] = 0;
      fputs(recv, stdout);
    }
  }
  else
  {
    while (fgets(send, BUFFLENGTH, stdin) != NULL)
    {
      if (sendto(sockfd, send, strlen(send), 0, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1)
      {
        perror("An error occurred while sending message");
      }
    }
  }
 
  return EXIT_SUCCESS;
}

#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 201101L
#endif
 
#ifndef PERFORMANCE_TEST_ENABLED
#define PERFORMANCE_TEST_ENABLED 0
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
 
#include "chash.h"
 
#if PERFORMANCE_TEST_ENABLED
#include <time.h>
#endif
 
#include <netinet/in.h>
#include <arpa/inet.h>
 
#include <sys/types.h>
#include <sys/socket.h>
 
/* SETTINGS */
 
#define SERVERPORT 64546
#define BUFSIZE 256
 
#define WELCOME "Welcome, You have successfully connected to the server!\n"
 
typedef struct client
{
  char nickname[20];
  struct sockaddr_in data;
} client_t;
 
char * s_addr_to_string(struct sockaddr_in *address);
unsigned long hash(const void * value);
int compare(const void * x, const void * y);
 
char * s_addr_to_string(struct sockaddr_in *address)
{
  char *s = (char *) calloc(24, sizeof(char));
  sprintf(s, "%s:%d", inet_ntoa((*address).sin_addr), (int) ntohs((*address).sin_port));
  return s;
}
 
unsigned long hash(const void * value)
{
  unsigned long hash = 49613;
  int c;
  while ((c = *(char *) value++))
  {
    hash = ((hash << 5) + hash) + c;
  }
  return hash;
}
 
void printroom(void *key, void *value, void *state)
{
  printf("table[\"%s\"] = \"%d\"\n", (char *) key, value == NULL);
}
 
int compare(const void * x, const void * y)
{
  return strcmp((const char *) x, (const char *) y);
}
 
int main(int argc, char ** argv)
{
  printf("-------------------------------------------------------\n");
  printf("# Projekt: Chat mit Hut\n\n");
  printf("# B-BKSPP-PR\n");
  printf("# Authors: Nikolaj S. & Rafael F.\n\n");
 
  printf("# Datum: 22-12-2013\n\n");
 
  printf("# SDL 2.0.1 http://www.libsdl.org/download-2.0.php\n");
  printf("# CMAKE 2.8 http://www.cmake.org/cmake/resources/software.html\n");
  printf("-------------------------------------------------------\n");
 
  socklen_t socklen = sizeof(struct sockaddr_in);
 
#if PERFORMANCE_TEST_ENABLED
  struct timespec start, finish;
#endif
 
  char buffer[BUFSIZE];
 
  int sockfd, recvlen;
  void **s;
  struct sockaddr_in server_addr, client_addr;
 
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  {
    perror("An error occurred while creating socket");
    return EXIT_FAILURE;
  }
 
  memset((void *) &server_addr, 0, (size_t) socklen);
 
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  server_addr.sin_port = htons(SERVERPORT);
 
  if (bind(sockfd, (struct sockaddr *) &server_addr, socklen))
  {
    perror("An error occurred while binding socket");
    return EXIT_FAILURE;
  }
 
  hashtable_t *ht = hashtable_alloc(&hash, &compare, 0);
  char * key; //TODO: Don't forget to free!
  for (;;)
  {
#if PERFORMANCE_TEST_ENABLED
    clock_gettime(CLOCK_MONOTONIC, &start);
#endif
 
    if ((recvlen = recvfrom(sockfd, buffer, BUFSIZE, 0, (struct sockaddr *) &client_addr, &socklen)) > 0)
    {
      if ((s = hashtable_access(ht, key = s_addr_to_string(&client_addr), NULL)) == NULL)
      {
        client_t *cl = (client_t *) malloc(sizeof(client_t));
        (*cl).data = client_addr;
        strcpy((*cl).nickname, buffer);
 
        printf("%s (%s:%d) connected\n", (*cl).nickname, inet_ntoa((*cl).data.sin_addr), (int) ntohs((*cl).data.sin_port));
 
        if (sendto(sockfd, WELCOME, sizeof(WELCOME), 0, (struct sockaddr *) &(*cl).data, socklen) == -1)
        {
          perror("An error occurred while sending welcome message");
        }
        hashtable_access(ht, (void *) key, (void *) cl);
      }
      else
      {
        int outlen = recvlen + strlen((*(client_t *) (*s)).nickname) + 2;
        char * temp = calloc(outlen, sizeof(char));
 
        buffer[recvlen] = 0;
 
        sprintf(temp, "%s: %s", (*(client_t *) (*s)).nickname, buffer);
        printf("%s", temp);
 
        for (int i = 0; i < ht->size; i++)
        {
          if ((ht->buckets[i].key) != NULL)
          {
            sendto(sockfd, temp, outlen, 0, (struct sockaddr *) &(*(client_t*) ht->buckets[i].value).data, socklen);
          }
        }
        free(temp);
      }
    }
#if PERFORMANCE_TEST_ENABLED
    clock_gettime(CLOCK_MONOTONIC, &finish);
    printf("Executed in : %ld ns\n", (finish.tv_sec - start.tv_sec) * (1000000000l) + (finish.tv_nsec - start.tv_nsec));
#endif
  }
  hashtable_free(ht, &free, &free);
  close(sockfd);
  return EXIT_SUCCESS;
}