फोर्क का उपयोग करके C में मल्टी-प्रोसेस सॉकेट सर्वर बनाएं

परिचय

C में फोर्क के साथ एक मल्टी-प्रोसेसिंग सॉकेट सर्वर हमें एकाधिक क्लाइंट कनेक्शन को समवर्ती रूप से संभालने की अनुमति देता है। फोर्क सिस्टम कॉल का उपयोग करके, सर्वर प्रत्येक कनेक्टेड क्लाइंट के लिए चाइल्ड प्रक्रियाएं बना सकता है जो स्वतंत्र संचार चैनल सुनिश्चित करता है। यह दृष्टिकोण एकाधिक क्लाइंट के साथ एक साथ संचार सक्षम बनाता है।

आइए चर्चा करें कि C में फोर्क के साथ मल्टी-प्रोसेसिंग सॉकेट सर्वर को कैसे लागू किया जाए। हम सर्वर-साइड प्रोग्राम और क्लाइंट-साइड प्रोग्राम के प्रोग्रामिंग उदाहरणों के बारे में बताएंगे जिनके द्वारा हम C में फोर्क के साथ मल्टी-प्रोसेसिंग सॉकेट सर्वर प्राप्त कर सकते हैं।

फोर्क सिस्टम कॉल क्या है?

जब एक सिस्टम कॉल किसी मौजूदा प्रक्रिया का क्लोन बनाता है, तो इसे "fork()" सिस्टम कॉल कहा जाता है। यह अनिवार्य रूप से चल रहे प्रोग्राम को दो अलग-अलग प्रक्रियाओं में विभाजित करता है जिन्हें पैरेंट और चाइल्ड के रूप में जाना जाता है। चाइल्ड और पैरेंट प्रक्रियाओं के लिए सभी पैरामीटर समान हैं सिवाय इसके कि उनके अलग-अलग PID हैं। यह सिस्टम कॉल निम्नलिखित लौटाता है:

1. पैरेंट को चाइल्ड प्रक्रिया का PID
2. चाइल्ड को शून्य (0)

प्रोग्रामिंग उदाहरण 1: सर्वर-साइड प्रोग्राम

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#define PORT 8888

int main() {
    int serSoc, cliSoc;
    struct sockaddr_in serverAddr, clientAddr;
    socklen_t addrSize = sizeof(clientAddr);
    char buffer[1024];
    int clientCount = 0;

    // सर्वर सॉकेट बनाएं
    serSoc = socket(AF_INET, SOCK_STREAM, 0);
    if (serSoc < 0) {
        perror("सॉकेट निर्माण में त्रुटि");
        exit(1);
    }

    printf("सर्वर सॉकेट बनाया गया।\n");

    // सर्वर पता सेट करें
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(serSoc, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("बाइंडिंग में त्रुटि");
        exit(1);
    }

    // आने वाले कनेक्शन के लिए सुनना शुरू करें
    if (listen(serSoc, 5) == 0) {
        printf("कनेक्शन के लिए सुन रहे हैं...\n");
    } else {
        perror("सुनने में त्रुटि");
        exit(1);
    }

    while (1) {
        // क्लाइंट कनेक्शन स्वीकार करें
        cliSoc = accept(serSoc, (struct sockaddr*)&clientAddr, &addrSize);
        if (cliSoc < 0) {
            perror("कनेक्शन स्वीकार करने में त्रुटि");
            exit(1);
        }

        // क्लाइंट काउंट बढ़ाएं और क्लाइंट जानकारी प्रदर्शित करें
        clientCount++;
        printf("क्लाइंट %d से कनेक्शन स्वीकार किया गया: %s:%d\n", clientCount, inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
        printf("कुल कनेक्टेड क्लाइंट: %d\n", clientCount);

        pid_t pid = fork();

        if (pid == 0) {
            // चाइल्ड प्रक्रिया
            close(serSoc);

            // क्लाइंट से संदेश प्राप्त करें
            while (1) {
                memset(buffer, 0, sizeof(buffer));
                if (recv(cliSoc, buffer, sizeof(buffer), 0) < 0) {
                    perror("डेटा प्राप्त करने में त्रुटि");
                    exit(1);
                }

                printf("क्लाइंट %d से डेटा प्राप्त: %s\n", clientCount, buffer);

                // प्राप्त संदेश को क्लाइंट को वापस इको करें
                if (send(cliSoc, buffer, strlen(buffer), 0) < 0) {
                    perror("डेटा भेजने में त्रुटि");
                    exit(1);
                }
            }
        } else if (pid > 0) {
            // पैरेंट प्रक्रिया
            close(cliSoc);
        } else {
            perror("फोर्किंग में त्रुटि");
            exit(1);
        }
    }

    // सर्वर सॉकेट बंद करें
    close(serSoc);

    return 0;
}

प्रोग्रामिंग उदाहरण 2: क्लाइंट-साइड प्रोग्राम

#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#define PORT 8888
#define SERVER_IP "127.0.0.1"

int main() {
    int cliSoc;
    struct sockaddr_in serverAddr;
    char buffer[1024];

    // क्लाइंट सॉकेट बनाएं
    cliSoc = socket(AF_INET, SOCK_STREAM, 0);
    if (cliSoc < 0) {
        perror("सॉकेट निर्माण में त्रुटि");
        exit(1);
    }

    printf("क्लाइंट %d सॉकेट बनाया गया।\n", getpid());

    // सर्वर पता पैरामीटर सेट करें
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);

    // सर्वर से कनेक्ट करें
    if (connect(cliSoc, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
        perror("सर्वर से कनेक्ट करने में त्रुटि");
        exit(1);
    }

    printf("सर्वर से कनेक्टेड।\n");
    while (1) {
        // उपयोगकर्ता से इनपुट पढ़ें
        printf("क्लाइंट %d - एक संदेश दर्ज करें: ", getpid());
        fgets(buffer, sizeof(buffer), stdin);

        if (send(cliSoc, buffer, strlen(buffer), 0) < 0) {
            perror("डेटा भेजने में त्रुटि");
            exit(1);
        }

        // सर्वर से प्रतिक्रिया प्राप्त करें
        memset(buffer, 0, sizeof(buffer));
        if (recv(cliSoc, buffer, sizeof(buffer), 0) < 0) {
            perror("डेटा प्राप्त करने में त्रुटि");
            exit(1);
        }
        printf("क्लाइंट %d - सर्वर प्रतिक्रिया: %s\n", getpid(), buffer);
    }

    // क्लाइंट सॉकेट बंद करें
    close(cliSoc);
    return 0;
}

आउटपुट

सर्वर प्रोग्राम संकलन

$ gcc ser.c -o ser
$ ./ser
सर्वर सॉकेट बनाया गया।
कनेक्शन के लिए सुन रहे हैं...
सर्वर सॉकेट बनाया गया।
कनेक्शन के लिए सुन रहे हैं...
क्लाइंट 1 से कनेक्शन स्वीकार किया गया: 127.0.0.1:59074
कुल कनेक्टेड क्लाइंट: 1
क्लाइंट 1 से डेटा प्राप्त: hii admin
क्लाइंट 2 से कनेक्शन स्वीकार किया गया: 127.0.0.1:40192
कुल कनेक्टेड क्लाइंट: 2
क्लाइंट 2 से डेटा प्राप्त: hello everybody

क्लाइंट 1 प्रोग्राम संकलन

$ gcc cel.c -o cel
$ ./cel
क्लाइंट 4007 सॉकेट बनाया गया।
सर्वर से कनेक्टेड।
क्लाइंट 4007 - एक संदेश दर्ज करें: hii admin

क्लाइंट 2 प्रोग्राम संकलन

$ gcc cel.c -o cel
$ ./cel
क्लाइंट 4024 सॉकेट बनाया गया।
सर्वर से कनेक्टेड।
क्लाइंट 4024 - एक संदेश दर्ज करें: hello everybody

व्याख्या:

इस प्रोग्रामिंग उदाहरण में, हमने C में फोर्क के साथ मल्टी-प्रोसेसिंग सॉकेट सर्वर के कार्यान्वयन की व्याख्या की। यहां सर्वर-साइड प्रोग्राम में, हम एक सर्वर सॉकेट बनाते हैं, इसे एक विशिष्ट पते और पोर्ट से बांधते हैं, और आने वाले कनेक्शन के लिए सुनते हैं। जब एक क्लाइंट कनेक्ट होता है, तो "fork()" का उपयोग करके एक चाइल्ड प्रक्रिया बनाई जाती है। यह एकाधिक क्लाइंट को समवर्ती रूप से संभालने की अनुमति देता है। चाइल्ड प्रक्रिया क्लाइंट से संदेश प्राप्त करती है और क्लाइंट के ID के साथ डेटा प्रदर्शित करती है। यह मल्टी-प्रोसेसिंग सॉकेट सर्वर हमें "n" संख्या के क्लाइंट के साथ एक साथ संचार की अनुमति देता है।

निष्कर्ष

हमने C में फोर्क के साथ मल्टी-प्रोसेसिंग सॉकेट सर्वर के कार्यान्वयन पर चर्चा की। फोर्क सिस्टम कॉल का उपयोग करके, यह एकाधिक क्लाइंट कनेक्शन को समवर्ती रूप से संभालने की अनुमति देता है। यह एकाधिक क्लाइंट के साथ एक साथ संचार और क्लाइंट अनुरोधों के कुशल प्रबंधन को सक्षम बनाता है।

लेखक के बारे में

बामदेब घोष

बामदेब घोष को वायरलेस नेटवर्किंग डोमेन में व्यावहारिक अनुभव है। वह वायरलेस या वायर्ड नेटवर्किंग पर वायरशार्क कैप्चर विश्लेषण के विशेषज्ञ हैं, साथ ही एंड्रॉइड, ब्लूटूथ, लिनक्स कमांड और पायथन का ज्ञान रखते हैं। उनकी साइट फॉलो करें: wifisharks.com