Workreap React Native v2.6求职软件app Java JavaScript项目源码ios android

/* * Copyright (c) Facebook, Inc. and its 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/io/async/AsyncSocket.h> #include <sys/types.h> #include <cerrno> #include <climits> #include <sstream> #include <thread> #include <boost/preprocessor/control/if.hpp> #include <folly/ExceptionWrapper.h> #include <folly/Format.h> #include <folly/Portability.h> #include <folly/SocketAddress.h> #include <folly/String.h> #include <folly/io/Cursor.h> #include <folly/io/IOBuf.h> #include <folly/io/IOBufQueue.h> #include <folly/io/SocketOptionMap.h> #include <folly/portability/Fcntl.h> #include <folly/portability/Sockets.h> #include <folly/portability/SysUio.h> #include <folly/portability/Unistd.h> #if defined(__linux__) #include <linux/if_packet.h> #include <linux/sockios.h> #include <sys/ioctl.h> #endif #if FOLLY_HAVE_VLA #define FOLLY_HAVE_VLA_01 1 #else #define FOLLY_HAVE_VLA_01 0 #endif using std::string; using std::unique_ptr; namespace fsp = folly::portability::sockets; namespace folly { static constexpr bool msgErrQueueSupported = #ifdef FOLLY_HAVE_MSG_ERRQUEUE true; #else false; #endif // FOLLY_HAVE_MSG_ERRQUEUE static AsyncSocketException const& getSocketClosedLocallyEx() { static auto& ex = *new AsyncSocketException( AsyncSocketException::END_OF_FILE, "socket closed locally"); return ex; } static AsyncSocketException const& getSocketShutdownForWritesEx() { static auto& ex = *new AsyncSocketException( AsyncSocketException::END_OF_FILE, "socket shutdown for writes"); return ex; } namespace { #if FOLLY_HAVE_SO_TIMESTAMPING const sock_extended_err* FOLLY_NULLABLE cmsgToSockExtendedErr(const cmsghdr& cmsg) { if ((cmsg.cmsg_level == SOL_IP && cmsg.cmsg_type == IP_RECVERR) || (cmsg.cmsg_level == SOL_IPV6 && cmsg.cmsg_type == IPV6_RECVERR) || (cmsg.cmsg_level == SOL_PACKET && cmsg.cmsg_type == PACKET_TX_TIMESTAMP)) { return reinterpret_cast<const sock_extended_err*>(CMSG_DATA(&cmsg)); } (void)cmsg; return nullptr; } const sock_extended_err* FOLLY_NULLABLE cmsgToSockExtendedErrTimestamping(const cmsghdr& cmsg) { const auto serr = cmsgToSockExtendedErr(cmsg); if (serr && serr->ee_errno == ENOMSG && serr->ee_origin == SO_EE_ORIGIN_TIMESTAMPING) { return serr; } (void)cmsg; return nullptr; } const scm_timestamping* FOLLY_NULLABLE cmsgToScmTimestamping(const cmsghdr& cmsg) { if (cmsg.cmsg_level == SOL_SOCKET && cmsg.cmsg_type == SCM_TIMESTAMPING) { return reinterpret_cast<const struct scm_timestamping*>(CMSG_DATA(&cmsg)); } (void)cmsg; return nullptr; } #endif // FOLLY_HAVE_SO_TIMESTAMPING } // namespace // TODO: It might help performance to provide a version of BytesWriteRequest // that users could derive from, so we can avoid the extra allocation for each // call to write()/writev(). // // We would need the version for external users where they provide the iovec // storage space, and only our internal version would allocate it at the end of // the WriteRequest. /* The default WriteRequest implementation, used for write(), writev() and * writeChain() * * A new BytesWriteRequest operation is allocated on the heap for all write * operations that cannot be completed immediately. */ class AsyncSocket::BytesWriteRequest : public AsyncSocket::WriteRequest { public: static BytesWriteRequest* newRequest( AsyncSocket* socket, WriteCallback* callback, const iovec* ops, uint32_t opCount, uint32_t partialWritten, uint32_t bytesWritten, unique_ptr<IOBuf>&& ioBuf, WriteFlags flags) { assert(opCount > 0); // Since we put a variable size iovec array at the end // of each BytesWriteRequest, we have to manually allocate the memory. void* buf = malloc(sizeof(BytesWriteRequest) + (opCount * sizeof(struct iovec))); if (buf == nullptr) { throw std::bad_alloc(); } return new (buf) BytesWriteRequest( socket, callback, ops, opCount, partialWritten, bytesWritten, std::move(ioBuf), flags); } void destroy() override { if (ioBuf_ && releaseIOBufCallback_) { releaseIOBufCallback_->releaseIOBuf(std::move(ioBuf_)); } this->~BytesWriteRequest(); free(this); } WriteResult performWrite() override { WriteFlags writeFlags = flags_; if (getNext() != nullptr) { writeFlags |= WriteFlags::CORK; } socket_->adjustZeroCopyFlags(writeFlags); auto writeResult = socket_->performWrite( getOps(), getOpCount(), writeFlags, &opsWritten_, &partialBytes_); bytesWritten_ = writeResult.writeReturn > 0 ? writeResult.writeReturn : 0; if (bytesWritten_) { if (socket_->isZeroCopyRequest(writeFlags)) { if (isComplete()) { socket_->addZeroCopyBuf(std::move(ioBuf_), releaseIOBufCallback_); } else { socket_->addZeroCopyBuf(ioBuf_.get()); } } else { // this happens if at least one of the prev requests were sent // with zero copy but not the last one if (isComplete() && zeroCopyRequest_ && socket_->containsZeroCopyBuf(ioBuf_.get())) { socket_->setZeroCopyBuf(std::move(ioBuf_), releaseIOBufCallback_); } } } return writeResult; } bool isComplete() override { return opsWritten_ == getOpCount(); } void consume() override { // Advance opIndex_ forward by opsWritten_ opIndex_ += opsWritten_; assert(opIndex_ < opCount_); bool zeroCopyReq = socket_->isZeroCopyRequest(flags_); if (zeroCopyReq) { zeroCopyRequest_ = true; } if (!zeroCopyRequest_) { // If we've finished writing any IOBufs, release them // but only if we did not send any of them via zerocopy if (ioBuf_) { for (uint32_t i = opsWritten_; i != 0; --i) { assert(ioBuf_); auto next = ioBuf_->pop(); if (releaseIOBufCallback_) { releaseIOBufCallback_->releaseIOBuf(std::move(ioBuf_)); } ioBuf_ = std::move(next); } } } // Move partialBytes_ forward into the current iovec buffer struct iovec* currentOp = writeOps_ + opIndex_; assert((partialBytes_ < currentOp->iov_len) || (currentOp->iov_len == 0)); currentOp->iov_base = reinterpret_cast<uint8_t*>(currentOp->iov_base) + partialBytes_; currentOp->iov_len -= partialBytes_; // Increment the totalBytesWritten_ count by bytesWritten_; assert(bytesWritten_ >= 0); totalBytesWritten_ += uint32_t(bytesWritten_); } private: BytesWriteRequest( AsyncSocket* socket, WriteCallback* callback, const struct iovec* ops, uint32_t opCount, uint32_t partialBytes, uint32_t bytesWritten, unique_ptr<IOBuf>&& ioBuf, WriteFlags flags) : AsyncSocket::WriteRequest(socket, callback), opCount_(opCount), opIndex_(0), flags_(flags), ioBuf_(std::move(ioBuf)), opsWritten_(0), partialBytes_(partialBytes), bytesWritten_(bytesWritten) { memcpy(writeOps_, ops, sizeof(*ops) * opCount_); zeroCopyRequest_ = socket_->isZeroCopyRequest(flags_); } // private destructor, to ensure callers use destroy() ~BytesWriteRequest() override = default; const struct iovec* getOps() const { assert(opCount_ > opIndex_); return writeOps_ + opIndex_; } uint32_t getOpCoun