void host_object::test<10>() { std::string hostStr = "64.233.167.99"; LLHost host; host.setHostByName(hostStr); ensure("SetHostByName for dotted IP Address failed", host.getAddress() == ip_string_to_u32(hostStr.c_str())); }
// static bool LLFloaterMessageLog::onConfirmCloseCircuit(const LLSD& notification, const LLSD& response ) { S32 option = LLNotificationsUtil::getSelectedOption(notification, response); LLCircuitData* cdp = gMessageSystem->mCircuitInfo.findCircuit(LLHost(notification["payload"]["circuittoclose"].asString())); if(!cdp) return false; LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(cdp->getHost()); switch(option) { case 0: // yes gMessageSystem->newMessageFast(_PREHASH_CloseCircuit); gMessageSystem->sendReliable(cdp->getHost()); break; case 2: // cancel return false; break; case 1: // no default: break; } if(gMessageSystem->findCircuitCode(cdp->getHost())) gMessageSystem->disableCircuit(cdp->getHost()); else gMessageSystem->mCircuitInfo.removeCircuitData(cdp->getHost()); if(regionp) { LLHost myhost = regionp->getHost(); LLSD args; args["MESSAGE"] = "That host had a region associated with it.\nDo you want to clean that up?"; LLSD payload; payload["regionhost"] = myhost.getString(); LLNotificationsUtil::add("GenericAlertYesCancel", args, payload, onConfirmRemoveRegion); } return false; }
bool LLViewerParcelMedia::allowedMedia(std::string media_url) { LLStringUtil::trim(media_url); std::string domain = extractDomain(media_url); LLHost host; host.setHostByName(domain); std::string ip = host.getIPString(); if (sAllowedMedia.count(domain) || sAllowedMedia.count(ip)) { return true; } std::string server; for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++) { server = sMediaFilterList[i]["domain"].asString(); if (server == domain || server == ip) { if (sMediaFilterList[i]["action"].asString() == "allow") { return true; } else { return false; } } } return false; }
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()); }
void host_object::test<6>() { U32 ip = 0xc098017d, port = 8080; LLHost host; host.set(ip,port); ensure("IP address is invalid", (ip == host.getAddress())); ensure("Port Number is invalid", (port == host.getPort())); }
S32 tcp_open_channel(LLHost host) { // Open a TCP channel // Jump through some hoops to ensure that if the request hosts is down // or not reachable connect() does not block S32 handle; handle = socket(AF_INET, SOCK_STREAM, 0); if (!handle) { llwarns << "Error opening TCP control socket, socket() returned " << handle << llendl; return -1; } struct sockaddr_in address; address.sin_port = htons(host.getPort()); address.sin_family = AF_INET; address.sin_addr.s_addr = host.getAddress(); // Non blocking WSAEVENT hEvent=WSACreateEvent(); WSAEventSelect(handle, hEvent, FD_CONNECT) ; connect(handle, (struct sockaddr*)&address, sizeof(address)) ; // Wait fot 5 seconds, if we can't get a TCP channel open in this // time frame then there is something badly wrong. WaitForSingleObject(hEvent, 1000*5); // 5 seconds time out WSANETWORKEVENTS netevents; WSAEnumNetworkEvents(handle,hEvent,&netevents); // Check the async event status to see if we connected if ((netevents.lNetworkEvents & FD_CONNECT) == FD_CONNECT) { if (netevents.iErrorCode[FD_CONNECT_BIT] != 0) { llwarns << "Unable to open TCP channel, WSA returned an error code of " << netevents.iErrorCode[FD_CONNECT_BIT] << llendl; WSACloseEvent(hEvent); return -1; } // Now we are connected disable non blocking // we don't need support an async interface as // currently our only consumer (socks5) will make one round // of packets then just hold the connection open WSAEventSelect(handle, hEvent, NULL) ; unsigned long NonBlock = 0; ioctlsocket(handle, FIONBIO, &NonBlock); return handle; } llwarns << "Unable to open TCP channel, Timeout is the host up?" << netevents.iErrorCode[FD_CONNECT_BIT] << llendl; return -1; }
void host_object::test<9>() { std::string hostStr = "google.com"; LLHost host; host.setHostByName(hostStr); // reverse DNS will likely result in appending of some // sub-domain to the main hostname. so look for // the main domain name and not do the exact compare std::string hostname = host.getHostName(); ensure("getHostName failed", hostname.find(hostStr) != std::string::npos); }
void host_object::test<8>() { const std::string str("192.168.1.1"); U32 port = 8080; LLHost host; host.set(str,port); std::string ip_string = host.getIPString(); ensure("Function Failed", (ip_string == str)); std::string ip_string_port = host.getIPandPort(); ensure("Function Failed", (ip_string_port == "192.168.1.1:8080")); }
// static BOOL LLFloaterMessageLog::onClickCloseCircuit(void* user_data) { LLNetListItem* itemp = (LLNetListItem*)user_data; LLCircuitData* cdp = (LLCircuitData*)itemp->mCircuitData; if(!cdp) return FALSE; LLHost myhost = cdp->getHost(); LLSD args; args["MESSAGE"] = "This will delete local circuit data.\nDo you want to tell the remote host to close the circuit too?"; LLSD payload; payload["circuittoclose"] = myhost.getString(); LLNotificationsUtil::add("GenericAlertYesCancel", args, payload, onConfirmCloseCircuit); return TRUE; }
void SLFloaterMediaFilter::onBlacklistRemove() { LLScrollListItem* selected = mBlacklistSLC->getFirstSelected(); if (selected) { std::string domain = mBlacklistSLC->getSelectedItemLabel(); size_t pos = domain.find(' '); if (pos != std::string::npos) { domain = domain.substr(0, pos); } LLViewerParcelMedia::sDeniedMedia.erase(domain); for (S32 i = 0; i < (S32)LLViewerParcelMedia::sMediaFilterList.size(); i++) { if (LLViewerParcelMedia::sMediaFilterList[i]["domain"].asString() == domain) { LLViewerParcelMedia::sMediaFilterList.erase(i); break; } } if (childGetValue("match_ip") && domain.find('/') == std::string::npos) { LLHost host; host.setHostByName(domain); std::string ip = host.getIPString(); if (ip != domain) { LLViewerParcelMedia::sDeniedMedia.erase(ip); for (S32 i = 0; i < (S32)LLViewerParcelMedia::sMediaFilterList.size(); i++) { if (LLViewerParcelMedia::sMediaFilterList[i]["domain"].asString() == ip) { LLViewerParcelMedia::sMediaFilterList.erase(i); break; } } } } LLViewerParcelMedia::saveDomainFilterList(); setDirty(); } }
/** * @brief Initiates a SOCKS 5 proxy session. * * Performs basic checks on host to verify that it is a valid address. Opens the control channel * and then negotiates the proxy connection with the server. Closes any existing SOCKS * connection before proceeding. Also disables an HTTP proxy if it is using SOCKS as the proxy. * * * @param host Socks server to connect to. * @return SOCKS_OK if successful, otherwise a SOCKS error code defined in llproxy.h. */ S32 LLProxy::startSOCKSProxy(LLHost host) { if (host.isOk()) { mTCPProxy = host; } else { return SOCKS_INVALID_HOST; } // Close any running SOCKS connection. stopSOCKSProxy(); mProxyControlChannel = tcp_open_channel(mTCPProxy); if (!mProxyControlChannel) { return SOCKS_HOST_CONNECT_FAILED; } S32 status = proxyHandshake(mTCPProxy); if (status != SOCKS_OK) { // Shut down the proxy if any of the above steps failed. stopSOCKSProxy(); } else { // Connection was successful. sUDPProxyEnabled = true; } return status; }
S32 tcp_open_channel(LLHost host) { S32 handle; handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (!handle) { llwarns << "Error opening TCP control socket, socket() returned " << handle << llendl; return -1; } struct sockaddr_in address; address.sin_port = htons(host.getPort()); address.sin_family = AF_INET; address.sin_addr.s_addr = host.getAddress(); // Set the socket to non blocking for the connect() int flags = fcntl(handle, F_GETFL, 0); fcntl(handle, F_SETFL, flags | O_NONBLOCK); S32 error = connect(handle, (sockaddr*)&address, sizeof(address)); if (error && (errno != EINPROGRESS)) { llwarns << "Unable to open TCP channel, error code: " << errno << llendl; return -1; } struct timeval timeout; timeout.tv_sec = 5; // Maximum time to wait for the connect() to complete timeout.tv_usec = 0; fd_set fds; FD_ZERO(&fds); FD_SET(handle, &fds); // See if we have connectde or time out after 5 seconds U32 rc = select(sizeof(fds)*8, NULL, &fds, NULL, &timeout); if (rc != 1) // we require exactly one descriptor to be set { llwarns << "Unable to open TCP channel" << llendl; return -1; } // Return the socket to blocking operations fcntl(handle, F_SETFL, flags); return handle; }
BOOL LLPacketRing::doSendPacket(int h_socket, const char * send_buffer, S32 buf_size, LLHost host) { if (!LLSocks::isEnabled()) { return send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort()); } proxywrap_t *socks_header = (proxywrap_t *)&mProxyWrappedSendBuffer; 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(mProxyWrappedSendBuffer+10, send_buffer, buf_size); return send_packet(h_socket,(const char*) mProxyWrappedSendBuffer, buf_size+10, LLSocks::getInstance()->getUDPPproxy().getAddress(), LLSocks::getInstance()->getUDPPproxy().getPort()); }
void host_object::test<9>() { skip("this test is irreparably flaky"); // skip("setHostByName(\"google.com\"); getHostName() -> (e.g.) \"yx-in-f100.1e100.net\""); // nat: is it reasonable to expect LLHost::getHostName() to echo // back something resembling the string passed to setHostByName()? // // If that's not even reasonable, would a round trip in the /other/ // direction make more sense? (Call getHostName() for something with // known IP address; call setHostByName(); verify IP address) // // Failing that... is there a plausible way to test getHostName() and // setHostByName()? Hopefully without putting up a dummy local DNS // server? // monty: If you don't control the DNS server or the DNS configuration // for the test point then, no, none of these will necessarily be // reliable and may start to fail at any time. Forward translation // is subject to CNAME records and round-robin address assignment. // Reverse lookup is 1-to-many and is more and more likely to have // nothing to do with the forward translation. // // So the test is increasingly meaningless on a real network. std::string hostStr = "lindenlab.com"; LLHost host; host.setHostByName(hostStr); // reverse DNS will likely result in appending of some // sub-domain to the main hostname. so look for // the main domain name and not do the exact compare std::string hostname = host.getHostName(); try { ensure("getHostName failed", hostname.find(hostStr) != std::string::npos); } catch (const std::exception&) { std::cerr << "set '" << hostStr << "'; reported '" << hostname << "'" << std::endl; throw; } }
bool LLSocket::blockingConnect(const LLHost& host) { if(!mSocket) return false; apr_sockaddr_t* sa = NULL; std::string ip_address; ip_address = host.getIPString(); if(ll_apr_warn_status(apr_sockaddr_info_get( &sa, ip_address.c_str(), APR_UNSPEC, host.getPort(), 0, mPool()))) { return false; } setBlocking(1000); ll_debug_socket("Blocking connect", mSocket); if(ll_apr_warn_status(apr_socket_connect(mSocket, sa))) return false; setNonBlocking(); return true; }
void host_object::test<9>() { // skip("setHostByName(\"google.com\"); getHostName() -> (e.g.) \"yx-in-f100.1e100.net\""); std::string hostStr = "linux.org"; LLHost host; host.setHostByName(hostStr); // reverse DNS will likely result in appending of some // sub-domain to the main hostname. so look for // the main domain name and not do the exact compare std::string hostname = host.getHostName(); try { ensure("getHostName failed", hostname.find(hostStr) != std::string::npos); } catch (const std::exception&) { std::cerr << "set '" << hostStr << "'; reported '" << hostname << "'" << std::endl; throw; } }
/** * @brief Enable the HTTP proxy for either SOCKS or HTTP. * * Check the supplied host to see if it is a valid IP and port. * * @param httpHost Proxy server to connect to. * @param type Is the host a SOCKS or HTTP proxy. * @return Return true if applying the setting was successful. No changes are made if false. */ bool LLProxy::enableHTTPProxy(LLHost httpHost, LLHttpProxyType type) { if (!httpHost.isOk()) { LL_WARNS("Proxy") << "Invalid SOCKS 5 Server" << LL_ENDL; return false; } LLMutexLock lock(&mProxyMutex); mHTTPProxy = httpHost; mProxyType = type; mHTTPProxyEnabled = true; return true; }
LLViewerRegionImpl(LLViewerRegion * region, LLHost const & host) : mHost(host), mCompositionp(NULL), mEventPoll(NULL), // I'd prefer to set the LLCapabilityListener name to match the region // name -- it's disappointing that's not available at construction time. // We could instead store an LLCapabilityListener*, making // setRegionNameAndZone() replace the instance. Would that pose // consistency problems? Can we even request a capability before calling // setRegionNameAndZone()? // For testability -- the new Michael Feathers paradigm -- // LLCapabilityListener binds all the globals it expects to need at // construction time. mCapabilityListener(host.getString(), gMessageSystem, *region, gAgent.getID(), gAgent.getSessionID()) { }
void SLFloaterMediaFilter::draw() { if (mIsDirty && mWhitelistSLC && mBlacklistSLC) { S32 whitescrollpos = mWhitelistSLC->getScrollPos(); S32 blackscrollpos = mBlacklistSLC->getScrollPos(); mWhitelistSLC->deleteAllItems(); mBlacklistSLC->deleteAllItems(); std::set<std::string> listed; LLHost host; std::string ip; std::string domain; std::string action; LLSD element; element["columns"][0]["font"] = "SANSSERIF"; element["columns"][0]["font-style"] = "BOLD"; for (S32 i = 0; i < (S32)LLViewerParcelMedia::sMediaFilterList.size(); i++) { domain = LLViewerParcelMedia::sMediaFilterList[i]["domain"].asString(); if (mShowIPs) { host.setHostByName(domain); ip = host.getIPString(); if (ip != domain && domain.find('/') == std::string::npos) { domain += " (" + ip + ")"; } } action = LLViewerParcelMedia::sMediaFilterList[i]["action"].asString(); if (!domain.empty() && action == "allow") { element["columns"][0]["column"] = "whitelist_col"; element["columns"][0]["value"] = domain; //element["columns"][0]["color"] = LLColor4::green3.getValue(); mWhitelistSLC->addElement(element, ADD_BOTTOM); listed.insert(domain); } else if (!domain.empty() && action == "deny") { element["columns"][0]["column"] = "blacklist_col"; element["columns"][0]["value"] = domain; //element["columns"][0]["color"] = LLColor4::red2.getValue(); mBlacklistSLC->addElement(element, ADD_BOTTOM); listed.insert(domain); } else { LL_WARNS("MediaFilter") << "Bad media filter list: removing corrupted entry for \"" << domain << "\"" << LL_ENDL; LLViewerParcelMedia::sMediaFilterList.erase(i--); } } std::set<std::string>::iterator it; element["columns"][0]["font"] = "SANSSERIF"; element["columns"][0]["font-style"] = "ITALIC"; //element["columns"][0]["color"] = LLColor4::green3.getValue(); element["columns"][0]["column"] = "whitelist_col"; for (it = LLViewerParcelMedia::sAllowedMedia.begin(); it != LLViewerParcelMedia::sAllowedMedia.end(); it++) { domain = *it; if (mShowIPs) { host.setHostByName(domain); ip = host.getIPString(); if (ip != domain && domain.find('/') == std::string::npos) { domain += " (" + ip + ")"; } } if (listed.count(domain) == 0) { element["columns"][0]["value"] = domain; mWhitelistSLC->addElement(element, ADD_BOTTOM); } } element["columns"][0]["column"] = "blacklist_col"; for (it = LLViewerParcelMedia::sDeniedMedia.begin(); it != LLViewerParcelMedia::sDeniedMedia.end(); it++) { domain = *it; if (mShowIPs) { host.setHostByName(domain); ip = host.getIPString(); if (ip != domain && domain.find('/') == std::string::npos) { domain += " (" + ip + ")"; } } if (listed.count(domain) == 0) { element["columns"][0]["value"] = domain; mBlacklistSLC->addElement(element, ADD_BOTTOM); } } mWhitelistSLC->setScrollPos(whitescrollpos); mBlacklistSLC->setScrollPos(blackscrollpos); if (!gSavedSettings.getBOOL("MediaEnableFilter")) { childDisable("clear_lists"); childDisable("show_ips"); childDisable("blacklist_list"); childDisable("whitelist_list"); childDisable("remove_whitelist"); childDisable("add_whitelist"); childDisable("remove_blacklist"); childDisable("add_blacklist"); childDisable("match_ip"); childDisable("input_domain"); childDisable("commit_domain"); childSetText("add_text", std::string("****** WARNING: media filtering is currently DISABLED ******")); } mIsDirty = false; mShowIPs = false; } LLFloater::draw(); }
void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type) { std::string media_action; std::string media_url; std::string domain; std::string ip; if (parcel != LLViewerParcelMgr::getInstance()->getAgentParcel()) { // The parcel just changed (may occur right out after a TP) sIsUserAction = false; return; } if (type == 0) { media_url = parcel->getMediaURL(); } else { media_url = parcel->getMusicURL(); } LLStringUtil::trim(media_url); domain = extractDomain(media_url); if (sMediaQueries.count(domain) > 0) { sIsUserAction = false; return; } LLHost host; host.setHostByName(domain); ip = host.getIPString(); if (sIsUserAction) { // This was a user manual request to play this media, so give // it another chance... sIsUserAction = false; bool dirty = false; if (sDeniedMedia.count(domain)) { sDeniedMedia.erase(domain); dirty = true; } if (sDeniedMedia.count(ip)) { sDeniedMedia.erase(ip); dirty = true; } if (dirty) { SLFloaterMediaFilter::setDirty(); } } if (media_url.empty()) { media_action = "allow"; } else if (!sMediaFilterListLoaded || sDeniedMedia.count(domain) || sDeniedMedia.count(ip)) { media_action = "ignore"; } else if (sAllowedMedia.count(domain) || sAllowedMedia.count(ip)) { media_action = "allow"; } else { std::string server; for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++) { server = sMediaFilterList[i]["domain"].asString(); if (server == domain || server == ip) { media_action = sMediaFilterList[i]["action"].asString(); break; } } } if (media_action == "allow") { if (type == 0) { play(parcel, false); } else { playStreamingMusic(parcel, false); } return; } if (media_action == "ignore") { if (type == 1) { LLViewerParcelMedia::stopStreamingMusic(); } return; } LLSD args; if (ip != domain && domain.find('/') == std::string::npos) { args["DOMAIN"] = domain + " (" + ip + ")"; } else { args["DOMAIN"] = domain; } if (media_action == "deny") { LLNotificationsUtil::add("MediaBlocked", args); if (type == 1) { LLViewerParcelMedia::stopStreamingMusic(); } // So to avoid other "blocked" messages later in the session // for this url should it be requested again by a script. // We don't add the IP, on purpose (want to show different // blocks for different domains pointing to the same IP). sDeniedMedia.insert(domain); } else { sMediaQueries.insert(domain); args["URL"] = media_url; if (type == 0) { args["TYPE"] = "media"; } else { args["TYPE"] = "audio"; } LLNotificationsUtil::add("MediaAlert", args, LLSD(), boost::bind(callback_media_alert, _1, _2, parcel, type, domain)); } }
void host_object::test<1>() { LLHost host; ensure("IP address is not NULL", (0 == host.getAddress()) && (0 == host.getPort()) && !host.isOk()); }
/** * @brief Open the SOCKS 5 TCP control channel. * * Perform a SOCKS 5 authentication and UDP association with the proxy server. * * @param proxy The SOCKS 5 server to connect to. * @return SOCKS_OK if successful, otherwise a socks error code from llproxy.h. */ S32 LLProxy::proxyHandshake(LLHost proxy) { S32 result; /* SOCKS 5 Auth request */ socks_auth_request_t socks_auth_request; socks_auth_response_t socks_auth_response; socks_auth_request.version = SOCKS_VERSION; // SOCKS version 5 socks_auth_request.num_methods = 1; // Sending 1 method. socks_auth_request.methods = getSelectedAuthMethod(); // Send only the selected method. result = tcp_blocking_handshake(mProxyControlChannel, static_cast<char*>(static_cast<void*>(&socks_auth_request)), sizeof(socks_auth_request), static_cast<char*>(static_cast<void*>(&socks_auth_response)), sizeof(socks_auth_response)); if (result != APR_SUCCESS) { LL_WARNS("Proxy") << "SOCKS authentication request failed, error on TCP control channel : " << result << LL_ENDL; stopSOCKSProxy(); return SOCKS_CONNECT_ERROR; } if (socks_auth_response.method == AUTH_NOT_ACCEPTABLE) { LL_WARNS("Proxy") << "SOCKS 5 server refused all our authentication methods." << LL_ENDL; stopSOCKSProxy(); return SOCKS_NOT_ACCEPTABLE; } /* SOCKS 5 USERNAME/PASSWORD authentication */ if (socks_auth_response.method == METHOD_PASSWORD) { // The server has requested a username/password combination std::string socks_username(getSocksUser()); std::string socks_password(getSocksPwd()); U32 request_size = socks_username.size() + socks_password.size() + 3; char * password_auth = new char[request_size]; password_auth[0] = 0x01; password_auth[1] = (char) socks_username.size(); memcpy(&password_auth[2], socks_username.c_str(), socks_username.size()); password_auth[socks_username.size() + 2] = (char) socks_password.size(); memcpy(&password_auth[socks_username.size() + 3], socks_password.c_str(), socks_password.size()); authmethod_password_reply_t password_reply; result = tcp_blocking_handshake(mProxyControlChannel, password_auth, request_size, static_cast<char*>(static_cast<void*>(&password_reply)), sizeof(password_reply)); delete[] password_auth; if (result != APR_SUCCESS) { LL_WARNS("Proxy") << "SOCKS authentication failed, error on TCP control channel : " << result << LL_ENDL; stopSOCKSProxy(); return SOCKS_CONNECT_ERROR; } if (password_reply.status != AUTH_SUCCESS) { LL_WARNS("Proxy") << "SOCKS authentication failed" << LL_ENDL; stopSOCKSProxy(); return SOCKS_AUTH_FAIL; } } /* SOCKS5 connect request */ socks_command_request_t connect_request; socks_command_response_t connect_reply; connect_request.version = SOCKS_VERSION; // SOCKS V5 connect_request.command = COMMAND_UDP_ASSOCIATE; // Associate UDP connect_request.reserved = FIELD_RESERVED; connect_request.atype = ADDRESS_IPV4; connect_request.address = htonl(0); // 0.0.0.0 connect_request.port = htons(0); // 0 // "If the client is not in possession of the information at the time of the UDP ASSOCIATE, // the client MUST use a port number and address of all zeros. RFC 1928" result = tcp_blocking_handshake(mProxyControlChannel, static_cast<char*>(static_cast<void*>(&connect_request)), sizeof(connect_request), static_cast<char*>(static_cast<void*>(&connect_reply)), sizeof(connect_reply)); if (result != APR_SUCCESS) { LL_WARNS("Proxy") << "SOCKS connect request failed, error on TCP control channel : " << result << LL_ENDL; stopSOCKSProxy(); return SOCKS_CONNECT_ERROR; } if (connect_reply.reply != REPLY_REQUEST_GRANTED) { LL_WARNS("Proxy") << "Connection to SOCKS 5 server failed, UDP forward request not granted" << LL_ENDL; stopSOCKSProxy(); return SOCKS_UDP_FWD_NOT_GRANTED; } mUDPProxy.setPort(ntohs(connect_reply.port)); // reply port is in network byte order mUDPProxy.setAddress(proxy.getAddress()); // The connection was successful. We now have the UDP port to send requests that need forwarding to. LL_INFOS("Proxy") << "SOCKS 5 UDP proxy connected on " << mUDPProxy << LL_ENDL; return SOCKS_OK; }
void LLAssetStorage::getInvItemAsset(const LLHost &object_sim, const LLUUID &agent_id, const LLUUID &session_id, const LLUUID &owner_id, const LLUUID &task_id, const LLUUID &item_id, const LLUUID &asset_id, LLAssetType::EType atype, LLGetAssetCallback callback, void *user_data, BOOL is_priority) { lldebugs << "LLAssetStorage::getInvItemAsset() - " << asset_id << "," << LLAssetType::lookup(atype) << llendl; // // Probably will get rid of this early out? // //if (asset_id.isNull()) //{ // // Special case early out for NULL uuid // if (callback) // { // callback(mVFS, asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE); // } // return; //} bool exists = false; U32 size = 0; if(asset_id.notNull()) { exists = mVFS->getExists(asset_id, atype); LLVFile file(mVFS, asset_id, atype); size = exists ? file.getSize() : 0; if(exists && size < 1) { llwarns << "Asset vfile " << asset_id << ":" << atype << " found with bad size " << file.getSize() << ", removing" << llendl; file.remove(); } } if (size < 1) { // See whether we should talk to the object's originating sim, // or the upstream provider. LLHost source_host; if (object_sim.isOk()) { source_host = object_sim; } else { source_host = mUpstreamHost; } if (source_host.isOk()) { // stash the callback info so we can find it after we get the response message LLInvItemRequest *req = new LLInvItemRequest(asset_id, atype); req->mDownCallback = callback; req->mUserData = user_data; req->mIsPriority = is_priority; // send request message to our upstream data provider // Create a new asset transfer. LLTransferSourceParamsInvItem spi; spi.setAgentSession(agent_id, session_id); spi.setInvItem(owner_id, task_id, item_id); spi.setAsset(asset_id, atype); // Set our destination file, and the completion callback. LLTransferTargetParamsVFile tpvf; tpvf.setAsset(asset_id, atype); tpvf.setCallback(downloadInvItemCompleteCallback, req); llinfos << "Starting transfer for inventory asset " << item_id << " owned by " << owner_id << "," << task_id << llendl; LLTransferTargetChannel *ttcp = gTransferManager.getTargetChannel(source_host, LLTCT_ASSET); ttcp->requestTransfer(spi, tpvf, 100.f + (is_priority ? 1.f : 0.f)); } else { // uh-oh, we shouldn't have gotten here llwarns << "Attempt to move asset data request upstream w/o valid upstream provider" << llendl; if (callback) { callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LL_EXSTAT_NO_UPSTREAM); } } } else { // we've already got the file // theoretically, partial files w/o a pending request shouldn't happen // unless there's a weird error if (callback) { callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LL_EXSTAT_VFS_CACHED); } } }
void LLAssetStorage::getEstateAsset(const LLHost &object_sim, const LLUUID &agent_id, const LLUUID &session_id, const LLUUID &asset_id, LLAssetType::EType atype, EstateAssetType etype, LLGetAssetCallback callback, void *user_data, BOOL is_priority) { LL_DEBUGS() << "LLAssetStorage::getEstateAsset() - " << asset_id << "," << LLAssetType::lookup(atype) << ", estatetype " << etype << LL_ENDL; // // Probably will get rid of this early out? // if (asset_id.isNull()) { // Special case early out for NULL uuid if (callback) { callback(mVFS, asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LL_EXSTAT_NULL_UUID); } return; } // Try static VFS first. if (findInStaticVFSAndInvokeCallback(asset_id,atype,callback,user_data)) { return; } BOOL exists = mVFS->getExists(asset_id, atype); LLVFile file(mVFS, asset_id, atype); U32 size = exists ? file.getSize() : 0; if (size > 0) { // we've already got the file // theoretically, partial files w/o a pending request shouldn't happen // unless there's a weird error if (callback) { callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LL_EXSTAT_VFS_CACHED); } } else { if (exists) { LL_WARNS() << "Asset vfile " << asset_id << ":" << atype << " found with bad size " << file.getSize() << ", removing" << LL_ENDL; file.remove(); } // See whether we should talk to the object's originating sim, or the upstream provider. LLHost source_host; if (object_sim.isOk()) { source_host = object_sim; } else { source_host = mUpstreamHost; } if (source_host.isOk()) { // stash the callback info so we can find it after we get the response message LLEstateAssetRequest *req = new LLEstateAssetRequest(asset_id, atype, etype); req->mDownCallback = callback; req->mUserData = user_data; req->mIsPriority = is_priority; // send request message to our upstream data provider // Create a new asset transfer. LLTransferSourceParamsEstate spe; spe.setAgentSession(agent_id, session_id); spe.setEstateAssetType(etype); // Set our destination file, and the completion callback. LLTransferTargetParamsVFile tpvf; tpvf.setAsset(asset_id, atype); tpvf.setCallback(downloadEstateAssetCompleteCallback, req); LL_DEBUGS("AssetStorage") << "Starting transfer for " << asset_id << LL_ENDL; LLTransferTargetChannel *ttcp = gTransferManager.getTargetChannel(source_host, LLTCT_ASSET); ttcp->requestTransfer(spe, tpvf, 100.f + (is_priority ? 1.f : 0.f)); } else { // uh-oh, we shouldn't have gotten here LL_WARNS() << "Attempt to move asset data request upstream w/o valid upstream provider" << LL_ENDL; if (callback) { callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LL_EXSTAT_NO_UPSTREAM); } } } }
BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LLHost host) { BOOL status = TRUE; if (!mUseOutThrottle) { return send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort() ); } 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 = send_packet(h_socket, packetp->getData(), packet_size, packetp->getHost().getAddress(), packetp->getHost().getPort()); 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 = send_packet(h_socket, send_buffer, buf_size, host.getAddress(), host.getPort() ); 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. llwarns << "Throwing away outbound packet, overflowing buffer" << llendl; } else { static LLTimer queue_timer; if ((mOutBufferLength > 4192) && queue_timer.getElapsedTimeF32() > 1.f) { // Add it to the queue llinfos << "Outbound packet queue " << mOutBufferLength << " bytes" << llendl; queue_timer.reset(); } packetp = new LLPacketBuffer(host, send_buffer, buf_size); mOutBufferLength += packetp->getSize(); mSendQueue.push(packetp); } } return status; }
void SLFloaterMediaFilter::onCommitDomain() { std::string domain = childGetText("input_domain"); domain = LLViewerParcelMedia::extractDomain(domain); LLHost host; host.setHostByName(domain); std::string ip = host.getIPString(); bool match_ip = (childGetValue("match_ip") && ip != domain && domain.find('/') == std::string::npos); if (!domain.empty()) { LLViewerParcelMedia::sDeniedMedia.erase(domain); LLViewerParcelMedia::sAllowedMedia.erase(domain); for (S32 i = 0; i < (S32)LLViewerParcelMedia::sMediaFilterList.size(); i++) { if (LLViewerParcelMedia::sMediaFilterList[i]["domain"].asString() == domain) { LLViewerParcelMedia::sMediaFilterList.erase(i); } } if (match_ip) { LLViewerParcelMedia::sDeniedMedia.erase(ip); LLViewerParcelMedia::sAllowedMedia.erase(ip); for (S32 i = 0; i < (S32)LLViewerParcelMedia::sMediaFilterList.size(); i++) { if (LLViewerParcelMedia::sMediaFilterList[i]["domain"].asString() == ip) { LLViewerParcelMedia::sMediaFilterList.erase(i); } } } LLSD newmedia; newmedia["domain"] = domain; if (mIsWhitelist) { newmedia["action"] = "allow"; } else { newmedia["action"] = "deny"; } LLViewerParcelMedia::sMediaFilterList.append(newmedia); if (match_ip) { newmedia["domain"] = ip; LLViewerParcelMedia::sMediaFilterList.append(newmedia); } LLViewerParcelMedia::saveDomainFilterList(); } childEnable("clear_lists"); childEnable("show_ips"); childEnable("blacklist_list"); childEnable("whitelist_list"); childEnable("remove_whitelist"); childEnable("add_whitelist"); childEnable("remove_blacklist"); childEnable("add_blacklist"); childDisable("input_domain"); childDisable("commit_domain"); childSetText("add_text", std::string("New domain:")); childSetText("input_domain", std::string("")); setDirty(); }
void callback_media_alert(const LLSD ¬ification, const LLSD &response, LLParcel* parcel, U32 type, std::string domain) { S32 option = LLNotification::getSelectedOption(notification, response); LLHost host; host.setHostByName(domain); std::string ip = host.getIPString(); LLSD args; if (ip != domain && domain.find('/') == std::string::npos) { args["DOMAIN"] = domain + " (" + ip + ")"; } else { args["DOMAIN"] = domain; } if (option == 0 || option == 3) // Allow or Whitelist { LLViewerParcelMedia::sAllowedMedia.insert(domain); if (option == 3) // Whitelist { LLSD newmedia; newmedia["domain"] = domain; newmedia["action"] = "allow"; LLViewerParcelMedia::sMediaFilterList.append(newmedia); if (ip != domain && domain.find('/') == std::string::npos) { newmedia["domain"] = ip; LLViewerParcelMedia::sMediaFilterList.append(newmedia); } LLViewerParcelMedia::saveDomainFilterList(); args["LISTED"] = "whitelisted"; LLNotificationsUtil::add("MediaListed", args); } if (type == 0) { LLViewerParcelMedia::play(parcel, false); } else { LLViewerParcelMedia::playStreamingMusic(parcel, false); } } else if (option == 1 || option == 2) // Deny or Blacklist { LLViewerParcelMedia::sDeniedMedia.insert(domain); if (ip != domain && domain.find('/') == std::string::npos) { LLViewerParcelMedia::sDeniedMedia.insert(ip); } if (type == 1) { LLViewerParcelMedia::stopStreamingMusic(); } if (option == 1) // Deny { LLNotificationsUtil::add("MediaBlocked", args); } else // Blacklist { LLSD newmedia; newmedia["domain"] = domain; newmedia["action"] = "deny"; LLViewerParcelMedia::sMediaFilterList.append(newmedia); if (ip != domain && domain.find('/') == std::string::npos) { newmedia["domain"] = ip; LLViewerParcelMedia::sMediaFilterList.append(newmedia); } LLViewerParcelMedia::saveDomainFilterList(); args["LISTED"] = "blacklisted"; LLNotificationsUtil::add("MediaListed", args); } } LLViewerParcelMedia::sMediaQueries.erase(domain); SLFloaterMediaFilter::setDirty(); }
void host_object::test<7>() { const char* str = "192.168.1.1"; U32 port = 8080, ip; LLHost host; host.set(str,port); ip = ip_string_to_u32(str); ensure("IP address is invalid", (ip == host.getAddress())); ensure("Port Number is invalid", (port == host.getPort())); str = "64.233.187.99"; ip = ip_string_to_u32(str); host.setAddress(str); ensure("IP address is invalid", (ip == host.getAddress())); ip = 0xc098017b; host.setAddress(ip); ensure("IP address is invalid", (ip == host.getAddress())); // should still use the old port ensure("Port Number is invalid", (port == host.getPort())); port = 8084; host.setPort(port); ensure("Port Number is invalid", (port == host.getPort())); // should still use the old address ensure("IP address is invalid", (ip == host.getAddress())); }
LLViewerRegion::LLViewerRegion(const U64 &handle, const LLHost &host, const U32 grids_per_region_edge, const U32 grids_per_patch_edge, const F32 region_width_meters) : mCenterGlobal(), mHandle(handle), mHost( host ), mTimeDilation(1.0f), mName(""), mZoning(""), mOwnerID(), mIsEstateManager(FALSE), mCompositionp(NULL), mRegionFlags( REGION_FLAGS_DEFAULT ), mSimAccess( SIM_ACCESS_MIN ), mBillableFactor(1.0), mMaxTasks(DEFAULT_MAX_REGION_WIDE_PRIM_COUNT), mClassID(0), mCPURatio(0), mColoName("unknown"), mProductSKU("unknown"), mProductName("unknown"), mHttpUrl(""), mCacheLoaded(FALSE), mCacheDirty(FALSE), mCacheID(), mEventPoll(NULL), mReleaseNotesRequested(FALSE), // I'd prefer to set the LLCapabilityListener name to match the region // name -- it's disappointing that's not available at construction time. // We could instead store an LLCapabilityListener*, making // setRegionNameAndZone() replace the instance. Would that pose // consistency problems? Can we even request a capability before calling // setRegionNameAndZone()? // For testability -- the new Michael Feathers paradigm -- // LLCapabilityListener binds all the globals it expects to need at // construction time. mCapabilityListener(host.getString(), gMessageSystem, *this, gAgent.getID(), gAgent.getSessionID()) { mWidth = region_width_meters; mOriginGlobal = from_region_handle(handle); updateRenderMatrix(); mLandp = new LLSurface('l', NULL); if (!gNoRender) { // Create the composition layer for the surface mCompositionp = new LLVLComposition(mLandp, grids_per_region_edge, region_width_meters/grids_per_region_edge); mCompositionp->setSurface(mLandp); // Create the surfaces mLandp->setRegion(this); mLandp->create(grids_per_region_edge, grids_per_patch_edge, mOriginGlobal, mWidth); } if (!gNoRender) { mParcelOverlay = new LLViewerParcelOverlay(this, region_width_meters); } else { mParcelOverlay = NULL; } setOriginGlobal(from_region_handle(handle)); calculateCenterGlobal(); // Create the object lists initStats(); //create object partitions //MUST MATCH declaration of eObjectPartitions mObjectPartition.push_back(new LLHUDPartition()); //PARTITION_HUD mObjectPartition.push_back(new LLTerrainPartition()); //PARTITION_TERRAIN mObjectPartition.push_back(new LLWaterPartition()); //PARTITION_WATER mObjectPartition.push_back(new LLTreePartition()); //PARTITION_TREE mObjectPartition.push_back(new LLParticlePartition()); //PARTITION_PARTICLE mObjectPartition.push_back(new LLCloudPartition()); //PARTITION_CLOUD mObjectPartition.push_back(new LLGrassPartition()); //PARTITION_GRASS mObjectPartition.push_back(new LLVolumePartition()); //PARTITION_VOLUME mObjectPartition.push_back(new LLBridgePartition()); //PARTITION_BRIDGE mObjectPartition.push_back(new LLHUDParticlePartition());//PARTITION_HUD_PARTICLE mObjectPartition.push_back(NULL); //PARTITION_NONE }