Logger2/src/Communicator.cpp at master · mp3guy/Logger2 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*
 * Communicator.cpp
 *
 *  Created on: 14 Aug 2013
 *      Author: thomas
 */

#include "Communicator.h"

Communicator::Communicator()
 : port(54322),
   outSocket(-1),
   inSocket(-1),
   header("BLAH"),
   heartbeat("HERP"),
   broadcast("wlan1")
{
    outSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    int opt = 1;
    setsockopt(outSocket, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(int));

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port + 1);
    servaddr.sin_addr.s_addr = inet_addr(getBroadcastAddress().c_str());

    inSocket = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, 0);

    int on = 1;
    setsockopt(inSocket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);
    bind(inSocket, (struct sockaddr *)&addr, sizeof(struct sockaddr));
}

Communicator::~Communicator()
{
    close(outSocket);
    close(inSocket);
}

void Communicator::sendInfo(const std::string & info)
{
    int size = header.length() + info.length() + sizeof(int);

    unsigned char * data = (unsigned char *)calloc(size, sizeof(unsigned char));

    int * dataInt = (int *)data;
    dataInt[0] = size;

    std::string msg = header;
    msg.append(info);

    memcpy(&dataInt[1], msg.data(), msg.length());

    sendto(outSocket, data, size, 0, (struct sockaddr *) &servaddr, sizeof(servaddr));

    free(data);
}

std::string Communicator::getBroadcastAddress()
{
    struct ifaddrs *ifap, *ifa;
    struct sockaddr_in *sa;

    getifaddrs(&ifap);

    for(ifa = ifap; ifa; ifa = ifa->ifa_next)
    {
        if(ifa->ifa_addr->sa_family == AF_INET && !strcmp(ifa->ifa_name, broadcast.c_str()))
        {
#if defined __APPLE__ && defined __MACH__
            sa = (struct sockaddr_in *) ifa->ifa_broadaddr;
#else
            sa = (struct sockaddr_in *) ifa->ifa_ifu.ifu_broadaddr;
#endif
            std::string addr(inet_ntoa(sa->sin_addr));
            freeifaddrs(ifap);
            std::cout << "Got broadcast address: " << addr << std::endl;
            return addr;
        }
    }

    freeifaddrs(ifap);

    assert(false && "Can't get broadcast address");

    return "";
}

std::string Communicator::tryRecv()
{
    char buffer[65535];

    int recvSize = 0;

    if((recvSize = recv(inSocket, &buffer[0], 65535, 0)) > 0)
    {
        int size = ((int *)&buffer[0])[0];

        std::string msg = header;

        if(recvSize == size)
        {
            std::string testStr(&buffer[sizeof(int)], header.length());

            if(testStr.compare(header) == 0)
            {
                std::string retStr(&buffer[sizeof(int) + header.length()], recvSize - (sizeof(int) + header.length()));
                return retStr;
            }
        }
    }

    return "";
}