#include <sys/socket.h>

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

/* Returns: file descriptor (non-negative) on success, -1 on error */

1. domain

Specifies where the communication happens and what address format is used. The most common values are AF_UNIX (same machine, pathname address), AF_INET (IPv4 network), and AF_INET6 (IPv6 network).

2. type

Specifies how data flows. The two standard values are:

• SOCK_STREAM – reliable, ordered, connection-based byte stream (TCP)
• SOCK_DGRAM – unreliable, connectionless, preserves message boundaries (UDP)

Since Linux kernel 2.6.27, you can also bitwise-OR additional flags into type (explained below).

3. protocol

For the socket types covered in this chapter, always pass 0. The kernel picks the appropriate protocol automatically. You only set a non-zero value for special cases like raw sockets (IPPROTO_RAW).

On success, socket() returns a new file descriptor — a small non-negative integer just like the fd returned by open(). This fd is used in all subsequent socket system calls (bind(), connect(), send(), recv(), etc.).

On failure, socket() returns -1 and sets errno.

The fd is now ready to be used with bind(), connect(), etc.

Starting from kernel 2.6.27, Linux allows you to OR two extra flags into the type argument. This saves extra fcntl() calls that you would otherwise need after creating the socket.

Example 1: Basic TCP socket creation

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>

int main(void)
{
    int sockfd;

    /* Create an IPv4 TCP stream socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    printf("Socket created successfully, fd = %d\n", sockfd);

    /* sockfd is now ready for bind() or connect() */
    close(sockfd);
    return 0;
}

Example 2: UDP socket (datagram)

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>

int main(void)
{
    int sockfd;

    /* Create an IPv4 UDP datagram socket */
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    printf("UDP socket fd = %d\n", sockfd);
    close(sockfd);
    return 0;
}

Example 3: Using SOCK_CLOEXEC and SOCK_NONBLOCK flags

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>

int main(void)
{
    int sockfd;

    /*
     * Create TCP socket with two extra flags OR-ed in:
     * SOCK_CLOEXEC  – auto-close on exec(), avoids race with fork+exec
     * SOCK_NONBLOCK – I/O calls return EAGAIN instead of blocking
     *
     * Requires Linux kernel >= 2.6.27
     */
    sockfd = socket(AF_INET,
                    SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
                    0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    printf("Non-blocking, close-on-exec TCP socket fd = %d\n", sockfd);
    close(sockfd);
    return 0;
}

Example 4: UNIX domain socket (same-machine IPC)

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>

int main(void)
{
    int sockfd;

    /* AF_UNIX = local IPC via filesystem path, no network needed */
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    printf("UNIX domain socket fd = %d\n", sockfd);
    close(sockfd);
    return 0;
}

Example 5: Equivalent using fcntl() (the old way)

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/socket.h>

int main(void)
{
    int sockfd, flags;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    /* Set O_NONBLOCK using fcntl (old method, two extra syscalls) */
    flags = fcntl(sockfd, F_GETFL);
    if (flags == -1) { perror("fcntl F_GETFL"); exit(1); }

    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl F_SETFL");
        exit(1);
    }

    /*
     * The SOCK_NONBLOCK flag at socket() creation avoids these
     * two extra fcntl() calls shown above.
     */

    printf("Non-blocking socket fd = %d (done via fcntl)\n", sockfd);
    close(sockfd);
    return 0;
}