bluetooth
कम ऊर्जा संचार के लिए L2CAP सॉकेट खोलें

सी में, ब्लूज़ के साथ

int get_l2cap_connection () {

सबसे पहले, हमारे लिए आवश्यक सभी चर, उपयुक्त स्थान पर स्पष्टीकरण का पालन करेंगे।

    int ssock = 0;
    int csock = 0;
    int reuse_addr = 1;
    struct sockaddr_l2 src_addr;
    struct bt_security bt_sec;
    int result = 0;

सबसे पहले, हमें एक सॉकेट बनाने की आवश्यकता है, जिसे हम एक कनेक्शन स्वीकार कर सकते हैं। सॉकेट परिवार PF_BLUETOOTH , सॉकेट प्रकार SOCK_SEQPACKET (हम टीसीपी जैसा सॉकेट चाहते हैं, कच्चा नहीं है), और प्रोटोकॉल ब्लूटूथ प्रोटोकॉल L2CAP ( BTPROTO_L2CAP ) है।

    ssock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);

हम यह सुनिश्चित करना चाहते हैं कि यह सफल हो:

    if (ssock < 0) {
        perror("Opening L2CAP socket failed");
        return -1;
    }

हमें अब वाइल्डकार्ड पते के साथ स्रोत पता संरचना को भरना है, इसलिए किसी भी पते के साथ कोई भी ब्लूटूथ डिवाइस हमसे जुड़ सकता है। वाइल्डकार्ड पते को bluetooth.h में BDADDR_ANY रूप में परिभाषित किया गया है। इसे पते की संरचना में कॉपी करने के लिए, हम bacpy फ़ंक्शन का उपयोग कर सकते हैं। हमें एड्रेस फैमिली, एड्रेस टाइप और चैनल आईडी भी सेट करनी होगी।

    memset(&src_addr, 0, sizeof(src_addr));
    bacpy(&src_addr.l2_bdaddr, BDADDR_ANY);
    src_addr.l2_family = AF_BLUETOOTH;
    src_addr.l2_bdaddr_type = BDADDR_LE_PUBLIC;
    src_addr.l2_cid = htobs(CID_ATT);

SO_REUSEADDR विकल्प सेट करने से हम यदि आवश्यक हो तो जल्दी से फिर से कॉल कर सकते हैं (इसे छोड़ा जा सकता है):

    setsockopt(ssock, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, sizeof(reuse_addr));

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

    result = bind(ssock, (struct sockaddr*) &src_addr, sizeof(src_addr));
    if (result < 0) {
        perror("Binding L2CAP socket failed");
        return -1;
    }

अगला अप सुरक्षा स्तर निर्धारित कर रहा है। ध्यान दें कि यह चरण वैकल्पिक है, लेकिन सुरक्षा स्तर को MEDIUM पर सेट करने से डिवाइस के साथ स्वचालित युग्मन की अनुमति होगी (कर्नेल वास्तविक युग्मन को संभालता है)।

    memset(&bt_sec, 0, sizeof(bt_sec));
    bt_sec.level = BT_SECURITY_MEDIUM;
    result = setsockopt(ssock, SOL_BLUETOOTH, BT_SECURITY, &bt_sec, sizeof(bt_sec));
    if (result != 0) {
        perrorno("Setting L2CAP security level failed");
        return -1;
    }

अब हम कर्नेल को बता सकते हैं कि हमारा सॉस्क एक निष्क्रिय सॉकेट है, जो एक कनेक्शन स्वीकार करेगा। दूसरा पैरामीटर बैकलॉग है। यदि आप अधिक जानना चाहते हैं, तो सुनने के मुख्य पृष्ठ में आपकी आवश्यक सभी जानकारी है।

    result = listen(ssock, 10);
    if (result < 0) {
        perror("Listening on L2CAP socket failed");
        return -1;
    }

अब हम आने वाले कनेक्शन की प्रतीक्षा कर सकते हैं। Peer_addr संरचना में एक बार रिटर्न स्वीकार करने से जुड़े डिवाइस का पता होगा। कॉसक उस सॉकेट का फाइल डिस्क्रिप्टर होगा जिसे हम कनेक्टेड डिवाइस के साथ संवाद करने के लिए / लिख सकते हैं।

    memset(peer_addr, 0, sizeof(*peer_addr));
    socklen_t addrlen = sizeof(*peer_addr);
    csock = accept(ssock, (struct sockaddr*)peer_addr, &addrlen);
    if (csock < 0) {
        perror("Accepting connection on L2CAP socket failed");
        return -1;
    }

हम कनेक्टेड डिवाइस का पता प्रिंट कर सकते हैं (वैकल्पिक, निश्चित रूप से)। हम ब्लूटूथ पते को स्ट्रिंग में बदलने के लिए बैटस्ट्रो फंक्शन का उपयोग कर सकते हैं।

    printf("Accepted connection from %s", batostr(&peer_addr->l2_bdaddr));

यदि हम कोई अन्य उपकरण कनेक्ट नहीं करना चाहते हैं, तो हमें सर्वर सॉकेट बंद करना चाहिए। डिवाइस के साथ आपका संचार समाप्त होने के बाद, वही काम करें।

    close(ssock);
    return csock;
}