folly/folly/net/NetOpsDispatcher.cpp

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <folly/net/NetOps.h>
#include <folly/net/NetOpsDispatcher.h>

namespace folly {
namespace netops {
Dispatcher* Dispatcher::getDefaultInstance() { … }

NetworkSocket Dispatcher::accept(
    NetworkSocket s, sockaddr* addr, socklen_t* addrlen) { … }

int Dispatcher::bind(NetworkSocket s, const sockaddr* name, socklen_t namelen) { … }

int Dispatcher::close(NetworkSocket s) { … }

int Dispatcher::connect(
    NetworkSocket s, const sockaddr* name, socklen_t namelen) { … }

int Dispatcher::getpeername(
    NetworkSocket s, sockaddr* name, socklen_t* namelen) { … }

int Dispatcher::getsockname(
    NetworkSocket s, sockaddr* name, socklen_t* namelen) { … }

int Dispatcher::getsockopt(
    NetworkSocket s, int level, int optname, void* optval, socklen_t* optlen) { … }

int Dispatcher::inet_aton(const char* cp, in_addr* inp) { … }

int Dispatcher::listen(NetworkSocket s, int backlog) { … }

int Dispatcher::poll(PollDescriptor fds[], nfds_t nfds, int timeout) { … }

ssize_t Dispatcher::recv(NetworkSocket s, void* buf, size_t len, int flags) { … }

ssize_t Dispatcher::recvfrom(
    NetworkSocket s,
    void* buf,
    size_t len,
    int flags,
    sockaddr* from,
    socklen_t* fromlen) { … }

ssize_t Dispatcher::recvmsg(NetworkSocket s, msghdr* message, int flags) { … }

int Dispatcher::recvmmsg(
    NetworkSocket s,
    mmsghdr* msgvec,
    unsigned int vlen,
    unsigned int flags,
    timespec* timeout) { … }

ssize_t Dispatcher::send(
    NetworkSocket s, const void* buf, size_t len, int flags) { … }

ssize_t Dispatcher::sendmsg(
    NetworkSocket socket, const msghdr* message, int flags) { … }

int Dispatcher::sendmmsg(
    NetworkSocket socket, mmsghdr* msgvec, unsigned int vlen, int flags) { … }

ssize_t Dispatcher::sendto(
    NetworkSocket s,
    const void* buf,
    size_t len,
    int flags,
    const sockaddr* to,
    socklen_t tolen) { … }

int Dispatcher::setsockopt(
    NetworkSocket s,
    int level,
    int optname,
    const void* optval,
    socklen_t optlen) { … }

int Dispatcher::shutdown(NetworkSocket s, int how) { … }

NetworkSocket Dispatcher::socket(int af, int type, int protocol) { … }

int Dispatcher::socketpair(
    int domain, int type, int protocol, NetworkSocket sv[2]) { … }

int Dispatcher::set_socket_non_blocking(NetworkSocket s) { … }

int Dispatcher::set_socket_close_on_exec(NetworkSocket s) { … }

} // namespace netops
} // namespace folly