1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/dns/mock_mdns_socket_factory.h"
6
7 #include <algorithm>
8 #include <utility>
9
10 #include "base/functional/bind.h"
11 #include "base/functional/callback_helpers.h"
12 #include "base/location.h"
13 #include "base/task/single_thread_task_runner.h"
14 #include "net/base/net_errors.h"
15 #include "net/dns/public/util.h"
16
17 using testing::_;
18 using testing::Invoke;
19
20 namespace net {
21
MockMDnsDatagramServerSocket(AddressFamily address_family)22 MockMDnsDatagramServerSocket::MockMDnsDatagramServerSocket(
23 AddressFamily address_family) {
24 local_address_ = dns_util::GetMdnsReceiveEndPoint(address_family);
25 }
26
27 MockMDnsDatagramServerSocket::~MockMDnsDatagramServerSocket() = default;
28
SendTo(IOBuffer * buf,int buf_len,const IPEndPoint & address,CompletionOnceCallback callback)29 int MockMDnsDatagramServerSocket::SendTo(IOBuffer* buf,
30 int buf_len,
31 const IPEndPoint& address,
32 CompletionOnceCallback callback) {
33 return SendToInternal(std::string(buf->data(), buf_len), address.ToString(),
34 std::move(callback));
35 }
36
GetLocalAddress(IPEndPoint * address) const37 int MockMDnsDatagramServerSocket::GetLocalAddress(IPEndPoint* address) const {
38 *address = local_address_;
39 return OK;
40 }
41
SetResponsePacket(const std::string & response_packet)42 void MockMDnsDatagramServerSocket::SetResponsePacket(
43 const std::string& response_packet) {
44 response_packet_ = response_packet;
45 }
46
HandleRecvNow(IOBuffer * buffer,int size,IPEndPoint * address,CompletionOnceCallback callback)47 int MockMDnsDatagramServerSocket::HandleRecvNow(
48 IOBuffer* buffer,
49 int size,
50 IPEndPoint* address,
51 CompletionOnceCallback callback) {
52 int size_returned =
53 std::min(response_packet_.size(), static_cast<size_t>(size));
54 memcpy(buffer->data(), response_packet_.data(), size_returned);
55 return size_returned;
56 }
57
HandleRecvLater(IOBuffer * buffer,int size,IPEndPoint * address,CompletionOnceCallback callback)58 int MockMDnsDatagramServerSocket::HandleRecvLater(
59 IOBuffer* buffer,
60 int size,
61 IPEndPoint* address,
62 CompletionOnceCallback callback) {
63 int rv = HandleRecvNow(buffer, size, address, base::DoNothing());
64 base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
65 FROM_HERE, base::BindOnce(std::move(callback), rv));
66 return ERR_IO_PENDING;
67 }
68
69 MockMDnsSocketFactory::MockMDnsSocketFactory() = default;
70
71 MockMDnsSocketFactory::~MockMDnsSocketFactory() = default;
72
CreateSockets(std::vector<std::unique_ptr<DatagramServerSocket>> * sockets)73 void MockMDnsSocketFactory::CreateSockets(
74 std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
75 CreateSocket(ADDRESS_FAMILY_IPV4, sockets);
76 CreateSocket(ADDRESS_FAMILY_IPV6, sockets);
77 }
78
CreateSocket(AddressFamily address_family,std::vector<std::unique_ptr<DatagramServerSocket>> * sockets)79 void MockMDnsSocketFactory::CreateSocket(
80 AddressFamily address_family,
81 std::vector<std::unique_ptr<DatagramServerSocket>>* sockets) {
82 auto new_socket =
83 std::make_unique<testing::NiceMock<MockMDnsDatagramServerSocket>>(
84 address_family);
85
86 ON_CALL(*new_socket, SendToInternal(_, _, _))
87 .WillByDefault(Invoke(
88 this,
89 &MockMDnsSocketFactory::SendToInternal));
90
91 ON_CALL(*new_socket, RecvFrom(_, _, _, _))
92 .WillByDefault(Invoke(this, &MockMDnsSocketFactory::RecvFromInternal));
93
94 sockets->push_back(std::move(new_socket));
95 }
96
SimulateReceive(const uint8_t * packet,int size)97 void MockMDnsSocketFactory::SimulateReceive(const uint8_t* packet, int size) {
98 DCHECK(recv_buffer_size_ >= size);
99 DCHECK(recv_buffer_.get());
100 DCHECK(!recv_callback_.is_null());
101
102 memcpy(recv_buffer_->data(), packet, size);
103 std::move(recv_callback_).Run(size);
104 }
105
RecvFromInternal(IOBuffer * buffer,int size,IPEndPoint * address,CompletionOnceCallback callback)106 int MockMDnsSocketFactory::RecvFromInternal(IOBuffer* buffer,
107 int size,
108 IPEndPoint* address,
109 CompletionOnceCallback callback) {
110 recv_buffer_ = buffer;
111 recv_buffer_size_ = size;
112 recv_callback_ = std::move(callback);
113 return ERR_IO_PENDING;
114 }
115
SendToInternal(const std::string & packet,const std::string & address,CompletionOnceCallback callback)116 int MockMDnsSocketFactory::SendToInternal(const std::string& packet,
117 const std::string& address,
118 CompletionOnceCallback callback) {
119 OnSendTo(packet);
120 return packet.size();
121 }
122
123 } // namespace net
124