NAME
       unix - sockets for local interprocess communication

SYNOPSIS
       #include <sys/socket.h>
       #include <sys/un.h>

       unix_socket = socket(AF_UNIX, type, 0);
       error = socketpair(AF_UNIX, type, 0, int *sv);

DESCRIPTION
       The AF_UNIX (also known as AF_LOCAL) socket family is used to communicate between processes on the same machine efficiently.  Traditionally, UNIX domain sockets can be either unnamed, or bound to a
       filesystem pathname (marked as being of type socket).  Linux also supports an abstract namespace which is independent of the filesystem.

...
satır 359 ->   Program source

       /*
        * File connection.h
        */

       #define SOCKET_NAME "/tmp/9Lq7BNBnBycd6nxy.socket"
       #define BUFFER_SIZE 12

       /*
        * File server.c
        */
...

NAME
       socket - create an endpoint for communication

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int socket(int domain, int type, int protocol);

DESCRIPTION
       socket()  creates  an  endpoint for communication and returns a file descriptor that refers to that endpoint.  The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

       The domain argument specifies a communication domain; this selects the protocol family which will be used for communication.  These families are defined in <sys/socket.h>.   The  formats  currently understood by the Linux kernel include:

       Name         Purpose                                    Man page
       AF_UNIX      Local communication                        unix(7)
       AF_LOCAL     Synonym for AF_UNIX
       AF_INET      IPv4 Internet protocols                    ip(7)
       AF_AX25      Amateur radio AX.25 protocol               ax25(4)
       AF_IPX       IPX - Novell protocols
       AF_APPLETALK AppleTalk                                  ddp(7)
       AF_X25       ITU-T X.25 / ISO-8208 protocol             x25(7)
       AF_INET6     IPv6 Internet protocols                    ipv6(7)
       AF_DECnet    DECet protocol sockets
       AF_KEY       Key  management protocol, originally de‐
                    veloped for usage with IPsec
       AF_NETLINK   Kernel user interface device               netlink(7)
       AF_PACKET    Low-level packet interface                 packet(7)
       AF_RDS       Reliable Datagram Sockets (RDS) protocol   rds(7)
                                                               rds-rdma(7)
...

EXAMPLES
       An example of the use of socket() is shown in getaddrinfo(3).

#define SOCKET_NAME "/tmp/test_socket.socket"
#define BUFFER_SIZE 1024

/*
* File server.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include "connection.h"

int
main(int argc, char *argv[])
{
   struct sockaddr_un name;
   int down_flag = 0;
   int ret;
   int connection_socket;
   int data_socket;
   int result;
   char buffer[BUFFER_SIZE];

   /* Create local socket. */

   connection_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
   if (connection_socket == -1) {
	   perror("socket");
	   exit(EXIT_FAILURE);
   }

   /*
	* For portability clear the whole structure, since some
	* implementations have additional (nonstandard) fields in
	* the structure.
	*/

   memset(&name, 0, sizeof(name));
			  /* Bind socket to socket name. */

   name.sun_family = AF_UNIX;
   strncpy(name.sun_path, SOCKET_NAME, sizeof(name.sun_path) - 1);

   ret = bind(connection_socket, (const struct sockaddr *) &name,
			  sizeof(name));
   if (ret == -1) {
	   perror("bind");
	   exit(EXIT_FAILURE);
   }

   /*
	* Prepare for accepting connections. The backlog size is set
	* to 20. So while one request is being processed other requests
	* can be waiting.
	*/

   ret = listen(connection_socket, 20);
   if (ret == -1) {
	   perror("listen");
	   exit(EXIT_FAILURE);
   }

   /* This is the main loop for handling connections. */

   for (;;) {

	   /* Wait for incoming connection. */

	   data_socket = accept(connection_socket, NULL, NULL);
	   if (data_socket == -1) {
		   perror("accept");
		   exit(EXIT_FAILURE);
	   }
					  result = 0;
	   for (;;) {

		   /* Wait for next data packet. */

		   ret = read(data_socket, buffer, sizeof(buffer));
		   if (ret == -1) {
			   perror("read");
			   exit(EXIT_FAILURE);
		   }

		   /* Ensure buffer is 0-terminated. */

		   buffer[sizeof(buffer) - 1] = 0;

		   /* Handle commands. */

		   if (!strncmp(buffer, "DOWN", sizeof(buffer))) {
			   down_flag = 1;
			   break;
		   }

		   if (!strncmp(buffer, "END", sizeof(buffer))) {
			   break;
		   }

		   /* Add received summand. */

		   result += atoi(buffer);
	   }

	   /* Send result. */

	   sprintf(buffer, "%d", result);
	   ret = write(data_socket, buffer, sizeof(buffer));
	   if (ret == -1) {
		   perror("write");
		   exit(EXIT_FAILURE);
	   }
					  /* Close socket. */

	   close(data_socket);

	   /* Quit on DOWN command. */

	   if (down_flag) {
		   break;
	   }
   }

   close(connection_socket);

   /* Unlink the socket. */

   unlink(SOCKET_NAME);

   exit(EXIT_SUCCESS);
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include "connection.h"

int
main(int argc, char *argv[])
{
   struct sockaddr_un addr;
   int ret;
   int data_socket;
   char buffer[BUFFER_SIZE];

   /* Create local socket. */

   data_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
   if (data_socket == -1) {
	   perror("socket");
	   exit(EXIT_FAILURE);
   }

   /*
	* For portability clear the whole structure, since some
	* implementations have additional (nonstandard) fields in
	* the structure.
	*/

   memset(&addr, 0, sizeof(addr));

   /* Connect socket to socket address */

   addr.sun_family = AF_UNIX;
   strncpy(addr.sun_path, SOCKET_NAME, sizeof(addr.sun_path) - 1);

   ret = connect(data_socket, (const struct sockaddr *) &addr,
				  sizeof(addr));
   if (ret == -1) {
	   fprintf(stderr, "The server is down.\n");
	   exit(EXIT_FAILURE);
   }
			  /* Send arguments. */

   for (int i = 1; i < argc; ++i) {
	   ret = write(data_socket, argv[i], strlen(argv[i]) + 1);
	   if (ret == -1) {
		   perror("write");
		   break;
	   }
   }

   /* Request result. */

   strcpy(buffer, "END");
   ret = write(data_socket, buffer, strlen(buffer) + 1);
   if (ret == -1) {
	   perror("write");
	   exit(EXIT_FAILURE);
   }

   /* Receive result. */

   ret = read(data_socket, buffer, sizeof(buffer));
   if (ret == -1) {
	   perror("read");
	   exit(EXIT_FAILURE);
   }

   /* Ensure buffer is 0-terminated. */

   buffer[sizeof(buffer) - 1] = 0;

   printf("Result = %s\n", buffer);

   /* Close socket. */

   close(data_socket);

   exit(EXIT_SUCCESS);
}

yasin@uxn-workstation:~/test/c/C-Sockets$ gcc unix-domain-server-socket.c -o unix-domain-server
yasin@uxn-workstation:~/test/c/C-Sockets$ gcc unix-domain-client.c -o unix-domain-client
yasin@uxn-workstation:~/test/c/C-Sockets$ ./unix-domain-server 2>&1 &
[1] 51925
yasin@uxn-workstation:~/test/c/C-Sockets$ ./unix-domain-client 1 2 3 4 5 6 7 8 9 10 
Result = 55
yasin@uxn-workstation:~/test/c/C-Sockets$ ./unix-domain-client DOWN
read: Connection reset by peer
[1]+  Bitti                   ./unix-domain-server 2>&1
yasin@uxn-workstation:~/test/c/C-Sockets$ 

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>

#define BUF_SIZE 500

int
main(int argc, char *argv[])
{
	struct addrinfo hints;
	struct addrinfo *result, *rp;
	int sfd, cfd, s;
	struct sockaddr_storage peer_addr;
	socklen_t peer_addr_len;
	ssize_t nread;
	char buf[BUF_SIZE];

	if (argc != 3) {
		fprintf(stderr, "Usage: %s ip %s port\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
	hints.ai_socktype = SOCK_STREAM; /* STREAM socket */
	hints.ai_flags = AI_PASSIVE;    /* For wildcard IP address */
	hints.ai_protocol = IPPROTO_TCP;          /* TCP protocol */
	hints.ai_canonname = NULL;
	hints.ai_addr = NULL;
	hints.ai_next = NULL;
   
	s = getaddrinfo(argv[1], argv[2], &hints, &result);
	if (s != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
		exit(EXIT_FAILURE);
	}

	/* getaddrinfo() returns a list of address structures.
	  Try each address until we successfully bind(2).
	  If socket(2) (or bind(2)) fails, we (close the socket
	  and) try the next address. */

	for (rp = result; rp != NULL; rp = rp->ai_next) {
		int  reuse = 1;

		sfd = socket(rp->ai_family, rp->ai_socktype,
		   rp->ai_protocol);
		if (sfd == -1)
			continue;

		if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
			break;                  /* Success */

		close(sfd);
	}

	freeaddrinfo(result);           /* No longer needed */

	if (rp == NULL) {               /* No address succeeded */
		fprintf(stderr, "Could not bind\n");
		exit(EXIT_FAILURE);
	}

	if (listen(sfd, 10) < 0) {
		fprintf(stderr, "Could not listen\n");
		exit(EXIT_FAILURE);
	}

	/* Read data and echo them back to sender */

	for (;;) {
		peer_addr_len = sizeof(peer_addr);

		cfd = accept(sfd, (struct sockaddr*) &peer_addr, &peer_addr_len);  /* accept blocks */
		if (cfd < 0) {
			continue;  /* Ignore failed request */
		}

		/* read from client */
		int i;
		
		for (i = 0; i < BUF_SIZE; i++) {
			char buf[BUF_SIZE + 1];
			memset(buf, '\0', sizeof(buf)); 
			int count = read(cfd, buf, sizeof(buf));
			
			if (count > 0) {
				char host[NI_MAXHOST], service[NI_MAXSERV];
				s = getnameinfo((struct sockaddr *) &peer_addr, 
								peer_addr_len, host, NI_MAXHOST,
								service, NI_MAXSERV, NI_NUMERICSERV);
				if (s == 0)
					printf("\nReceived %zd bytes from %s:%s the message is: %s\n", 
									count, host, service, buf);
				else
					fprintf(stderr, "getnameinfo: %s\n", gai_strerror(s));

				printf("The message sending back to the client : %s\n", buf);
				if (sendto(cfd, buf, count, 0,
						(struct sockaddr *) &peer_addr, peer_addr_len) != count)
					fprintf(stderr, "Error sending response\n");
			}
		}
		close(cfd);
	}
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUF_SIZE 500

int
main(int argc, char *argv[])
{
	struct addrinfo hints;
	struct addrinfo *result, *rp;
	int sfd, s;
	size_t len;
	ssize_t nread;
	char buf[BUF_SIZE];

	if (argc < 3) {
		fprintf(stderr, "Usage: %s host port msg...\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	/* Obtain address(es) matching host/port */

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
	hints.ai_socktype = SOCK_STREAM; /* STREAM socket */
	hints.ai_flags = 0;
	hints.ai_protocol = IPPROTO_TCP;          /* TCP protocol */

	s = getaddrinfo(argv[1], argv[2], &hints, &result);
	if (s != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
		exit(EXIT_FAILURE);
	}

	/* getaddrinfo() returns a list of address structures.
	Try each address until we successfully connect(2).
	If socket(2) (or connect(2)) fails, we (close the socket
	and) try the next address. */

	for (rp = result; rp != NULL; rp = rp->ai_next) {
		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if (sfd == -1)
			continue;

		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1)
			break;                  /* Success */

		close(sfd);
	}

	freeaddrinfo(result);           /* No longer needed */

	if (rp == NULL) {               /* No address succeeded */
		fprintf(stderr, "Could not connect\n");
		exit(EXIT_FAILURE);
	}

	/* Send remaining command-line arguments as separate
	datagrams, and read responses from server */

	for (int j = 3; j < argc; j++) {
		len = strlen(argv[j]) + 1;
		/* +1 for terminating null byte */

	if (len > BUF_SIZE) {
		fprintf(stderr,
		"Ignoring long message in argument %d\n", j);
		continue;
	}

	if (write(sfd, argv[j], len) != len) {
		fprintf(stderr, "partial/failed write\n");
		exit(EXIT_FAILURE);
	}

	nread = read(sfd, buf, BUF_SIZE);
	if (nread == -1) {
		perror("read");
		exit(EXIT_FAILURE);
	}

	printf("Received %zd bytes: %s\n", nread, buf);
	}

	exit(EXIT_SUCCESS);
}

yasin@uxn-workstation:~/test/c/C-Sockets$ gcc tcp-server-socket.c -o tcp-server
yasin@uxn-workstation:~/test/c/C-Sockets$ gcc tcp-client-socket.c -o tcp-client

yasin@uxn-workstation:~/test/c/C-Sockets$ ./tcp-server ::1 8484
yasin@uxn-workstation:~/test/c/C-Sockets$ ./tcp-client ::1 8484 "Selam!"

yasin@uxn-workstation:~/test/c/C-Sockets$ ./tcp-server 0.0.0.0 8484
yasin@uxn-workstation:~/test/c/C-Sockets$ ./tcp-client 127.0.0.1 8484 "Selam!"

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>

#define BUF_SIZE 500

int
main(int argc, char *argv[])
{
	struct addrinfo hints;
	struct addrinfo *result, *rp;
	int sfd, s;
	struct sockaddr_storage peer_addr;
	socklen_t peer_addr_len;
	ssize_t nread;
	char buf[BUF_SIZE];

	if (argc != 3) {
		fprintf(stderr, "Usage: %s ip %s port\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
	hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
	hints.ai_flags = AI_PASSIVE;    /* For wildcard IP address */
	hints.ai_protocol = IPPROTO_UDP;/* UDP protocol */
	hints.ai_canonname = NULL;
	hints.ai_addr = NULL;
	hints.ai_next = NULL;
   
	s = getaddrinfo(argv[1], argv[2], &hints, &result);
	if (s != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
		exit(EXIT_FAILURE);
	}

	/* getaddrinfo() returns a list of address structures.
	  Try each address until we successfully bind(2).
	  If socket(2) (or bind(2)) fails, we (close the socket
	  and) try the next address. */

	for (rp = result; rp != NULL; rp = rp->ai_next) {
		sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if (sfd == -1)
			continue;

		if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
			break;                  /* Success */

		close(sfd);
	}

	freeaddrinfo(result);           /* No longer needed */

	if (rp == NULL) {               /* No address succeeded */
		fprintf(stderr, "Could not bind\n");
		exit(EXIT_FAILURE);
	}


   /* Read datagrams and echo them back to sender */

	for (;;) {
		peer_addr_len = sizeof(peer_addr);
		nread = recvfrom(sfd, buf, BUF_SIZE, 0,
					(struct sockaddr *) &peer_addr, &peer_addr_len);
		if (nread == -1)
			continue;               /* Ignore failed request */

		char host[NI_MAXHOST], service[NI_MAXSERV];

		s = getnameinfo((struct sockaddr *) &peer_addr,
		peer_addr_len, host, NI_MAXHOST,
		service, NI_MAXSERV, NI_NUMERICSERV);
		if (s == 0)
			printf("\nReceived %zd bytes from %s:%s the message is: %s\n",
						nread, host, service, buf);
		else
			fprintf(stderr, "getnameinfo: %s\n", gai_strerror(s));

		printf("The message sending back to the client : %s\n", buf);
		if (sendto(sfd, buf, nread, 0,
						(struct sockaddr *) &peer_addr, peer_addr_len) != nread)
		fprintf(stderr, "Error sending response\n");
	}
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUF_SIZE 500

int
main(int argc, char *argv[])
{
	struct addrinfo hints;
	struct addrinfo *result, *rp;
	int sfd, s;
	size_t len;
	ssize_t nread;
	char buf[BUF_SIZE];

	if (argc < 3) {
		fprintf(stderr, "Usage: %s host port msg...\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	/* Obtain address(es) matching host/port */

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
	hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
	hints.ai_flags = 0;
	hints.ai_protocol = 0;          /* Any protocol */

	s = getaddrinfo(argv[1], argv[2], &hints, &result);
	if (s != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
		exit(EXIT_FAILURE);
	}

	/* getaddrinfo() returns a list of address structures.
	Try each address until we successfully connect(2).
	If socket(2) (or connect(2)) fails, we (close the socket
	and) try the next address. */

	for (rp = result; rp != NULL; rp = rp->ai_next) {
			sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
		if (sfd == -1)
			continue;

		if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1)
			break;                  /* Success */

		close(sfd);
	}

	freeaddrinfo(result);           /* No longer needed */

	if (rp == NULL) {               /* No address succeeded */
		fprintf(stderr, "Could not connect\n");
		exit(EXIT_FAILURE);
	}

	/* Send remaining command-line arguments as separate
	datagrams, and read responses from server */

	for (int j = 3; j < argc; j++) {
		len = strlen(argv[j]) + 1;
		/* +1 for terminating null byte */

		if (len > BUF_SIZE) {
			fprintf(stderr, "Ignoring long message in argument %d\n", j);
			continue;
		}

		if (write(sfd, argv[j], len) != len) {
			fprintf(stderr, "partial/failed write\n");
			exit(EXIT_FAILURE);
		}

		nread = read(sfd, buf, BUF_SIZE);
		if (nread == -1) {
			perror("read");
			exit(EXIT_FAILURE);
		}

		printf("Received %zd bytes: %s\n", nread, buf);
	}
	exit(EXIT_SUCCESS);
}

yasin@uxn-workstation:~/test/c/C-Sockets$ gcc udp-server-socket.c -o udp-server
yasin@uxn-workstation:~/test/c/C-Sockets$ gcc udp-client-socket.c -o udp-client

yasin@uxn-workstation:~/test/c/C-Sockets$ ./udp-server ::1 8484
yasin@uxn-workstation:~/test/c/C-Sockets$ ./udp-client ::1 8484 "Selam!"

yasin@uxn-workstation:~/test/c/C-Sockets$ ./udp-server 0.0.0.0 8484
yasin@uxn-workstation:~/test/c/C-Sockets$ ./udp-client 127.0.0.1 8484 "Selam!"