blob: d3eb25667084fe7477e6a487ca46b8f7c6bf1024 [file] [log] [blame]
// Copyright (c) 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <memory>
#include <vector>
#include "base/at_exit.h"
#include "base/command_line.h"
#include "base/logging.h"
#include "net/quic/quic_chromium_alarm_factory.h"
#include "net/third_party/quic/core/quic_constants.h"
#include "net/third_party/quic/platform/impl/quic_chromium_clock.h"
#include "net/third_party/quic/quartc/quartc_factory.h"
#include "third_party/chromium_quic/demo/delegates.h"
int main(int argc, char** argv) {
base::AtExitManager exit_manager;
base::CommandLine::Init(argc, argv);
logging::LoggingSettings logging_settings;
logging_settings.logging_dest = logging::LOG_TO_FILE;
logging_settings.log_file = "/dev/stderr";
logging_settings.lock_log = logging::DONT_LOCK_LOG_FILE;
logging::InitLogging(logging_settings);
if (argc < 2) {
dprintf(STDERR_FILENO,
"Missing port number\nusage: streaming_playback_controller "
"<server-port>\n");
return 1;
}
int port = atoi(argv[1]);
if (port <= 0 || port > UINT16_MAX) {
dprintf(STDERR_FILENO, "Invalid port number: %d\n", port);
return 1;
}
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd == -1) {
perror("socket()");
return 1;
}
// On non-Linux, the SOCK_NONBLOCK option is not available, so use the
// more-portable method of calling fcntl() to set this behavior.
if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1) {
perror("fcntl(F_SETFL, +O_NONBLOCK)");
return 1;
}
struct sockaddr_in address = {};
address.sin_family = AF_INET;
address.sin_port = 0;
address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
int reuse = 1;
int result = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
if (result == -1) {
perror("setsockopt()");
return 1;
}
result = bind(fd, (struct sockaddr*)(&address), sizeof(address));
if (result == -1) {
perror("bind()");
return 1;
}
struct sockaddr_in server_address;
server_address.sin_family = AF_INET;
server_address.sin_port = htons(static_cast<uint16_t>(port));
server_address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
UdpTransport transport(fd, server_address);
auto* clock = quic::QuicChromiumClock::GetInstance();
std::vector<FakeTask> tasks;
scoped_refptr<FakeTaskRunner> task_runner =
base::MakeRefCounted<FakeTaskRunner>(&tasks);
auto alarm_factory =
std::make_unique<net::QuicChromiumAlarmFactory>(task_runner.get(), clock);
quic::QuartcFactoryConfig factory_config;
factory_config.alarm_factory = alarm_factory.get();
factory_config.clock = clock;
quic::QuartcFactory factory(factory_config);
quic::QuartcSessionConfig session_config;
session_config.perspective = quic::Perspective::IS_CLIENT;
session_config.unique_remote_server_id = "asdf";
session_config.packet_transport = &transport;
// rest are defaults
auto session = factory.CreateQuartcSession(session_config);
SessionDelegate session_delegate;
session->SetDelegate(&session_delegate);
StreamDelegate outgoing_delegate;
session->OnTransportCanWrite();
session->StartCryptoHandshake();
auto last = clock->WallNow();
bool once = false;
while (true) {
auto now = clock->WallNow();
for (auto it = tasks.begin(); it != tasks.end();) {
auto& next_task = *it;
next_task.delay -= base::TimeDelta::FromMicroseconds(
now.ToUNIXMicroseconds() - last.ToUNIXMicroseconds());
if (next_task.delay.InMicroseconds() < 0) {
printf("task: %s\n", next_task.whence.ToString().c_str());
std::move(next_task.task).Run();
it = tasks.erase(it);
} else {
++it;
}
}
last = now;
// NOTE: The stream will not close immediately on send, because it waits for
// ACKs, including for the fin bit. Calling CloseConnection, however,
// immediately closes the connection so it's safe to exit immediately here.
if (outgoing_delegate.closed()) {
session->CloseConnection("all your base");
break;
}
struct sockaddr_in peer_address;
socklen_t addrlen = sizeof(peer_address);
char buffer[quic::kMaxPacketSize] = {};
int buffer_length = sizeof(buffer);
result = recvfrom(fd, buffer, buffer_length, 0,
(struct sockaddr*)(&peer_address), &addrlen);
if ((result == -1 && errno != EWOULDBLOCK && errno != EAGAIN) ||
addrlen != sizeof(peer_address)) {
perror("recvfrom()");
return 1;
} else if (result > 0) {
printf("recvfrom()\n");
session->OnTransportReceived(buffer, result);
if (session->IsCryptoHandshakeConfirmed() &&
session->IsEncryptionEstablished() && !once) {
auto* stream = session->CreateOutgoingDynamicStream();
stream->SetDelegate(&outgoing_delegate);
// TODO(btolsch): This seems odd. Can we do better when reimplementing
// platform/impl?
// TODO(btolsch): Specify the number of copies/refcounts per write.
char data[] = "turtle";
auto buffer = base::MakeRefCounted<net::IOBuffer>(sizeof(data) - 1);
int length = sizeof(data) - 1;
memcpy(buffer->data(), data, sizeof(data) - 1);
stream->WriteMemSlices(
quic::QuicMemSliceSpan(
quic::QuicMemSliceSpanImpl(&buffer, &length, 1)),
true);
once = true;
}
}
}
return 0;
}