/** * @file llpacketring.cpp * @brief implementation of LLPacketRing class for a packet. * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "linden_common.h" #include "llpacketring.h" #if LL_WINDOWS #include <winsock2.h> #else #include <sys/socket.h> #include <netinet/in.h> #endif // linden library includes #include "llerror.h" #include "lltimer.h" #include "llproxy.h" #include "llrand.h" #include "message.h" #include "u64.h" /////////////////////////////////////////////////////////// LLPacketRing::LLPacketRing () : mUseInThrottle(false), mUseOutThrottle(false), mInThrottle(256000.f), mOutThrottle(64000.f), mActualBitsIn(0), mActualBitsOut(0), mMaxBufferLength(64000), mInBufferLength(0), mOutBufferLength(0), mDropPercentage(0.0f), mPacketsToDrop(0x0) { } /////////////////////////////////////////////////////////// LLPacketRing::~LLPacketRing () { cleanup(); } /////////////////////////////////////////////////////////// void LLPacketRing::cleanup () { LLPacketBuffer *packetp; while (!mReceiveQueue.empty()) { packetp = mReceiveQueue.front(); delete packetp; mReceiveQueue.pop(); } while (!mSendQueue.empty()) { packetp = mSendQueue.front(); delete packetp; mSendQueue.pop(); } } /////////////////////////////////////////////////////////// void LLPacketRing::dropPackets (U32 num_to_drop) { mPacketsToDrop += num_to_drop; } /////////////////////////////////////////////////////////// void LLPacketRing::setDropPercentage (F32 percent_to_drop) { mDropPercentage = percent_to_drop; } void LLPacketRing::setUseInThrottle(const bool use_throttle) { mUseInThrottle = use_throttle; } void LLPacketRing::setUseOutThrottle(const bool use_throttle) { mUseOutThrottle = use_throttle; } void LLPacketRing::setInBandwidth(const F32 bps) { mInThrottle.setRate(bps); } void LLPacketRing::setOutBandwidth(const F32 bps) { mOutThrottle.setRate(bps); } /////////////////////////////////////////////////////////// S32 LLPacketRing::receiveFromRing (S32 socket, char *datap) { if (mInThrottle.checkOverflow(0)) { // We don't have enough bandwidth, don't give them a packet. return 0; } LLPacketBuffer *packetp = NULL; if (mReceiveQueue.empty()) { // No packets on the queue, don't give them any. return 0; } S32 packet_size = 0; packetp = mReceiveQueue.front(); mReceiveQueue.pop(); packet_size = packetp->getSize(); if (packetp->getData() != NULL) { memcpy(datap, packetp->getData(), packet_size); /*Flawfinder: ignore*/ } // need to set sender IP/port!! mLastSender = packetp->getHost(); mLastReceivingIF = packetp->getReceivingInterface(); delete packetp; this->mInBufferLength -= packet_size; // Adjust the throttle mInThrottle.throttleOverflow(packet_size * 8.f); return packet_size; } /////////////////////////////////////////////////////////// S32 LLPacketRing::receivePacket (S32 socket, char *datap) { S32 packet_size = 0; // If using the throttle, simulate a limited size input buffer. if (mUseInThrottle) { bool done = false; // push any current net packet (if any) onto delay ring while (!done) { LLPacketBuffer *packetp; packetp = new LLPacketBuffer(socket); if (packetp->getSize()) { mActualBitsIn += packetp->getSize() * 8; // Fake packet loss if (mDropPercentage && (ll_frand(100.f) < mDropPercentage)) { mPacketsToDrop++; } if (mPacketsToDrop) { delete packetp; packetp = NULL; packet_size = 0; mPacketsToDrop--; } } // If we faked packet loss, then we don't have a packet // to use for buffer overflow testing if (packetp) { if (mInBufferLength + packetp->getSize() > mMaxBufferLength) { // Toss it. LL_WARNS() << "Throwing away packet, overflowing buffer" << LL_ENDL; delete packetp; packetp = NULL; } else if (packetp->getSize()) { mReceiveQueue.push(packetp); mInBufferLength += packetp->getSize(); } else { delete packetp; packetp = NULL; done = true; } } else { // No packetp, keep going? - no packetp == faked packet loss } } // Now, grab data off of the receive queue according to our // throttled bandwidth settings. packet_size = receiveFromRing(socket, datap); } else { // no delay, pull straight from net if (LLProxy::isSOCKSProxyEnabled()) { U8 buffer[NET_BUFFER_SIZE + SOCKS_HEADER_SIZE]; packet_size = receive_packet(socket, static_cast<char*>(static_cast<void*>(buffer))); if (packet_size > SOCKS_HEADER_SIZE) { // *FIX We are assuming ATYP is 0x01 (IPv4), not 0x03 (hostname) or 0x04 (IPv6) memcpy(datap, buffer + SOCKS_HEADER_SIZE, packet_size - SOCKS_HEADER_SIZE); proxywrap_t * header = static_cast<proxywrap_t*>(static_cast<void*>(buffer)); mLastSender.setAddress(header->addr); mLastSender.setPort(ntohs(header->port)); packet_size -= SOCKS_HEADER_SIZE; // The unwrapped packet size } else { packet_size = 0; } } else { packet_size = receive_packet(socket, datap); mLastSender = ::get_sender(); } mLastReceivingIF = ::get_receiving_interface(); if (packet_size) // did we actually get a packet? { if (mDropPercentage && (ll_frand(100.f) < mDropPercentage)) { mPacketsToDrop++; } if (mPacketsToDrop) { packet_size = 0; mPacketsToDrop--; } } } return packet_size; } bool LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LLHost host) { bool status = true; if (!mUseOutThrottle) { return sendPacketImpl(h_socket, send_buffer, buf_size, host ); } else { mActualBitsOut += buf_size * 8; LLPacketBuffer *packetp = NULL; // See if we've got enough throttle to send a packet. while (!mOutThrottle.checkOverflow(0.f)) { // While we have enough bandwidth, send a packet from the queue or the current packet S32 packet_size = 0; if (!mSendQueue.empty()) { // Send a packet off of the queue LLPacketBuffer *packetp = mSendQueue.front(); mSendQueue.pop(); mOutBufferLength -= packetp->getSize(); packet_size = packetp->getSize(); status = sendPacketImpl(h_socket, packetp->getData(), packet_size, packetp->getHost()); delete packetp; // Update the throttle mOutThrottle.throttleOverflow(packet_size * 8.f); } else { // If the queue's empty, we can just send this packet right away. status = sendPacketImpl(h_socket, send_buffer, buf_size, host ); packet_size = buf_size; // Update the throttle mOutThrottle.throttleOverflow(packet_size * 8.f); // This was the packet we're sending now, there are no other packets // that we need to send return status; } } // We haven't sent the incoming packet, add it to the queue if (mOutBufferLength + buf_size > mMaxBufferLength) { // Nuke this packet, we overflowed the buffer. // Toss it. LL_WARNS() << "Throwing away outbound packet, overflowing buffer" << LL_ENDL; } else { static LLTimer queue_timer; if ((mOutBufferLength > 4192) && queue_timer.getElapsedTimeF32() > 1.f) { // Add it to the queue LL_INFOS() << "Outbound packet queue " << mOutBufferLength << " bytes" << LL_ENDL; queue_timer.reset(); } packetp = new LLPacketBuffer(host, send_buffer, buf_size); mOutBufferLength += packetp->getSize(); mSendQueue.push(packetp); } } return status; } bool LLPacketRing::sendPacketImpl(int h_socket, const char * send_buffer, S32 buf_size, LLHost host) { if (!LLProxy::isSOCKSProxyEnabled()) { return send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort()); } char headered_send_buffer[NET_BUFFER_SIZE + SOCKS_HEADER_SIZE]; proxywrap_t *socks_header = static_cast<proxywrap_t*>(static_cast<void*>(&headered_send_buffer)); socks_header->rsv = 0; socks_header->addr = host.getAddress(); socks_header->port = htons(host.getPort()); socks_header->atype = ADDRESS_IPV4; socks_header->frag = 0; memcpy(headered_send_buffer + SOCKS_HEADER_SIZE, send_buffer, buf_size); return send_packet( h_socket, headered_send_buffer, buf_size + SOCKS_HEADER_SIZE, LLProxy::getInstance()->getUDPProxy().getAddress(), LLProxy::getInstance()->getUDPProxy().getPort()); }