东风草堂博客

template <typename T>
class ThreadSafePointer {
public:
    ThreadSafePointer() : data(nullptr), ref_count(new size_t(0)), mutex(new std::mutex()) {}

    ThreadSafePointer(T* ptr) : data(ptr), ref_count(new size_t(1)), mutex(new std::mutex()) {}

    ThreadSafePointer(const ThreadSafePointer<T>& other) {
        std::lock_guard<std::mutex> lock(*other.mutex);
        data = other.data;
        ref_count = other.ref_count;
        (*ref_count)++;
        mutex = other.mutex;
    }

    ThreadSafePointer& operator=(const ThreadSafePointer<T>& other) {
        if (this == &other) return *this;

        release();
        std::lock_guard<std::mutex> lock(*other.mutex);
        data = other.data;
        ref_count = other.ref_count;
        (*ref_count)++;
        mutex = other.mutex;
        return *this;
    }

    ~ThreadSafePointer() {
        release();
    }

    T* get() const {
        std::lock_guard<std::mutex> lock(*mutex);
        return data;
    }

    size_t use_count() const {
        std::lock_guard<std::mutex> lock(*mutex);
        return *ref_count;
    }

private:
    T* data;
    size_t* ref_count;
    std::mutex* mutex;

    void release() {
        std::lock_guard<std::mutex> lock(*mutex);
        if (ref_count && --(*ref_count) == 0) {
            delete data;
            delete ref_count;
            delete mutex;
        }
    }
};

ThreadSafePointer<int> ptr1(new int(42));
{
    ThreadSafePointer<int> ptr2 = ptr1;
    std::cout << "ptr2: " << *ptr2.get() << " (use count: " << ptr2.use_count() << ")" << std::endl;
}

std::cout << "ptr1: " << *ptr1.get() << " (use count: " << ptr1.use_count() << ")" << std::endl;

// 如果查找失败，判断最接近目标数的元素是array[left]还是array[right]
if (abs(array[left] - target) < abs(array[right] - target)) {
   // 如果array[left]更接近，返回left
   return left;
} else {
   // 如果array[right]更接近，返回right
   return right;
}

std::string getInterfaceNameFromSockaddr(const struct sockaddr_in &sockAddr)
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1)
    {
        return "";
    }

    struct ifconf ifc;
    char buf[1024]; // 大小根据实际情况调整
    ifc.ifc_len = sizeof(buf);
    ifc.ifc_buf = buf;

    if (ioctl(sockfd, SIOCGIFCONF, (char *)&ifc) == -1)
    {
        close(sockfd);
        return "";
    }

    std::string interfaceName = "";
    int num = ifc.ifc_len / sizeof(struct ifreq);
    struct ifreq *ifr = ifc.ifc_req;

    for (int i = 0; i < num; ++i)
    {
        struct sockaddr_in *addr = reinterpret_cast<struct sockaddr_in *>(&ifr[i].ifr_addr);

        if (addr->sin_family == AF_INET)
        {
            char ipStr[INET_ADDRSTRLEN];
            const char *ip = inet_ntop(AF_INET, &(addr->sin_addr), ipStr, INET_ADDRSTRLEN);
            std::cout << "guess IP address: " << ip << std::endl;

            if (ip != nullptr && std::memcmp(&(sockAddr.sin_addr), &(addr->sin_addr), sizeof(struct in_addr)) == 0)
            {
                interfaceName = ifr[i].ifr_name;
                std::cout << "guessed!" << std::endl;
                break;
            }
        }
    }

    close(sockfd);
    return interfaceName;
}

// 定时器线程：每隔30秒发送STUN登录请求
std::thread timer_thread([&]()
                            {
    while (true) {
        static unsigned int s_seq = 0;
        int size = sizeof(SStunLogin) + g_strDeviceId.size() - 1;
        char* buf = new char[size];
        SStunLogin* p = (SStunLogin*)buf;
        p->head.len = htons(size);
        p->head.cmd = htons(STUN_CMD_LOGIN);
        p->head.seq = htonl(++s_seq);
        p->nat = g_finalNatType;
        memcpy_s(p->uid, size - sizeof(SStunLogin) + 1, g_strDeviceId.c_str(), g_strDeviceId.size());
        sendto(sockfd, buf, size, 0, (const sockaddr*)&server_addr, sizeof(server_addr));
        delete[] buf;
        printf("udp stun alive seq = %u\n", s_seq);
        sleep(30);
    } });

// 创建epoll
int epoll_fd = epoll_create(1);
if (epoll_fd < 0)
{
    std::cerr << "Failed to create epoll" << std::endl;
    return 1;
}

// 添加UDP套接字到epoll
struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = sockfd;
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &event) < 0)
{
    std::cerr << "Failed to add socket to epoll" << std::endl;
    return 1;
}

// epoll等待事件
const int MAX_EVENTS = 10;
struct epoll_event events[MAX_EVENTS];
while (true)
{
    int num_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
    if (num_events < 0)
    {
        std::cerr << "Error in epoll_wait" << std::endl;
        return 1;
    }

    for (int i = 0; i < num_events; ++i)
    {
        if (events[i].data.fd == sockfd && events[i].events & EPOLLIN)
        {
            char buf[1500];
            struct sockaddr_in client_addr;
            socklen_t addr_len = sizeof(client_addr);
            ssize_t num_bytes = recvfrom(sockfd, &buf, sizeof(buf), 0,
                                            (struct sockaddr *)&client_addr, &addr_len);
            if (num_bytes < 0)
            {
                std::cerr << "Error in recvfrom" << std::endl;
                continue;
            }

            printf("recvfrom %s_%d size = %ld\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), num_bytes);

            if (sizeof(SStunLoginResponse) == num_bytes)
            {
                // 尝试解析成穿透响应
                SStunLoginResponse *slr = (SStunLoginResponse *)buf;
                if (ntohs(slr->head.cmd) == STUN_CMD_LOGIN && ntohs(slr->head.len) == num_bytes)
                {
                    printf("recv stun alive result = %d,seq = %u,ip = %s,port = %d\n", (int)slr->result, ntohl(slr->head.seq),
                            IpInt2Str(slr->ip).c_str(), ntohs(slr->port));
                }
            }
            if (sizeof(SStunTransfer) == num_bytes)
            {
                // 尝试解析成穿透命令
                SStunTransfer *st = (SStunTransfer *)buf;
                if (ntohs(st->head.cmd) == STUN_CMD_TRANSFER && ntohs(st->head.len) == num_bytes)
                {
                    SStunResponse response;
                    response.head.cmd = st->head.cmd;
                    response.head.seq = st->head.seq;
                    response.head.len = htons(sizeof(response));
                    response.result = 0;
                    int tmpRet = sendto(sockfd, (const char *)&response, sizeof(response), 0, (sockaddr *)&client_addr, addr_len);
                    if (tmpRet != sizeof(response))
                    {
                        printf("sendto %s_%d ret = %d,error = %d\n", IpInt2Str(client_addr.sin_addr.s_addr).c_str(), ntohs(client_addr.sin_port), tmpRet,
                                errno);
                    }
                    client_addr.sin_addr.s_addr = st->ip;
                    client_addr.sin_port = st->port;
                    tmpRet = sendto(sockfd, "0", 1, 0, (sockaddr *)&client_addr, addr_len);
                    if (tmpRet != 1)
                    {
                        printf("sendto %s_%d ret = %d,error = %d\n", IpInt2Str(client_addr.sin_addr.s_addr).c_str(), ntohs(client_addr.sin_port), tmpRet,
                                errno);
                    }
                    printf("stun to %s_%d\n", IpInt2Str(client_addr.sin_addr.s_addr).c_str(), ntohs(client_addr.sin_port));
                }
            }
            else
            {
                std::cout << "receive data " << string(buf, num_bytes) << std::endl;
            }
        }
    }
}

// TCP套接字可以重用地址
ip::tcp::socket::reuse_address ra(true);
sock.set_option(ra);