ਨਮਸਕਾਰ ਮੈਂ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ "ਲੀਨਕਸ API" ਕਿਤਾਬ ਪੇਸ਼ ਕਰਦਾ ਹਾਂ। ਇੱਕ ਵਿਆਪਕ ਗਾਈਡ" (ਕਿਤਾਬ ਦਾ ਅਨੁਵਾਦ ਲੀਨਕਸ ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ). ਇਸ ਨੂੰ ਪ੍ਰਕਾਸ਼ਕ ਦੀ ਵੈੱਬਸਾਈਟ 'ਤੇ ਆਰਡਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਪ੍ਰਚਾਰ ਕੋਡ ਲਾਗੂ ਕਰਦੇ ਹੋ LinuxAPI , ਤੁਹਾਨੂੰ 30% ਦੀ ਛੋਟ ਮਿਲੇਗੀ।

ਹਵਾਲੇ ਲਈ ਕਿਤਾਬ ਤੋਂ ਅੰਸ਼:

ਸਾਕਟ: ਸਰਵਰ ਆਰਕੀਟੈਕਚਰ

ਇਸ ਅਧਿਆਇ ਵਿੱਚ, ਅਸੀਂ ਦੁਹਰਾਓ ਅਤੇ ਸਮਾਨਾਂਤਰ ਸਰਵਰਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ, ਅਤੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਡੈਮਨ ਨੂੰ ਵੀ ਦੇਖਾਂਗੇ, ਜਿਸਨੂੰ inetd ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਇੰਟਰਨੈਟ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

ਦੁਹਰਾਓ ਅਤੇ ਸਮਾਂਤਰ ਸਰਵਰ

ਦੋ ਆਮ ਸਾਕਟ-ਅਧਾਰਿਤ ਨੈੱਟਵਰਕ ਸਰਵਰ ਆਰਕੀਟੈਕਚਰ ਹਨ:

• ਦੁਹਰਾਓ: ਸਰਵਰ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਗਾਹਕਾਂ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ, ਪਹਿਲਾਂ ਇੱਕ ਕਲਾਇੰਟ ਤੋਂ ਇੱਕ ਬੇਨਤੀ (ਜਾਂ ਕਈ ਬੇਨਤੀਆਂ) ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਅਗਲੇ ਵਿੱਚ ਜਾਂਦਾ ਹੈ;

• ਸਮਾਨਾਂਤਰ: ਸਰਵਰ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਗਾਹਕਾਂ ਦੀ ਸੇਵਾ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ।

FIFO ਕਤਾਰਾਂ 'ਤੇ ਅਧਾਰਤ ਇੱਕ ਦੁਹਰਾਉਣ ਵਾਲੇ ਸਰਵਰ ਦੀ ਉਦਾਹਰਨ ਪਹਿਲਾਂ ਹੀ ਸੈਕਸ਼ਨ 44.8 ਵਿੱਚ ਪੇਸ਼ ਕੀਤੀ ਗਈ ਹੈ।

ਦੁਹਰਾਉਣ ਵਾਲੇ ਸਰਵਰ ਆਮ ਤੌਰ 'ਤੇ ਸਿਰਫ਼ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਹੀ ਢੁਕਵੇਂ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਕਲਾਇੰਟ ਦੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਕਾਫ਼ੀ ਤੇਜ਼ੀ ਨਾਲ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਹਰੇਕ ਕਲਾਇੰਟ ਨੂੰ ਉਦੋਂ ਤੱਕ ਇੰਤਜ਼ਾਰ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਸ ਦੇ ਸਾਹਮਣੇ ਕੋਈ ਹੋਰ ਕਲਾਇੰਟਸ ਦੀ ਸੇਵਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ। ਇਸ ਪਹੁੰਚ ਲਈ ਇੱਕ ਆਮ ਵਰਤੋਂ ਦਾ ਕੇਸ ਇੱਕ ਕਲਾਇੰਟ ਅਤੇ ਸਰਵਰ ਵਿਚਕਾਰ ਸਿੰਗਲ ਬੇਨਤੀਆਂ ਅਤੇ ਜਵਾਬਾਂ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਹੈ।

ਪੈਰਲਲ ਸਰਵਰ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਢੁਕਵੇਂ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਹਰੇਕ ਬੇਨਤੀ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਜਾਂ ਜਿੱਥੇ ਕਲਾਇੰਟ ਅਤੇ ਸਰਵਰ ਲੰਬੇ ਸੰਦੇਸ਼ਾਂ ਦੇ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਇਸ ਅਧਿਆਇ ਵਿੱਚ, ਅਸੀਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਮਾਨਾਂਤਰ ਸਰਵਰਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੇ ਰਵਾਇਤੀ (ਅਤੇ ਸਰਲ) ਤਰੀਕੇ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਾਂਗੇ, ਜੋ ਕਿ ਹਰੇਕ ਨਵੇਂ ਕਲਾਇੰਟ ਲਈ ਇੱਕ ਵੱਖਰੀ ਬਾਲ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣਾ ਹੈ। ਇਹ ਪ੍ਰਕਿਰਿਆ ਗਾਹਕ ਦੀ ਸੇਵਾ ਕਰਨ ਲਈ ਸਾਰਾ ਕੰਮ ਕਰਦੀ ਹੈ ਅਤੇ ਫਿਰ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਕਿਉਂਕਿ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦੀ ਹੈ, ਇੱਕੋ ਸਮੇਂ ਕਈ ਗਾਹਕਾਂ ਦੀ ਸੇਵਾ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਮੁੱਖ ਸਰਵਰ ਪ੍ਰਕਿਰਿਆ (ਮਾਪਿਆਂ) ਦਾ ਮੁੱਖ ਕੰਮ ਹਰੇਕ ਨਵੇਂ ਕਲਾਇੰਟ ਲਈ ਇੱਕ ਵੱਖਰਾ ਬੱਚਾ ਬਣਾਉਣਾ ਹੈ (ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ, ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਬਜਾਏ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਥਰਿੱਡ ਬਣਾਏ ਜਾ ਸਕਦੇ ਹਨ)।

ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਵਿੱਚ, ਅਸੀਂ ਦੁਹਰਾਉਣ ਵਾਲੇ ਅਤੇ ਸਮਾਨਾਂਤਰ ਇੰਟਰਨੈਟ ਡੋਮੇਨ ਸਾਕਟ ਸਰਵਰਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇਖਾਂਗੇ। ਇਹ ਦੋ ਸਰਵਰ ਈਕੋ ਸੇਵਾ (RFC 862) ਦਾ ਇੱਕ ਸਰਲ ਸੰਸਕਰਣ ਲਾਗੂ ਕਰਦੇ ਹਨ, ਜੋ ਕਿ ਇੱਕ ਕਲਾਇੰਟ ਦੁਆਰਾ ਇਸ ਨੂੰ ਭੇਜੇ ਗਏ ਕਿਸੇ ਵੀ ਸੰਦੇਸ਼ ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਦੁਹਰਾਉਣ ਵਾਲਾ UDP ਸਰਵਰ ਈਕੋ

ਇਸ ਅਤੇ ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਈਕੋ ਸੇਵਾ ਲਈ ਸਰਵਰਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਾਂਗੇ। ਇਹ ਪੋਰਟ ਨੰਬਰ 7 'ਤੇ ਉਪਲਬਧ ਹੈ ਅਤੇ UDP ਅਤੇ TCP ਦੋਵਾਂ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ (ਇਹ ਪੋਰਟ ਰਿਜ਼ਰਵ ਹੈ, ਅਤੇ ਇਸਲਈ ਈਕੋ ਸਰਵਰ ਨੂੰ ਪ੍ਰਬੰਧਕ ਦੇ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਨਾਲ ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ)।

ਈਕੋ UDP ਸਰਵਰ ਲਗਾਤਾਰ ਡਾਟਾਗ੍ਰਾਮ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਭੇਜਣ ਵਾਲੇ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਕਾਪੀਆਂ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਿਉਂਕਿ ਸਰਵਰ ਨੂੰ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਸੰਦੇਸ਼ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇੱਕ ਦੁਹਰਾਓ ਢਾਂਚਾ ਕਾਫੀ ਹੋਵੇਗਾ। ਸਰਵਰਾਂ ਲਈ ਸਿਰਲੇਖ ਫਾਈਲ ਸੂਚੀ 56.1 ਵਿੱਚ ਦਿਖਾਈ ਗਈ ਹੈ।

ਸੂਚੀ 56.1. ਪ੍ਰੋਗਰਾਮਾਂ ਲਈ ਹੈਡਰ ਫਾਈਲ id_echo_sv.c ਅਤੇ id_echo_cl.c

#include "inet_sockets.h" /* ਸਾਡੇ ਸਾਕਟ ਫੰਕਸ਼ਨਾਂ ਦਾ ਐਲਾਨ ਕਰਦਾ ਹੈ */
# "tlpi_hdr.h" ਸ਼ਾਮਲ ਕਰੋ

# ਪਰਿਭਾਸ਼ਿਤ ਸੇਵਾ "ਈਕੋ" /* UDP ਸੇਵਾ ਨਾਮ */

# ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ BUF_SIZE 500 /* ਡੇਟਾਗ੍ਰਾਮ ਦਾ ਅਧਿਕਤਮ ਆਕਾਰ ਜੋ
ਕਲਾਇੰਟ ਅਤੇ ਸਰਵਰ ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ */
_____________________________________________________________________ ਸਾਕਟ/id_echo.h

ਸੂਚੀ 56.2 ਸਰਵਰ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਹੇਠ ਲਿਖੇ ਨੁਕਤੇ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹਨ:

• ਸਰਵਰ ਨੂੰ ਡੈਮਨ ਮੋਡ ਵਿੱਚ ਪਾਉਣ ਲਈ, ਅਸੀਂ ਸੈਕਸ਼ਨ 37.2 ਤੋਂ becomeDaemon() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ;

• ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਹੋਰ ਸੰਖੇਪ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਸੈਕਸ਼ਨ 55.12 ਵਿੱਚ ਵਿਕਸਤ, ਇੰਟਰਨੈਟ ਡੋਮੇਨ ਸਾਕਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ;

• ਜੇਕਰ ਸਰਵਰ ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਨਹੀਂ ਦੇ ਸਕਦਾ ਹੈ, ਤਾਂ ਇਹ syslog() ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗ ਨੂੰ ਸੁਨੇਹਾ ਲਿਖਦਾ ਹੈ।

ਇੱਕ ਅਸਲ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ, ਅਸੀਂ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ syslog() ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਲੌਗ ਕਰਨ ਦੀ ਬਾਰੰਬਾਰਤਾ 'ਤੇ ਕੁਝ ਸੀਮਾ ਲਗਾਵਾਂਗੇ। ਇਹ ਸਿਸਟਮ ਲੌਗ ਨੂੰ ਓਵਰਫਲੋ ਕਰਨ ਵਾਲੇ ਹਮਲਾਵਰ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਖਤਮ ਕਰ ਦੇਵੇਗਾ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਨਾ ਭੁੱਲੋ ਕਿ syslog() ਲਈ ਹਰੇਕ ਕਾਲ ਕਾਫ਼ੀ ਮਹਿੰਗੀ ਹੈ, ਕਿਉਂਕਿ ਇਹ fsync() ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਵਰਤਦਾ ਹੈ।

ਸੂਚੀ 56.2. ਦੁਹਰਾਓ ਸਰਵਰ ਜੋ UDP ਈਕੋ ਸੇਵਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ

_____________________________________________________________________ ਸਾਕਟ/id_echo_sv.c
#ਸ਼ਾਮਲ
# "id_echo.h" ਸ਼ਾਮਲ ਕਰੋ
# "become_daemon.h" ਸ਼ਾਮਲ ਕਰੋ

ਇੰਟ
ਮੁੱਖ (int argc, char *argv[])
{
int sfd;
ssize_t numRead;
socklen_t len;
struct sockaddr_storage claddr;
char buf[BUF_SIZE];
char addrStr[IS_ADDR_STR_LEN];

ਜੇਕਰ (ਬਣ ਗਿਆ ਡੈਮਨ(0) == -1)
errExit("becomeDaemon");

sfd = inetBind(ਸੇਵਾ, SOCK_DGRAM, NULL);
ਜੇਕਰ (sfd == -1) {
syslog(LOG_ERR, "ਸਰਵਰ ਸਾਕਟ ਨਹੀਂ ਬਣਾਇਆ ਜਾ ਸਕਿਆ (%s)",
strerror(errno));
ਨਿਕਾਸ (EXIT_FAILURE);

/* ਡੇਟਾਗ੍ਰਾਮ ਪ੍ਰਾਪਤ ਕਰੋ ਅਤੇ ਭੇਜਣ ਵਾਲਿਆਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਕਾਪੀਆਂ ਵਾਪਸ ਕਰੋ */
}
ਲਈ (;;) {
len = sizeof(struct sockaddr_storage);
numRead = recvfrom(sfd, buf, BUF_SIZE, 0, (struct sockaddr *) &claddr, &len);

ਜੇਕਰ (numRead == -1)
errExit("recvfrom");
if (sendto(sfd, buf, numRead, 0, (struct sockaddr *) &claddr, len)
!= numRead)
syslog(LOG_WARNING, "%s (%s) ਦੇ ਜਵਾਬ ਨੂੰ ਗੂੰਜਣ ਵਿੱਚ ਗਲਤੀ",
inetAddressStr((struct sockaddr*) &claddr, len,
addrStr, IS_ADDR_STR_LEN),
strerror(errno));
}
}
_____________________________________________________________________ ਸਾਕਟ/id_echo_sv.c

ਸਰਵਰ ਦੀ ਕਾਰਵਾਈ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਅਸੀਂ ਸੂਚੀ 56.3 ਤੋਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇਹ ਸੈਕਸ਼ਨ 55.12 ਵਿੱਚ ਵਿਕਸਤ, ਇੰਟਰਨੈਟ ਡੋਮੇਨ ਸਾਕਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰਦਾ ਹੈ। ਪਹਿਲੀ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਵਜੋਂ, ਕਲਾਇੰਟ ਪ੍ਰੋਗਰਾਮ ਉਸ ਨੈੱਟਵਰਕ ਨੋਡ ਦਾ ਨਾਮ ਲੈਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਸਰਵਰ ਸਥਿਤ ਹੈ। ਕਲਾਇੰਟ ਇੱਕ ਲੂਪ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਸਰਵਰ ਨੂੰ ਵੱਖਰੇ ਡੇਟਾਗ੍ਰਾਮਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਬਾਕੀ ਬਚੇ ਹਰੇਕ ਆਰਗੂਮੈਂਟ ਨੂੰ ਭੇਜਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਜਵਾਬ ਵਿੱਚ ਸਰਵਰ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾਗ੍ਰਾਮਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਅਤੇ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ।

ਸੂਚੀ 56.3. UDP ਈਕੋ ਸੇਵਾ ਲਈ ਕਲਾਇੰਟ

# "id_echo.h" ਸ਼ਾਮਲ ਕਰੋ

ਇੰਟ
ਮੁੱਖ (int argc, char *argv[])
{
int sfd, j;
ਆਕਾਰ_ਟੀ ਲੈਨ;
ssize_t numRead;
char buf[BUF_SIZE];

ਜੇਕਰ (argc < 2 || strcmp(argv[1], "--help") == 0)
usageErr("%s host msg…n", argv[0]);

/* ਪਹਿਲੀ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਦੇ ਅਧਾਰ ਤੇ ਸਰਵਰ ਐਡਰੈੱਸ ਬਣਾਓ */
sfd = inetConnect(argv[1], SERVICE, SOCK_DGRAM);
ਜੇਕਰ (sfd == -1)
ਘਾਤਕ ("ਸਰਵਰ ਸਾਕਟ ਨਾਲ ਕਨੈਕਟ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਿਆ");

/* ਬਾਕੀ ਬਚੇ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਵੱਖਰੇ ਡੇਟਾਗ੍ਰਾਮ ਦੇ ਰੂਪ ਵਿੱਚ ਸਰਵਰ ਨੂੰ ਭੇਜੋ */
ਲਈ (j = 2; j < argc; j++) {
len = strlen(argv[j]);
ਜੇਕਰ (ਲਿਖੋ(sfd, argv[j], len) != len)
ਘਾਤਕ ("ਅੰਸ਼ਕ/ਅਸਫ਼ਲ ਲਿਖਤ");

numRead = ਪੜ੍ਹੋ(sfd, buf, BUF_SIZE);
ਜੇਕਰ (numRead == -1)
errExit("ਪੜ੍ਹੋ");
printf("[%ld ਬਾਈਟਸ] %.*sn", (long) numRead, (int) numRead, buf);
}
ਨਿਕਾਸ (EXIT_SUCCESS);
}
_____________________________________________________________________ ਸਾਕਟ/id_echo_cl.c

ਹੇਠਾਂ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਕਿ ਅਸੀਂ ਸਰਵਰ ਅਤੇ ਦੋ ਕਲਾਇੰਟ ਉਦਾਹਰਨਾਂ ਨੂੰ ਚਲਾਉਣ ਵੇਲੇ ਕੀ ਦੇਖਾਂਗੇ:

$su // ਰਿਜ਼ਰਵਡ ਪੋਰਟ ਨਾਲ ਜੋੜਨ ਲਈ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ
ਪਾਸਵਰਡ:
# ./id_echo_sv // ਸਰਵਰ ਬੈਕਗ੍ਰਾਉਂਡ ਮੋਡ ਵਿੱਚ ਜਾਂਦਾ ਹੈ
# ਬਾਹਰ ਨਿਕਲੋ // ਪ੍ਰਸ਼ਾਸਕ ਦੇ ਅਧਿਕਾਰ ਛੱਡੋ
$ ./id_echo_cl localhost hello world // ਇਹ ਕਲਾਇੰਟ ਦੋ ਡਾਟਾਗ੍ਰਾਮ ਭੇਜਦਾ ਹੈ
[5 ਬਾਈਟਸ] ਹੈਲੋ // ਕਲਾਇੰਟ ਸਰਵਰ ਤੋਂ ਪ੍ਰਾਪਤ ਜਵਾਬ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ
[5 ਬਾਈਟ] ਸੰਸਾਰ
$ ./id_echo_cl ਲੋਕਲਹੋਸਟ ਅਲਵਿਦਾ // ਇਹ ਕਲਾਇੰਟ ਇੱਕ ਡੇਟਾਗ੍ਰਾਮ ਭੇਜਦਾ ਹੈ
[7 ਬਾਈਟਸ] ਅਲਵਿਦਾ

ਮੈਂ ਤੁਹਾਨੂੰ ਇੱਕ ਸੁਹਾਵਣਾ ਪੜ੍ਹਨ ਦੀ ਕਾਮਨਾ ਕਰਦਾ ਹਾਂ)

ਸਰੋਤ: linux.org.ru