void PtexMainWriter::finish() { // do nothing if there's no new data to write if (!_hasNewData) return; // copy missing faces from _reader if (_reader) { for (int i = 0, nfaces = _header.nfaces; i < nfaces; i++) { if (_faceinfo[i].flags == uint8_t(-1)) { // copy face data const Ptex::FaceInfo& info = _reader->getFaceInfo(i); int size = _pixelSize * info.res.size(); if (info.isConstant()) { PtexPtr<PtexFaceData> data ( _reader->getData(i) ); if (data) { writeConstantFace(i, info, data->getData()); } } else { void* data = malloc(size); _reader->getData(i, data, 0); writeFace(i, info, data, 0); free(data); } } } } else { // just flag missing faces as constant (black) for (int i = 0, nfaces = _header.nfaces; i < nfaces; i++) { if (_faceinfo[i].flags == uint8_t(-1)) _faceinfo[i].flags = FaceInfo::flag_constant; } } // write reductions to tmp file if (_genmipmaps) generateReductions(); // flag faces w/ constant neighborhoods flagConstantNeighorhoods(); // update header _header.nlevels = uint16_t(_levels.size()); _header.nfaces = uint32_t(_faceinfo.size()); // create new file FILE* newfp = fopen(_newpath.c_str(), "wb+"); if (!newfp) { setError(fileError("Can't write to ptex file: ", _newpath.c_str())); return; } // write blank header (to fill in later) writeBlank(newfp, HeaderSize); writeBlank(newfp, ExtHeaderSize); // write compressed face info block _header.faceinfosize = writeZipBlock(newfp, &_faceinfo[0], sizeof(FaceInfo)*_header.nfaces); // write compressed const data block _header.constdatasize = writeZipBlock(newfp, &_constdata[0], int(_constdata.size())); // write blank level info block (to fill in later) FilePos levelInfoPos = ftello(newfp); writeBlank(newfp, LevelInfoSize * _header.nlevels); // write level data blocks (and record level info) std::vector<LevelInfo> levelinfo(_header.nlevels); for (int li = 0; li < _header.nlevels; li++) { LevelInfo& info = levelinfo[li]; LevelRec& level = _levels[li]; int nfaces = int(level.fdh.size()); info.nfaces = nfaces; // output compressed level data header info.levelheadersize = writeZipBlock(newfp, &level.fdh[0], sizeof(FaceDataHeader)*nfaces); info.leveldatasize = info.levelheadersize; // copy level data from tmp file for (int fi = 0; fi < nfaces; fi++) info.leveldatasize += copyBlock(newfp, _tmpfp, level.pos[fi], level.fdh[fi].blocksize()); _header.leveldatasize += info.leveldatasize; } rewind(_tmpfp); // write meta data (if any) if (!_metadata.empty()) writeMetaData(newfp); // update extheader for edit data position _extheader.editdatapos = ftello(newfp); // rewrite level info block fseeko(newfp, levelInfoPos, SEEK_SET); _header.levelinfosize = writeBlock(newfp, &levelinfo[0], LevelInfoSize*_header.nlevels); // rewrite header fseeko(newfp, 0, SEEK_SET); writeBlock(newfp, &_header, HeaderSize); writeBlock(newfp, &_extheader, ExtHeaderSize); fclose(newfp); }
bool Connection::processHandshake() { // Parse data UINT8 protocolVersion = m_reader.readByte(); if (protocolVersion == 0xff) { setError("Too many connections reported by server", 0, UME_OTHER); return false; } else if (protocolVersion != MYSQL_PROTOCOL_VERSION) { setError("Protocol version not supported(1)", 0, UME_OTHER); return false; } char *serverVersion = m_reader.readNTString(); UINT32 threadId = m_reader.readLong(); char *scrambleBuff = (char *) m_reader.readBytes(8); UINT8 filler1 = m_reader.readByte(); UINT16 serverCaps = m_reader.readShort(); if (!(serverCaps & MCP_PROTOCOL_41)) { setError("Authentication < 4.1 not supported", 1, UME_OTHER); return false; } UINT8 serverLang = m_reader.readByte(); UINT16 serverStatus = m_reader.readShort(); UINT8 *filler2 = m_reader.readBytes(13); char *scrambleBuff2 = NULL; if (m_reader.getBytesLeft ()) { scrambleBuff2 = (char *) m_reader.readNTString(); } else { setError("Authentication < 4.1 not supported", 2, UME_OTHER); return false; } m_clientCaps = serverCaps; m_clientCaps &= ~MCP_COMPRESS; m_clientCaps &= ~MCP_NO_SCHEMA; m_clientCaps &= ~MCP_SSL; if (!(serverCaps & MCP_CONNECT_WITH_DB) && !m_database.empty()) { setError("Protocol < 4.1 not supported", 3, UME_OTHER); return false; } if ((serverCaps & MCP_CONNECT_WITH_DB) && m_database.empty()) { m_clientCaps &= ~MCP_CONNECT_WITH_DB; } m_reader.skip(); m_writer.reset(); m_writer.writeLong (m_clientCaps); m_writer.writeLong (MYSQL_PACKET_SIZE); if (m_charset != MCS_UNDEFINED) { m_writer.writeByte( (UINT8) (int) m_charset); } else { m_writer.writeByte(serverLang); } for (int filler = 0; filler < 23; filler ++) m_writer.writeByte(0x00); m_writer.writeNTString(m_username.c_str ()); if (!m_password.empty()) { m_writer.writeByte(20); UINT8 token[20]; scramble(scrambleBuff, scrambleBuff2, token); m_writer.writeBytes(token, 20); } else { m_writer.writeByte(0x00); } if (!m_database.empty()) { m_writer.writeNTString(m_database.c_str()); } m_writer.finalize(1); return true; }
void *Connection::query(const char *_query, size_t _cbQuery) { m_dbgMethodProgress ++; if (m_dbgMethodProgress > 1) { /* NOTE: We don't call setError here because it will close the socket worsening the concurrent access error making it impossible to trace */ m_errorMessage = "Concurrent access in query method"; m_errno = 0; m_errorType = UME_OTHER; m_dbgMethodProgress --; return NULL; } if (m_sockInst == NULL) { PRINTMARK(); setError ("Not connected", 0, UME_OTHER); m_dbgMethodProgress --; return NULL; } size_t len = _cbQuery; if (len > m_writer.getSize () - (MYSQL_PACKET_HEADER_SIZE + 1)) { PRINTMARK(); setError ("Query too big", 0, UME_OTHER); m_dbgMethodProgress --; return NULL; } m_writer.reset(); m_writer.writeByte(MC_QUERY); m_writer.writeBytes ( (void *) _query, len); m_writer.finalize(0); if (!sendPacket()) { PRINTMARK(); m_dbgMethodProgress --; return NULL; } if (!recvPacket()) { PRINTMARK(); m_dbgMethodProgress --; return NULL; } UINT8 result = m_reader.readByte(); switch (result) { case 0x00: PRINTMARK(); m_dbgMethodProgress --; return handleOKPacket(); case 0xff: PRINTMARK(); handleErrorPacket(); m_dbgMethodProgress --; return NULL; case 0xfe: PRINTMARK(); setError ("Unexpected EOF when decoding result", 0, UME_OTHER); m_dbgMethodProgress --; return NULL; default: PRINTMARK(); m_dbgMethodProgress --; return handleResultPacket((int)result); } PRINTMARK(); m_dbgMethodProgress --; return NULL; }
bool VideoPlayerBackend::start(const QUrl &url) { Q_ASSERT(!m_pipeline); if (state() == PermanentError || m_pipeline) return false; if (!m_sink) { setError(true, QLatin1String("Internal error: improper usage")); return false; } /* Pipeline */ m_pipeline = gst_pipeline_new("stream"); if (!m_pipeline) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("stream"))); return false; } /* Buffered HTTP source */ setVideoBuffer(new VideoHttpBuffer(url)); GstElement *source = m_videoBuffer->setupSrcElement(m_pipeline); if (!source) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("source"))); setVideoBuffer(0); return false; } m_videoBuffer->startBuffering(); /* Decoder */ GstElement *decoder = gst_element_factory_make("decodebin2", "decoder"); if (!decoder) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("decoder"))); return false; } g_object_set(G_OBJECT(decoder), "use-buffering", TRUE, "max-size-time", 10 * GST_SECOND, NULL); g_signal_connect(decoder, "new-decoded-pad", G_CALLBACK(staticDecodePadReady), this); /* Colorspace conversion (no-op if unnecessary) */ GstElement *colorspace = gst_element_factory_make("ffmpegcolorspace", "colorspace"); if (!colorspace) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("colorspace"))); return false; } gst_bin_add_many(GST_BIN(m_pipeline), decoder, colorspace, m_sink, NULL); if (!gst_element_link(source, decoder)) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("link decoder"))); return false; } if (!gst_element_link(colorspace, m_sink)) { setError(true, tr("Failed to create video pipeline (%1)").arg(QLatin1String("link sink"))); return false; } /* This is the element that is linked to the decoder for video output; it will be linked when decodePadReady * gives us the video pad. */ m_videoLink = colorspace; m_playbackSpeed = 1.0; /* We handle all messages in the sync handler, because we can't run a glib event loop. * Although linux does use glib's loop (and we could take advantage of that), it's better * to handle everything this way for windows and mac support. */ GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(m_pipeline)); Q_ASSERT(bus); gst_bus_enable_sync_message_emission(bus); gst_bus_set_sync_handler(bus, staticBusHandler, this); gst_object_unref(bus); /* Move the pipeline into the PLAYING state. This call may block for a very long time * (up to several seconds), because it will block until the pipeline has completed that move. */ gst_element_set_state(m_pipeline, GST_STATE_READY); return true; }
HRESULT VFSExplorer::i_updateS3(TaskVFSExplorer *aTask) { LogFlowFuncEnter(); AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS); HRESULT rc = S_OK; RTS3 hS3 = NULL; std::list<VFSExplorer::Data::DirEntry> fileList; try { int vrc = RTS3Create(&hS3, m->strUsername.c_str(), m->strPassword.c_str(), m->strHostname.c_str(), "virtualbox-agent/" VBOX_VERSION_STRING); if (RT_FAILURE(vrc)) throw setError(E_FAIL, tr ("Can't open S3 storage service (%Rrc)"), vrc); RTS3SetProgressCallback(hS3, VFSExplorer::TaskVFSExplorer::uploadProgress, &aTask); /* Do we need the list of buckets or keys? */ if (m->strBucket.isEmpty()) { PCRTS3BUCKETENTRY pBuckets = NULL; vrc = RTS3GetBuckets(hS3, &pBuckets); if (RT_FAILURE(vrc)) throw setError(E_FAIL, tr ("Can't get buckets (%Rrc)"), vrc); PCRTS3BUCKETENTRY pTmpBuckets = pBuckets; while (pBuckets) { /* Set always read/write permissions of the current logged in user. */ fileList.push_back(VFSExplorer::Data::DirEntry(pBuckets->pszName, VFSFileType_Directory, 0, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR)); pBuckets = pBuckets->pNext; } RTS3BucketsDestroy(pTmpBuckets); } else { PCRTS3KEYENTRY pKeys = NULL; vrc = RTS3GetBucketKeys(hS3, m->strBucket.c_str(), &pKeys); if (RT_FAILURE(vrc)) throw setError(E_FAIL, tr ("Can't get keys for bucket (%Rrc)"), vrc); PCRTS3KEYENTRY pTmpKeys = pKeys; while (pKeys) { Utf8Str name(pKeys->pszName); /* Set always read/write permissions of the current logged in user. */ fileList.push_back(VFSExplorer::Data::DirEntry(pKeys->pszName, VFSFileType_File, pKeys->cbFile, RTFS_UNIX_IRUSR | RTFS_UNIX_IWUSR)); pKeys = pKeys->pNext; } RTS3KeysDestroy(pTmpKeys); } } catch(HRESULT aRC) { rc = aRC; } if (hS3 != NULL) RTS3Destroy(hS3); /* Assign the result on success (this clears the old list) */ if (rc == S_OK) m->entryList.assign(fileList.begin(), fileList.end()); aTask->rc = rc; if (!aTask->progress.isNull()) aTask->progress->i_notifyComplete(rc); LogFlowFunc(("rc=%Rhrc\n", rc)); LogFlowFuncLeave(); return VINF_SUCCESS; }
void Soprano::Error::ErrorCache::setError( const QString& errorMessage, int code ) const { setError( Error( errorMessage, code ) ); }
HRESULT StorageController::setPortCount(ULONG aPortCount) { /* the machine needs to be mutable */ AutoMutableStateDependency adep(m->pParent); if (FAILED(adep.rc())) return adep.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); switch (m->bd->storageBus) { case StorageBus_SATA: { /* AHCI SATA supports a maximum of 30 ports. */ if (aPortCount < 1 || aPortCount > 30) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 1, 30); break; } case StorageBus_SCSI: { /* * SCSI does not support setting different ports. * (doesn't make sense here either). * The maximum and minimum is 16 and unless the callee * tries to set a different value we return an error. */ if (aPortCount != 16) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 16, 16); break; } case StorageBus_IDE: { /* * The port count is fixed to 2. */ if (aPortCount != 2) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 2, 2); break; } case StorageBus_Floppy: { /* * The port count is fixed to 1. */ if (aPortCount != 1) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 1, 1); break; } case StorageBus_SAS: { /* SAS supports a maximum of 255 ports. */ if (aPortCount < 1 || aPortCount > 255) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 1, 255); break; } case StorageBus_USB: { /* * The port count is fixed to 8. */ if (aPortCount != 8) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 8, 8); break; } case StorageBus_PCIe: { /* * PCIe (NVMe in particular) supports theoretically 2^32 - 1 * different namespaces, limit the amount artifically here. */ if (aPortCount < 1 || aPortCount > 255) return setError(E_INVALIDARG, tr("Invalid port count: %lu (must be in range [%lu, %lu])"), aPortCount, 1, 255); break; } default: AssertMsgFailed(("Invalid controller type %d\n", m->bd->storageBus)); } if (m->bd->ulPortCount != aPortCount) { m->bd.backup(); m->bd->ulPortCount = aPortCount; alock.release(); AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS); // m->pParent is const, needs no locking m->pParent->i_setModified(Machine::IsModified_Storage); mlock.release(); m->pParent->i_onStorageControllerChange(m->pParent->i_getId(), m->bd->strName); } return S_OK; }
bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &addr, quint16 port) { #ifdef QNATIVESOCKETENGINE_DEBUG qDebug("QNativeSocketEnginePrivate::nativeConnect() : %d ", socketDescriptor); #endif struct sockaddr_in sockAddrIPv4; struct sockaddr *sockAddrPtr = 0; QT_SOCKLEN_T sockAddrSize = 0; struct sockaddr_in6 sockAddrIPv6; if (addr.protocol() == QAbstractSocket::IPv6Protocol) { memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6)); sockAddrIPv6.sin6_family = AF_INET6; sockAddrIPv6.sin6_port = htons(port); QString scopeid = addr.scopeId(); bool ok; sockAddrIPv6.sin6_scope_id = scopeid.toInt(&ok); #ifndef QT_NO_IPV6IFNAME if (!ok) sockAddrIPv6.sin6_scope_id = ::if_nametoindex(scopeid.toLatin1()); #endif Q_IPV6ADDR ip6 = addr.toIPv6Address(); memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &ip6, sizeof(ip6)); sockAddrSize = sizeof(sockAddrIPv6); sockAddrPtr = (struct sockaddr *) &sockAddrIPv6; } else if (addr.protocol() == QAbstractSocket::IPv4Protocol) { memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4)); sockAddrIPv4.sin_family = AF_INET; sockAddrIPv4.sin_port = htons(port); sockAddrIPv4.sin_addr.s_addr = htonl(addr.toIPv4Address()); sockAddrSize = sizeof(sockAddrIPv4); sockAddrPtr = (struct sockaddr *) &sockAddrIPv4; } else { // unreachable } int connectResult = qt_safe_connect(socketDescriptor, sockAddrPtr, sockAddrSize); if (connectResult == -1) { switch (errno) { case EISCONN: socketState = QAbstractSocket::ConnectedState; break; case ECONNREFUSED: case EINVAL: setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString); socketState = QAbstractSocket::UnconnectedState; break; case ETIMEDOUT: setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString); break; case EHOSTUNREACH: setError(QAbstractSocket::NetworkError, HostUnreachableErrorString); socketState = QAbstractSocket::UnconnectedState; break; case ENETUNREACH: setError(QAbstractSocket::NetworkError, NetworkUnreachableErrorString); socketState = QAbstractSocket::UnconnectedState; break; case EADDRINUSE: setError(QAbstractSocket::NetworkError, AddressInuseErrorString); break; case EINPROGRESS: case EALREADY: setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString); socketState = QAbstractSocket::ConnectingState; break; case EAGAIN: setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString); setError(QAbstractSocket::SocketResourceError, ResourceErrorString); break; case EACCES: case EPERM: setError(QAbstractSocket::SocketAccessError, AccessErrorString); socketState = QAbstractSocket::UnconnectedState; break; case EAFNOSUPPORT: case EBADF: case EFAULT: case ENOTSOCK: socketState = QAbstractSocket::UnconnectedState; default: break; } if (socketState != QAbstractSocket::ConnectedState) { #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == false (%s)", addr.toString().toLatin1().constData(), port, socketState == QAbstractSocket::ConnectingState ? "Connection in progress" : socketErrorString.toLatin1().constData()); #endif return false; } } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == true", addr.toString().toLatin1().constData(), port); #endif socketState = QAbstractSocket::ConnectedState; return true; }
bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port) { struct sockaddr_in sockAddrIPv4; struct sockaddr *sockAddrPtr = 0; QT_SOCKLEN_T sockAddrSize = 0; struct sockaddr_in6 sockAddrIPv6; if (address.protocol() == QAbstractSocket::IPv6Protocol || address.protocol() == QAbstractSocket::AnyIPProtocol) { #ifdef IPV6_V6ONLY int ipv6only = 0; if (address.protocol() == QAbstractSocket::IPv6Protocol) ipv6only = 1; //default value of this socket option varies depending on unix variant (or system configuration on BSD), so always set it explicitly ::setsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&ipv6only, sizeof(ipv6only) ); #endif memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6)); sockAddrIPv6.sin6_family = AF_INET6; sockAddrIPv6.sin6_port = htons(port); #ifndef QT_NO_IPV6IFNAME sockAddrIPv6.sin6_scope_id = ::if_nametoindex(address.scopeId().toLatin1().data()); #else sockAddrIPv6.sin6_scope_id = address.scopeId().toInt(); #endif Q_IPV6ADDR tmp = address.toIPv6Address(); memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &tmp, sizeof(tmp)); sockAddrSize = sizeof(sockAddrIPv6); sockAddrPtr = (struct sockaddr *) &sockAddrIPv6; } else if (address.protocol() == QAbstractSocket::IPv4Protocol) { memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4)); sockAddrIPv4.sin_family = AF_INET; sockAddrIPv4.sin_port = htons(port); sockAddrIPv4.sin_addr.s_addr = htonl(address.toIPv4Address()); sockAddrSize = sizeof(sockAddrIPv4); sockAddrPtr = (struct sockaddr *) &sockAddrIPv4; } else { // unreachable } int bindResult = QT_SOCKET_BIND(socketDescriptor, sockAddrPtr, sockAddrSize); if (bindResult < 0) { switch(errno) { case EADDRINUSE: setError(QAbstractSocket::AddressInUseError, AddressInuseErrorString); break; case EACCES: setError(QAbstractSocket::SocketAccessError, AddressProtectedErrorString); break; case EINVAL: setError(QAbstractSocket::UnsupportedSocketOperationError, OperationUnsupportedErrorString); break; case EADDRNOTAVAIL: setError(QAbstractSocket::SocketAddressNotAvailableError, AddressNotAvailableErrorString); break; default: break; } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == false (%s)", address.toString().toLatin1().constData(), port, socketErrorString.toLatin1().constData()); #endif return false; } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == true", address.toString().toLatin1().constData(), port); #endif socketState = QAbstractSocket::BoundState; return true; }
TCPSession::TCPSession(TCPV6Socket &s, int pri, size_t stack) : Thread(pri, stack), TCPStream(s) { setCompletion(true); setError(false); }
TCPStream::TCPStream(TCPSocket &server, bool throwflag, timeout_t to) : streambuf(), Socket(accept(server.getSocket(), NULL, NULL)), #ifdef OLD_IOSTREAM iostream() #else iostream((streambuf *)this) #endif ,bufsize(0) ,gbuf(NULL) ,pbuf(NULL) { tpport_t port; family = IPV4; #ifdef OLD_IOSTREAM init((streambuf *)this); #endif timeout = to; setError(throwflag); IPV4Host host = getPeer(&port); if(!server.onAccept(host, port)) { endSocket(); error(errConnectRejected); iostream::clear(ios::failbit | rdstate()); return; } segmentBuffering(server.getSegmentSize()); Socket::state = CONNECTED; } #ifdef CCXX_IPV6 TCPStream::TCPStream(TCPV6Socket &server, bool throwflag, timeout_t to) : streambuf(), Socket(accept(server.getSocket(), NULL, NULL)), #ifdef OLD_IOSTREAM iostream() #else iostream((streambuf *)this) #endif ,bufsize(0) ,gbuf(NULL) ,pbuf(NULL) { tpport_t port; family = IPV6; #ifdef OLD_IOSTREAM init((streambuf *)this); #endif timeout = to; setError(throwflag); IPV6Host host = getIPV6Peer(&port); if(!server.onAccept(host, port)) { endSocket(); error(errConnectRejected); iostream::clear(ios::failbit | rdstate()); return; } segmentBuffering(server.getSegmentSize()); Socket::state = CONNECTED; } #endif TCPStream::TCPStream(const IPV4Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) : streambuf(), Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), #ifdef OLD_IOSTREAM iostream(), #else iostream((streambuf *)this), #endif bufsize(0),gbuf(NULL),pbuf(NULL) { #ifdef OLD_IOSTREAM init((streambuf *)this); #endif family = IPV4; timeout = to; setError(throwflag); connect(host, port, size); } #ifdef CCXX_IPV6 TCPStream::TCPStream(const IPV6Host &host, tpport_t port, unsigned size, bool throwflag, timeout_t to) : streambuf(), Socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP), #ifdef OLD_IOSTREAM iostream(), #else iostream((streambuf *)this), #endif bufsize(0),gbuf(NULL),pbuf(NULL) { family = IPV6; #ifdef OLD_IOSTREAM init((streambuf *)this); #endif timeout = to; setError(throwflag); connect(host, port, size); } #endif TCPStream::~TCPStream() { #ifdef CCXX_EXCEPTIONS try { endStream(); } catch( ... ) { if ( ! std::uncaught_exception()) throw;}; #else endStream(); #endif } #ifdef HAVE_GETADDRINFO void TCPStream::connect(const char *target, unsigned mss) { char namebuf[128]; char *cp; struct addrinfo hint, *list = NULL, *next, *first; bool connected = false; snprintf(namebuf, sizeof(namebuf), "%s", target); cp = strrchr(namebuf, '/'); if(!cp) cp = strrchr(namebuf, ':'); if(!cp) { endStream(); connectError(); return; } *(cp++) = 0; memset(&hint, 0, sizeof(hint)); hint.ai_family = family; hint.ai_socktype = SOCK_STREAM; hint.ai_protocol = IPPROTO_TCP; if(getaddrinfo(namebuf, cp, &hint, &list) || !list) { endStream(); connectError(); return; } first = list; #ifdef TCP_MAXSEG if(mss) setsockopt(so, IPPROTO_TCP, TCP_MAXSEG, (char *)&mss, sizeof(mss)); #endif while(list) { if(!::connect(so, list->ai_addr, (socklen_t)list->ai_addrlen)) { connected = true; break; } next = list->ai_next; list = next; } freeaddrinfo(first); if(!connected) { endStream(); connectError(); return; } segmentBuffering(mss); Socket::state = CONNECTED; }
/** * Start teleporter to the specified target. * * @returns COM status code. * * @param aHostname The name of the target host. * @param aPort The TCP port number. * @param aPassword The password. * @param aMaxDowntime Max allowed "downtime" in milliseconds. * @param aProgress Where to return the progress object. */ STDMETHODIMP Console::Teleport(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress) { /* * Validate parameters, check+hold object status, write lock the object * and validate the state. */ CheckComArgOutPointerValid(aProgress); CheckComArgStrNotEmptyOrNull(aHostname); CheckComArgStrNotEmptyOrNull(aPassword); CheckComArgExprMsg(aPort, aPort > 0 && aPort <= 65535, ("is %u", aPort)); CheckComArgExprMsg(aMaxDowntime, aMaxDowntime > 0, ("is %u", aMaxDowntime)); Utf8Str strPassword(aPassword); if (!strPassword.isEmpty()) { if (VBoxIsPasswordHashed(&strPassword)) return setError(E_INVALIDARG, tr("The specified password resembles a hashed password, expected plain text")); VBoxHashPassword(&strPassword); } AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS); LogFlowThisFunc(("mMachineState=%d\n", mMachineState)); switch (mMachineState) { case MachineState_Running: case MachineState_Paused: break; default: return setError(VBOX_E_INVALID_VM_STATE, tr("Invalid machine state: %s (must be Running or Paused)"), Global::stringifyMachineState(mMachineState)); } /* * Create a progress object, spawn a worker thread and change the state. * Note! The thread won't start working until we release the lock. */ LogFlowThisFunc(("Initiating TELEPORT request...\n")); ComObjPtr<Progress> ptrProgress; HRESULT hrc = ptrProgress.createObject(); if (SUCCEEDED(hrc)) hrc = ptrProgress->init(static_cast<IConsole *>(this), Bstr(tr("Teleporter")).raw(), TRUE /*aCancelable*/); if (FAILED(hrc)) return hrc; TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpUVM, ptrProgress, mMachineState); pState->mstrPassword = strPassword; pState->mstrHostname = aHostname; pState->muPort = aPort; pState->mcMsMaxDowntime = aMaxDowntime; void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState)); ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser); int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/, RTTHREADTYPE_EMULATION, 0 /*fFlags*/, "Teleport"); if (RT_SUCCESS(vrc)) { if (mMachineState == MachineState_Running) hrc = setMachineState(MachineState_Teleporting); else hrc = setMachineState(MachineState_TeleportingPausedVM); if (SUCCEEDED(hrc)) { ptrProgress.queryInterfaceTo(aProgress); mptrCancelableProgress = ptrProgress; } else ptrProgress->Cancel(); } else { ptrProgress->setCancelCallback(NULL, NULL); delete pState; hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc); } return hrc; }
/** * Do the teleporter. * * @returns VBox status code. * @param pState The teleporter state. */ HRESULT Console::teleporterSrc(TeleporterStateSrc *pState) { AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); /* * Wait for Console::Teleport to change the state. */ { AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS); } BOOL fCanceled = TRUE; HRESULT hrc = pState->mptrProgress->COMGETTER(Canceled)(&fCanceled); if (FAILED(hrc)) return hrc; if (fCanceled) return setError(E_FAIL, tr("canceled")); /* * Try connect to the destination machine, disable Nagle. * (Note. The caller cleans up mhSocket, so we can return without worries.) */ int vrc = RTTcpClientConnect(pState->mstrHostname.c_str(), pState->muPort, &pState->mhSocket); if (RT_FAILURE(vrc)) return setError(E_FAIL, tr("Failed to connect to port %u on '%s': %Rrc"), pState->muPort, pState->mstrHostname.c_str(), vrc); vrc = RTTcpSetSendCoalescing(pState->mhSocket, false /*fEnable*/); AssertRC(vrc); /* Read and check the welcome message. */ char szLine[RT_MAX(128, sizeof(g_szWelcome))]; RT_ZERO(szLine); vrc = RTTcpRead(pState->mhSocket, szLine, sizeof(g_szWelcome) - 1, NULL); if (RT_FAILURE(vrc)) return setError(E_FAIL, tr("Failed to read welcome message: %Rrc"), vrc); if (strcmp(szLine, g_szWelcome)) return setError(E_FAIL, tr("Unexpected welcome %.*Rhxs"), sizeof(g_szWelcome) - 1, szLine); /* password */ pState->mstrPassword.append('\n'); vrc = RTTcpWrite(pState->mhSocket, pState->mstrPassword.c_str(), pState->mstrPassword.length()); if (RT_FAILURE(vrc)) return setError(E_FAIL, tr("Failed to send password: %Rrc"), vrc); /* ACK */ hrc = teleporterSrcReadACK(pState, "password", tr("Invalid password")); if (FAILED(hrc)) return hrc; /* * Start loading the state. * * Note! The saved state includes vital configuration data which will be * verified against the VM config on the other end. This is all done * in the first pass, so we should fail pretty promptly on misconfig. */ hrc = teleporterSrcSubmitCommand(pState, "load"); if (FAILED(hrc)) return hrc; RTSocketRetain(pState->mhSocket); void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState)); vrc = VMR3Teleport(VMR3GetVM(pState->mpUVM), pState->mcMsMaxDowntime, &g_teleporterTcpOps, pvUser, teleporterProgressCallback, pvUser, &pState->mfSuspendedByUs); RTSocketRelease(pState->mhSocket); if (RT_FAILURE(vrc)) { if ( vrc == VERR_SSM_CANCELLED && RT_SUCCESS(RTTcpSelectOne(pState->mhSocket, 1))) { hrc = teleporterSrcReadACK(pState, "load-complete"); if (FAILED(hrc)) return hrc; } return setError(E_FAIL, tr("VMR3Teleport -> %Rrc"), vrc); } hrc = teleporterSrcReadACK(pState, "load-complete"); if (FAILED(hrc)) return hrc; /* * We're at the point of no return. */ if (!pState->mptrProgress->notifyPointOfNoReturn()) { teleporterSrcSubmitCommand(pState, "cancel", false /*fWaitForAck*/); return E_FAIL; } /* * Hand over any media which we might be sharing. * * Note! This is only important on localhost teleportations. */ /** @todo Maybe we should only do this if it's a local teleportation... */ hrc = mControl->UnlockMedia(); if (FAILED(hrc)) return hrc; pState->mfUnlockedMedia = true; hrc = teleporterSrcSubmitCommand(pState, "lock-media"); if (FAILED(hrc)) return hrc; /* * The FINAL step is giving the target instructions how to proceed with the VM. */ if ( vrc == VINF_SSM_LIVE_SUSPENDED || pState->menmOldMachineState == MachineState_Paused) hrc = teleporterSrcSubmitCommand(pState, "hand-over-paused"); else hrc = teleporterSrcSubmitCommand(pState, "hand-over-resume"); if (FAILED(hrc)) return hrc; /* * teleporterSrcThreadWrapper will do the automatic power off because it * has to release the AutoVMCaller. */ return S_OK; }
/** * Creates a TCP server that listens for the source machine and passes control * over to Console::teleporterTrgServeConnection(). * * @returns VBox status code. * @param pUVM The user-mode VM handle * @param pMachine The IMachine for the virtual machine. * @param pErrorMsg Pointer to the error string for VMSetError. * @param fStartPaused Whether to start it in the Paused (true) or * Running (false) state, * @param pProgress Pointer to the progress object. * @param pfPowerOffOnFailure Whether the caller should power off * the VM on failure. * * @remarks The caller expects error information to be set on failure. * @todo Check that all the possible failure paths sets error info... */ HRESULT Console::teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused, Progress *pProgress, bool *pfPowerOffOnFailure) { LogThisFunc(("pUVM=%p pMachine=%p fStartPaused=%RTbool pProgress=%p\n", pUVM, pMachine, fStartPaused, pProgress)); *pfPowerOffOnFailure = true; /* * Get the config. */ ULONG uPort; HRESULT hrc = pMachine->COMGETTER(TeleporterPort)(&uPort); if (FAILED(hrc)) return hrc; ULONG const uPortOrg = uPort; Bstr bstrAddress; hrc = pMachine->COMGETTER(TeleporterAddress)(bstrAddress.asOutParam()); if (FAILED(hrc)) return hrc; Utf8Str strAddress(bstrAddress); const char *pszAddress = strAddress.isEmpty() ? NULL : strAddress.c_str(); Bstr bstrPassword; hrc = pMachine->COMGETTER(TeleporterPassword)(bstrPassword.asOutParam()); if (FAILED(hrc)) return hrc; Utf8Str strPassword(bstrPassword); strPassword.append('\n'); /* To simplify password checking. */ /* * Create the TCP server. */ int vrc; PRTTCPSERVER hServer; if (uPort) vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer); else { for (int cTries = 10240; cTries > 0; cTries--) { uPort = RTRandU32Ex(cTries >= 8192 ? 49152 : 1024, 65534); vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer); if (vrc != VERR_NET_ADDRESS_IN_USE) break; } if (RT_SUCCESS(vrc)) { hrc = pMachine->COMSETTER(TeleporterPort)(uPort); if (FAILED(hrc)) { RTTcpServerDestroy(hServer); return hrc; } } } if (RT_FAILURE(vrc)) return setError(E_FAIL, tr("RTTcpServerCreateEx failed with status %Rrc"), vrc); /* * Create a one-shot timer for timing out after 5 mins. */ RTTIMERLR hTimerLR; vrc = RTTimerLRCreateEx(&hTimerLR, 0 /*ns*/, RTTIMER_FLAGS_CPU_ANY, teleporterDstTimeout, hServer); if (RT_SUCCESS(vrc)) { vrc = RTTimerLRStart(hTimerLR, 5*60*UINT64_C(1000000000) /*ns*/); if (RT_SUCCESS(vrc)) { /* * Do the job, when it returns we're done. */ TeleporterStateTrg theState(this, pUVM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused); theState.mstrPassword = strPassword; theState.mhServer = hServer; void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState)); if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser)) { LogRel(("Teleporter: Waiting for incoming VM...\n")); hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")).raw(), 1); if (SUCCEEDED(hrc)) { vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState); pProgress->setCancelCallback(NULL, NULL); if (vrc == VERR_TCP_SERVER_STOP) { vrc = theState.mRc; /* Power off the VM on failure unless the state callback already did that. */ *pfPowerOffOnFailure = false; if (RT_SUCCESS(vrc)) hrc = S_OK; else { VMSTATE enmVMState = VMR3GetStateU(pUVM); if ( enmVMState != VMSTATE_OFF && enmVMState != VMSTATE_POWERING_OFF) *pfPowerOffOnFailure = true; /* Set error. */ if (pErrorMsg->length()) hrc = setError(E_FAIL, "%s", pErrorMsg->c_str()); else hrc = setError(E_FAIL, tr("Teleporation failed (%Rrc)"), vrc); } } else if (vrc == VERR_TCP_SERVER_SHUTDOWN) { BOOL fCanceled = TRUE; hrc = pProgress->COMGETTER(Canceled)(&fCanceled); if (FAILED(hrc) || fCanceled) hrc = setError(E_FAIL, tr("Teleporting canceled")); else hrc = setError(E_FAIL, tr("Teleporter timed out waiting for incoming connection")); LogRel(("Teleporter: RTTcpServerListen aborted - %Rrc\n", vrc)); } else { hrc = setError(E_FAIL, tr("Unexpected RTTcpServerListen status code %Rrc"), vrc); LogRel(("Teleporter: Unexpected RTTcpServerListen rc: %Rrc\n", vrc)); } } else LogThisFunc(("SetNextOperation failed, %Rhrc\n", hrc)); } else { LogThisFunc(("Canceled - check point #1\n")); hrc = setError(E_FAIL, tr("Teleporting canceled")); } } else hrc = setError(E_FAIL, "RTTimerLRStart -> %Rrc", vrc); RTTimerLRDestroy(hTimerLR); } else hrc = setError(E_FAIL, "RTTimerLRCreate -> %Rrc", vrc); RTTcpServerDestroy(hServer); /* * If we change TeleporterPort above, set it back to it's original * value before returning. */ if (uPortOrg != uPort) { ErrorInfoKeeper Eik; pMachine->COMSETTER(TeleporterPort)(uPortOrg); } return hrc; }
/// \brief Call the first/next iteration of parsing the header /// \return true on success, false if more data is needed (putInput(const char*,std::size_t)) or if an error occurred. Check lasterror() for an error bool parse() { unsigned char ch = nextChar(); for (;ch != 0; ch = nextChar()) { switch (m_state) { case Init: if (ch == '<') { m_state = ParseXmlOpen; } else if (ch <= 32) { continue; } else { setError( "expected open tag angle bracket '>'"); return false; } break; case ParseXmlOpen: if (ch == '?') { m_state = ParseXmlHdr; } else if (ch <= 32) { break; } else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_') { return true; } else { setError( "expected xml header question mark '?' after open tag angle bracket '<'"); return false; } break; case ParseXmlHdr: if (ch <= 32 || ch == '?') { if (m_item != "xml") { setError( "expected '<?xml' as xml header start"); return false; } m_item.clear(); if (ch == '?') return true; /*...."<?xml?>"*/ m_state = FindAttributeName; } else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_') { m_item.push_back(ch); continue; } else if (ch == '>') { setError( "unexpected close angle bracket '>' in xml header after '<?xml'"); return false; } else { setError( "expected '<?xml' as xml header start (invalid character)"); return false; } break; case FindAttributeName: if (ch <= 32) { continue; } else if (ch == '>' || ch == '?') { if (ch == '>') { setError( "unexpected close angle bracket '>' in xml header (missing '?')"); return false; } return true; } else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_') { m_item.push_back(ch); m_state = ParseAttributeName; } else { setError( "invalid character in xml header attribute name"); return false; } break; case ParseAttributeName: if (ch <= 32 || ch == '=') { if (m_item == "encoding") { m_attributetype = Encoding; } else if (m_item == "version") { m_attributetype = Version; } else if (m_item == "standalone") { m_attributetype = Standalone; } else { setError( "unknown xml header attribute name"); return false; } m_item.clear(); if (ch == '=') { m_state = FindAttributeValue; continue; } m_state = FindAttributeAssign; } else if (((ch|32) >= 'a' && (ch|32) <= 'z') || ch == '_') { m_item.push_back(ch); continue; } else { setError( "invalid character in xml header attribute name"); return false; } break; case FindAttributeAssign: if (ch == '=') { m_state = FindAttributeValue; } else if (ch <= 32) { continue; } else { setError( "expected '=' after xml header attribute name"); return false; } break; case FindAttributeValue: if (ch == '"') { m_state = ParseAttributeValueDq; continue; } else if (ch == '\'') { m_state = ParseAttributeValueSq; continue; } else if (ch <= 32) { continue; } else { setError( "expected single or double quote string as xml header attribute value"); return false; } break; case ParseAttributeValueSq: if (ch == '\'') { switch (m_attributetype) { case Encoding: m_encoding = m_item; break; case Version: case Standalone: break; } m_item.clear(); m_state = FindAttributeName; continue; } else { m_item.push_back( ch); } break; case ParseAttributeValueDq: if (ch == '\"') { switch (m_attributetype) { case Encoding: m_encoding = m_item; break; case Version: case Standalone: break; } m_item.clear(); m_state = FindAttributeName; continue; } else { m_item.push_back( ch); } break; }/*switch(..)*/ }/*for(;..;..)*/ return false; }
bool QNativeSocketEnginePrivate::fetchConnectionParameters() { localPort = 0; localAddress.clear(); peerPort = 0; peerAddress.clear(); if (socketDescriptor == -1) return false; qt_sockaddr sa; QT_SOCKLEN_T sockAddrSize = sizeof(sa); // Determine local address memset(&sa, 0, sizeof(sa)); if (::getsockname(socketDescriptor, &sa.a, &sockAddrSize) == 0) { qt_socket_getPortAndAddress(&sa, &localPort, &localAddress); // Determine protocol family switch (sa.a.sa_family) { case AF_INET: socketProtocol = QAbstractSocket::IPv4Protocol; break; case AF_INET6: socketProtocol = QAbstractSocket::IPv6Protocol; break; default: socketProtocol = QAbstractSocket::UnknownNetworkLayerProtocol; break; } } else if (errno == EBADF) { setError(QAbstractSocket::UnsupportedSocketOperationError, InvalidSocketErrorString); return false; } // Determine the remote address if (!::getpeername(socketDescriptor, &sa.a, &sockAddrSize)) qt_socket_getPortAndAddress(&sa, &peerPort, &peerAddress); // Determine the socket type (UDP/TCP) int value = 0; QT_SOCKOPTLEN_T valueSize = sizeof(int); if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_TYPE, &value, &valueSize) == 0) { if (value == SOCK_STREAM) socketType = QAbstractSocket::TcpSocket; else if (value == SOCK_DGRAM) socketType = QAbstractSocket::UdpSocket; else socketType = QAbstractSocket::UnknownSocketType; } #if defined (QNATIVESOCKETENGINE_DEBUG) QString socketProtocolStr = "UnknownProtocol"; if (socketProtocol == QAbstractSocket::IPv4Protocol) socketProtocolStr = "IPv4Protocol"; else if (socketProtocol == QAbstractSocket::IPv6Protocol) socketProtocolStr = "IPv6Protocol"; QString socketTypeStr = "UnknownSocketType"; if (socketType == QAbstractSocket::TcpSocket) socketTypeStr = "TcpSocket"; else if (socketType == QAbstractSocket::UdpSocket) socketTypeStr = "UdpSocket"; qDebug("QNativeSocketEnginePrivate::fetchConnectionParameters() local == %s:%i," " peer == %s:%i, socket == %s - %s", localAddress.toString().toLatin1().constData(), localPort, peerAddress.toString().toLatin1().constData(), peerPort,socketTypeStr.toLatin1().constData(), socketProtocolStr.toLatin1().constData()); #endif return true; }
void JsonRpcResponse::setError(const Error& error) { setError(error, json::Value()); }
/* * Sends the given SyncML message to the server specified * by the instal property 'url'. Returns the response status code or -1 * if it was not possible initialize the connection. * * Use getResponse() to get the server response. */ char* CurlTransportAgent::sendMessage(const char* msg) { if (!easyhandle) { setError(ERR_NETWORK_INIT, "libcurl error init error"); LOG.error("%s", getLastErrorMsg()); return NULL; } size_t size = strlen(msg); LOG.debug("Requesting resource %s at %s:%d", url.resource, url.host, url.port); POSIX_LOG.setPrefix("data out: "); LOG.debug("=== %d bytes ===\n%s", (int)size, msg); POSIX_LOG.setPrefix(NULL); curl_slist *slist=NULL; char *response = NULL; CURLcode code; char contenttype[256]; sprintf(contenttype, "Content-Type: %s", SYNCML_CONTENT_TYPE); slist = curl_slist_append(slist, contenttype); responsebuffersize = 64 * 1024; responsebuffer = new char[responsebuffersize]; received = 0; responsebuffer[0] = 0; // todo? url.resource const char *certificates = getSSLServerCertificates(); if ((code = curl_easy_setopt(easyhandle, CURLOPT_POST, true)) || (code = curl_easy_setopt(easyhandle, CURLOPT_URL, url.fullURL)) || (code = curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDS, msg)) || (code = curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDSIZE, size)) || (code = curl_easy_setopt(easyhandle, CURLOPT_HTTPHEADER, slist)) || /* * slightly cheating here: when CURLOPT_CAINFO was set before, we don't unset it because * we don't know what the default is */ (certificates[0] && (code = curl_easy_setopt(easyhandle, CURLOPT_CAINFO, certificates))) || (code = curl_easy_setopt(easyhandle, CURLOPT_SSL_VERIFYPEER, (long)SSLVerifyServer)) || (code = curl_easy_setopt(easyhandle, CURLOPT_SSL_VERIFYHOST, (long)(SSLVerifyHost ? 2 : 0))) || (code = curl_easy_perform(easyhandle))) { delete [] responsebuffer; setErrorF(ERR_HTTP, "libcurl error %d, %.250s", code, curlerrortxt); LOG.error("%s", getLastErrorMsg()); } else { response = responsebuffer; POSIX_LOG.setPrefix("data in: "); LOG.debug("=== %d bytes ===\n%s", (int)strlen(response), response); } POSIX_LOG.setPrefix(NULL); responsebuffer = NULL; responsebuffersize = 0; if (slist) { curl_slist_free_all(slist); } return response; }
HRESULT StorageController::setControllerType(StorageControllerType_T aControllerType) { /* the machine needs to be mutable */ AutoMutableStateDependency adep(m->pParent); if (FAILED(adep.rc())) return adep.rc(); AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); HRESULT rc = S_OK; switch (m->bd->storageBus) { case StorageBus_IDE: { if ( (aControllerType != StorageControllerType_PIIX3) && (aControllerType != StorageControllerType_PIIX4) && (aControllerType != StorageControllerType_ICH6)) rc = E_INVALIDARG; break; } case StorageBus_SATA: { if (aControllerType != StorageControllerType_IntelAhci) rc = E_INVALIDARG; break; } case StorageBus_SCSI: { if ( (aControllerType != StorageControllerType_LsiLogic) && (aControllerType != StorageControllerType_BusLogic)) rc = E_INVALIDARG; break; } case StorageBus_Floppy: { if (aControllerType != StorageControllerType_I82078) rc = E_INVALIDARG; break; } case StorageBus_SAS: { if (aControllerType != StorageControllerType_LsiLogicSas) rc = E_INVALIDARG; break; } case StorageBus_USB: { if (aControllerType != StorageControllerType_USB) rc = E_INVALIDARG; break; } case StorageBus_PCIe: { if (aControllerType != StorageControllerType_NVMe) rc = E_INVALIDARG; break; } default: AssertMsgFailed(("Invalid controller type %d\n", m->bd->storageBus)); rc = E_INVALIDARG; } if (!SUCCEEDED(rc)) return setError(rc, tr("Invalid controller type %d"), aControllerType); if (m->bd->controllerType != aControllerType) { m->bd.backup(); m->bd->controllerType = aControllerType; alock.release(); AutoWriteLock mlock(m->pParent COMMA_LOCKVAL_SRC_POS); // m->pParent is const, needs no locking m->pParent->i_setModified(Machine::IsModified_Storage); mlock.release(); m->pParent->i_onStorageControllerChange(m->pParent->i_getId(), m->bd->strName); } return S_OK; }
bool QNativeSocketEnginePrivate::fetchConnectionParameters() { localPort = 0; localAddress.clear(); peerPort = 0; peerAddress.clear(); inboundStreamCount = outboundStreamCount = 0; if (socketDescriptor == -1) return false; qt_sockaddr sa; QT_SOCKLEN_T sockAddrSize = sizeof(sa); // Determine local address memset(&sa, 0, sizeof(sa)); if (::getsockname(socketDescriptor, &sa.a, &sockAddrSize) == 0) { qt_socket_getPortAndAddress(&sa, &localPort, &localAddress); // Determine protocol family switch (sa.a.sa_family) { case AF_INET: socketProtocol = QAbstractSocket::IPv4Protocol; break; case AF_INET6: socketProtocol = QAbstractSocket::IPv6Protocol; break; default: socketProtocol = QAbstractSocket::UnknownNetworkLayerProtocol; break; } } else if (errno == EBADF) { setError(QAbstractSocket::UnsupportedSocketOperationError, InvalidSocketErrorString); return false; } #if defined (IPV6_V6ONLY) // determine if local address is dual mode // On linux, these are returned as "::" (==AnyIPv6) // On OSX, these are returned as "::FFFF:0.0.0.0" (==AnyIPv4) // in either case, the IPV6_V6ONLY option is cleared int ipv6only = 0; socklen_t optlen = sizeof(ipv6only); if (socketProtocol == QAbstractSocket::IPv6Protocol && (localAddress == QHostAddress::AnyIPv4 || localAddress == QHostAddress::AnyIPv6) && !getsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&ipv6only, &optlen )) { if (optlen != sizeof(ipv6only)) qWarning("unexpected size of IPV6_V6ONLY socket option"); if (!ipv6only) { socketProtocol = QAbstractSocket::AnyIPProtocol; localAddress = QHostAddress::Any; } } #endif // Determine the remote address if (!::getpeername(socketDescriptor, &sa.a, &sockAddrSize)) { qt_socket_getPortAndAddress(&sa, &peerPort, &peerAddress); inboundStreamCount = outboundStreamCount = 1; } // Determine the socket type (UDP/TCP) int value = 0; QT_SOCKOPTLEN_T valueSize = sizeof(int); if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_TYPE, &value, &valueSize) == 0) { if (value == SOCK_STREAM) socketType = QAbstractSocket::TcpSocket; else if (value == SOCK_DGRAM) socketType = QAbstractSocket::UdpSocket; else socketType = QAbstractSocket::UnknownSocketType; } #if defined (QNATIVESOCKETENGINE_DEBUG) QString socketProtocolStr = QStringLiteral("UnknownProtocol"); if (socketProtocol == QAbstractSocket::IPv4Protocol) socketProtocolStr = QStringLiteral("IPv4Protocol"); else if (socketProtocol == QAbstractSocket::IPv6Protocol || socketProtocol == QAbstractSocket::AnyIPProtocol) socketProtocolStr = QStringLiteral("IPv6Protocol"); QString socketTypeStr = QStringLiteral("UnknownSocketType"); if (socketType == QAbstractSocket::TcpSocket) socketTypeStr = QStringLiteral("TcpSocket"); else if (socketType == QAbstractSocket::UdpSocket) socketTypeStr = QStringLiteral("UdpSocket"); qDebug("QNativeSocketEnginePrivate::fetchConnectionParameters() local == %s:%i," " peer == %s:%i, socket == %s - %s, inboundStreamCount == %i, outboundStreamCount == %i", localAddress.toString().toLatin1().constData(), localPort, peerAddress.toString().toLatin1().constData(), peerPort,socketTypeStr.toLatin1().constData(), socketProtocolStr.toLatin1().constData(), inboundStreamCount, outboundStreamCount); #endif return true; }
/** * Initializes the storage controller object. * * @returns COM result indicator. * @param aParent Pointer to our parent object. * @param aName Name of the storage controller. * @param aStorageBus Type of the storage bus. * @param aInstance Instance number of the storage controller. * @param fBootable Bootable flag. */ HRESULT StorageController::init(Machine *aParent, const Utf8Str &aName, StorageBus_T aStorageBus, ULONG aInstance, bool fBootable) { LogFlowThisFunc(("aParent=%p aName=\"%s\" aInstance=%u\n", aParent, aName.c_str(), aInstance)); ComAssertRet(aParent && !aName.isEmpty(), E_INVALIDARG); if ( (aStorageBus <= StorageBus_Null) || (aStorageBus > StorageBus_PCIe)) return setError(E_INVALIDARG, tr("Invalid storage connection type")); ULONG maxInstances; ChipsetType_T chipsetType; HRESULT rc = aParent->COMGETTER(ChipsetType)(&chipsetType); if (FAILED(rc)) return rc; rc = aParent->i_getVirtualBox()->i_getSystemProperties()-> GetMaxInstancesOfStorageBus(chipsetType, aStorageBus, &maxInstances); if (FAILED(rc)) return rc; if (aInstance >= maxInstances) return setError(E_INVALIDARG, tr("Too many storage controllers of this type")); /* Enclose the state transition NotReady->InInit->Ready */ AutoInitSpan autoInitSpan(this); AssertReturn(autoInitSpan.isOk(), E_FAIL); m = new Data(aParent); /* m->pPeer is left null */ m->bd.allocate(); m->bd->strName = aName; m->bd->ulInstance = aInstance; m->bd->fBootable = fBootable; m->bd->storageBus = aStorageBus; if ( aStorageBus != StorageBus_IDE && aStorageBus != StorageBus_Floppy) m->bd->fUseHostIOCache = false; else m->bd->fUseHostIOCache = true; switch (aStorageBus) { case StorageBus_IDE: m->bd->ulPortCount = 2; m->bd->controllerType = StorageControllerType_PIIX4; break; case StorageBus_SATA: m->bd->ulPortCount = 30; m->bd->controllerType = StorageControllerType_IntelAhci; break; case StorageBus_SCSI: m->bd->ulPortCount = 16; m->bd->controllerType = StorageControllerType_LsiLogic; break; case StorageBus_Floppy: m->bd->ulPortCount = 1; m->bd->controllerType = StorageControllerType_I82078; break; case StorageBus_SAS: m->bd->ulPortCount = 8; m->bd->controllerType = StorageControllerType_LsiLogicSas; break; case StorageBus_USB: m->bd->ulPortCount = 8; m->bd->controllerType = StorageControllerType_USB; break; case StorageBus_PCIe: m->bd->ulPortCount = 1; m->bd->controllerType = StorageControllerType_NVMe; break; case StorageBus_Null: break; /* Shut up MSC. */ #ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK case StorageBus_32BitHack: break; /* Shut up GCC. */ #endif } /* Confirm a successful initialization */ autoInitSpan.setSucceeded(); return S_OK; }
bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &addr, quint16 port) { #ifdef QNATIVESOCKETENGINE_DEBUG qDebug() << "QNativeSocketEnginePrivate::nativeConnect() " << socketDescriptor; #endif qt_sockaddr aa; QT_SOCKLEN_T sockAddrSize; setPortAndAddress(port, addr, &aa, &sockAddrSize); int connectResult = qt_safe_connect(socketDescriptor, &aa.a, sockAddrSize); #if defined (QNATIVESOCKETENGINE_DEBUG) int ecopy = errno; #endif if (connectResult == -1) { switch (errno) { case EISCONN: socketState = QAbstractSocket::ConnectedState; break; case ECONNREFUSED: case EINVAL: setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString); socketState = QAbstractSocket::UnconnectedState; break; case ETIMEDOUT: setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString); break; case EHOSTUNREACH: setError(QAbstractSocket::NetworkError, HostUnreachableErrorString); socketState = QAbstractSocket::UnconnectedState; break; case ENETUNREACH: setError(QAbstractSocket::NetworkError, NetworkUnreachableErrorString); socketState = QAbstractSocket::UnconnectedState; break; case EADDRINUSE: setError(QAbstractSocket::NetworkError, AddressInuseErrorString); break; case EINPROGRESS: case EALREADY: setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString); socketState = QAbstractSocket::ConnectingState; break; case EAGAIN: setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString); break; case EACCES: case EPERM: setError(QAbstractSocket::SocketAccessError, AccessErrorString); socketState = QAbstractSocket::UnconnectedState; break; case EAFNOSUPPORT: case EBADF: case EFAULT: case ENOTSOCK: socketState = QAbstractSocket::UnconnectedState; default: break; } if (socketState != QAbstractSocket::ConnectedState) { #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == false (%s)", addr.toString().toLatin1().constData(), port, socketState == QAbstractSocket::ConnectingState ? "Connection in progress" : strerror(ecopy)); #endif return false; } } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == true", addr.toString().toLatin1().constData(), port); #endif socketState = QAbstractSocket::ConnectedState; return true; }
HRESULT VFSExplorer::i_updateFS(TaskVFSExplorer *aTask) { LogFlowFuncEnter(); AutoCaller autoCaller(this); if (FAILED(autoCaller.rc())) return autoCaller.rc(); AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS); HRESULT rc = S_OK; std::list<VFSExplorer::Data::DirEntry> fileList; char *pszPath = NULL; PRTDIR pDir = NULL; try { int vrc = RTDirOpen(&pDir, m->strPath.c_str()); if (RT_FAILURE(vrc)) throw setError(VBOX_E_FILE_ERROR, tr ("Can't open directory '%s' (%Rrc)"), pszPath, vrc); if (aTask->progress) aTask->progress->SetCurrentOperationProgress(33); RTDIRENTRYEX entry; while (RT_SUCCESS(vrc)) { vrc = RTDirReadEx(pDir, &entry, NULL, RTFSOBJATTRADD_NOTHING, RTPATH_F_ON_LINK); if (RT_SUCCESS(vrc)) { Utf8Str name(entry.szName); if ( name != "." && name != "..") fileList.push_back(VFSExplorer::Data::DirEntry(name, i_RTToVFSFileType(entry.Info.Attr.fMode), entry.Info.cbObject, entry.Info.Attr.fMode & (RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXG | RTFS_UNIX_IRWXO))); } } if (aTask->progress) aTask->progress->SetCurrentOperationProgress(66); } catch(HRESULT aRC) { rc = aRC; } /* Clean up */ if (pszPath) RTStrFree(pszPath); if (pDir) RTDirClose(pDir); if (aTask->progress) aTask->progress->SetCurrentOperationProgress(99); /* Assign the result on success (this clears the old list) */ if (rc == S_OK) m->entryList.assign(fileList.begin(), fileList.end()); aTask->rc = rc; if (!aTask->progress.isNull()) aTask->progress->i_notifyComplete(rc); LogFlowFunc(("rc=%Rhrc\n", rc)); LogFlowFuncLeave(); return VINF_SUCCESS; }
bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port) { qt_sockaddr aa; QT_SOCKLEN_T sockAddrSize; setPortAndAddress(port, address, &aa, &sockAddrSize); #ifdef IPV6_V6ONLY if (aa.a.sa_family == AF_INET6) { int ipv6only = 0; if (address.protocol() == QAbstractSocket::IPv6Protocol) ipv6only = 1; //default value of this socket option varies depending on unix variant (or system configuration on BSD), so always set it explicitly ::setsockopt(socketDescriptor, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&ipv6only, sizeof(ipv6only) ); } #endif int bindResult = QT_SOCKET_BIND(socketDescriptor, &aa.a, sockAddrSize); if (bindResult < 0 && errno == EAFNOSUPPORT && address.protocol() == QAbstractSocket::AnyIPProtocol) { // retry with v4 aa.a4.sin_family = AF_INET; aa.a4.sin_port = htons(port); aa.a4.sin_addr.s_addr = htonl(address.toIPv4Address()); sockAddrSize = sizeof(aa.a4); bindResult = QT_SOCKET_BIND(socketDescriptor, &aa.a, sockAddrSize); } if (bindResult < 0) { #if defined (QNATIVESOCKETENGINE_DEBUG) int ecopy = errno; #endif switch(errno) { case EADDRINUSE: setError(QAbstractSocket::AddressInUseError, AddressInuseErrorString); break; case EACCES: setError(QAbstractSocket::SocketAccessError, AddressProtectedErrorString); break; case EINVAL: setError(QAbstractSocket::UnsupportedSocketOperationError, OperationUnsupportedErrorString); break; case EADDRNOTAVAIL: setError(QAbstractSocket::SocketAddressNotAvailableError, AddressNotAvailableErrorString); break; default: break; } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == false (%s)", address.toString().toLatin1().constData(), port, strerror(ecopy)); #endif return false; } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == true", address.toString().toLatin1().constData(), port); #endif socketState = QAbstractSocket::BoundState; return true; }
/// \brief Set output filter state with error message /// \param [in] s new state /// \param [in] msg (optional) error to set void setState( State s, const char* msg=0) {m_state=s; setError(msg);}
qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxSize, QIpPacketHeader *header, QAbstractSocketEngine::PacketHeaderOptions options) { // we use quintptr to force the alignment quintptr cbuf[(CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) #if !defined(IP_PKTINFO) && defined(IP_RECVIF) && defined(Q_OS_BSD4) + CMSG_SPACE(sizeof(sockaddr_dl)) #endif + sizeof(quintptr) - 1) / sizeof(quintptr)]; struct msghdr msg; struct iovec vec; qt_sockaddr aa; char c; memset(&msg, 0, sizeof(msg)); memset(&aa, 0, sizeof(aa)); // we need to receive at least one byte, even if our user isn't interested in it vec.iov_base = maxSize ? data : &c; vec.iov_len = maxSize ? maxSize : 1; msg.msg_iov = &vec; msg.msg_iovlen = 1; if (options & QAbstractSocketEngine::WantDatagramSender) { msg.msg_name = &aa; msg.msg_namelen = sizeof(aa); } if (options & (QAbstractSocketEngine::WantDatagramHopLimit | QAbstractSocketEngine::WantDatagramDestination)) { msg.msg_control = cbuf; msg.msg_controllen = sizeof(cbuf); } ssize_t recvResult = 0; do { recvResult = ::recvmsg(socketDescriptor, &msg, 0); } while (recvResult == -1 && errno == EINTR); if (recvResult == -1) { setError(QAbstractSocket::NetworkError, ReceiveDatagramErrorString); if (header) header->clear(); } else if (options != QAbstractSocketEngine::WantNone) { Q_ASSERT(header); qt_socket_getPortAndAddress(&aa, &header->senderPort, &header->senderAddress); header->destinationPort = localPort; // parse the ancillary data struct cmsghdr *cmsgptr; for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) { if (cmsgptr->cmsg_level == IPPROTO_IPV6 && cmsgptr->cmsg_type == IPV6_PKTINFO && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in6_pktinfo))) { in6_pktinfo *info = reinterpret_cast<in6_pktinfo *>(CMSG_DATA(cmsgptr)); header->destinationAddress.setAddress(reinterpret_cast<quint8 *>(&info->ipi6_addr)); header->ifindex = info->ipi6_ifindex; if (header->ifindex) header->destinationAddress.setScopeId(QString::number(info->ipi6_ifindex)); } #ifdef IP_PKTINFO if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_PKTINFO && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in_pktinfo))) { in_pktinfo *info = reinterpret_cast<in_pktinfo *>(CMSG_DATA(cmsgptr)); header->destinationAddress.setAddress(ntohl(info->ipi_addr.s_addr)); header->ifindex = info->ipi_ifindex; } #else # ifdef IP_RECVDSTADDR if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_RECVDSTADDR && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(in_addr))) { in_addr *addr = reinterpret_cast<in_addr *>(CMSG_DATA(cmsgptr)); header->destinationAddress.setAddress(ntohl(addr->s_addr)); } # endif # if defined(IP_RECVIF) && defined(Q_OS_BSD4) if (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_RECVIF && cmsgptr->cmsg_len >= CMSG_LEN(sizeof(sockaddr_dl))) { sockaddr_dl *sdl = reinterpret_cast<sockaddr_dl *>(CMSG_DATA(cmsgptr)); header->ifindex = LLINDEX(sdl); } # endif #endif if (cmsgptr->cmsg_len == CMSG_LEN(sizeof(int)) && ((cmsgptr->cmsg_level == IPPROTO_IPV6 && cmsgptr->cmsg_type == IPV6_HOPLIMIT) || (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_TTL))) { header->hopLimit = *reinterpret_cast<int *>(CMSG_DATA(cmsgptr)); } } } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEnginePrivate::nativeReceiveDatagram(%p \"%s\", %lli, %s, %i) == %lli", data, qt_prettyDebug(data, qMin(recvResult, ssize_t(16)), recvResult).data(), maxSize, (recvResult != -1 && options != QAbstractSocketEngine::WantNone) ? header->senderAddress.toString().toLatin1().constData() : "(unknown)", (recvResult != -1 && options != QAbstractSocketEngine::WantNone) ? header->senderPort : 0, (qint64) recvResult); #endif return qint64(maxSize ? recvResult : recvResult == -1 ? -1 : 0); }
bool Connection::connect(const char *_host, int _port, const char *_username, const char *_password, const char *_database, int *_autoCommit, MYSQL_CHARSETS _charset) { m_dbgMethodProgress ++; if (m_dbgMethodProgress > 1) { /* NOTE: We don't call setError here because it will close the socket worsening the concurrent access error making it impossible to trace */ m_errorMessage = "Concurrent access in connect method"; m_errno = 0; m_errorType = UME_OTHER; m_dbgMethodProgress --; return false; } if (m_sockInst != NULL) { m_dbgMethodProgress --; setError ("Socket already connected", 0, UME_OTHER); return false; } m_host = _host ? _host : "localhost"; m_port = _port ? _port : 3306; m_username = _username ? _username : ""; m_password = _password ? _password : ""; m_database = _database ? _database : ""; m_autoCommit = _autoCommit ? (*_autoCommit) != 0 : false; m_charset = _charset; PRINTMARK(); m_sockInst = m_capi.getSocket(); if (m_sockInst == NULL) { m_dbgMethodProgress --; return false; } if (m_timeout != -1) { if (!setTimeout (m_timeout)) { m_dbgMethodProgress --; return false; } } if (!connectSocket()) { m_dbgMethodProgress --; return false; } PRINTMARK(); if (!recvPacket()) { m_dbgMethodProgress --; return false; } PRINTMARK(); if (!processHandshake()) { m_dbgMethodProgress --; return false; } PRINTMARK(); if (!sendPacket()) { m_dbgMethodProgress --; return false; } PRINTMARK(); m_writer.reset(); if (!recvPacket()) { m_dbgMethodProgress --; return false; } PRINTMARK(); UINT8 result = m_reader.readByte(); if (result == 0xff) { handleErrorPacket(); m_dbgMethodProgress --; return false; } if (result == 0xfe) { setError ("Old Authentication Method switch from server. Not supported by this client.", 4, UME_OTHER); m_dbgMethodProgress --; return false; } m_reader.skip(); PRINTMARK(); if (_autoCommit) { PRINTMARK(); char strTemp[256 + 1]; PRINTMARK(); size_t len = snprintf (strTemp, 256, "SET AUTOCOMMIT = %d", *_autoCommit); PRINTMARK(); m_writer.reset(); m_writer.writeByte(MC_QUERY); m_writer.writeBytes ( (void *) strTemp, len); m_writer.finalize(0); PRINTMARK(); if (!sendPacket()) { m_dbgMethodProgress --; return false; } PRINTMARK(); if (!recvPacket()) { m_dbgMethodProgress --; return false; } m_reader.skip(); } PRINTMARK(); m_state = QUERY_WAIT; m_dbgMethodProgress --; return true; }
qint64 QNativeSocketEnginePrivate::nativeSendDatagram(const char *data, qint64 len, const QIpPacketHeader &header) { // we use quintptr to force the alignment quintptr cbuf[(CMSG_SPACE(sizeof(struct in6_pktinfo)) + CMSG_SPACE(sizeof(int)) + sizeof(quintptr) - 1) / sizeof(quintptr)]; struct cmsghdr *cmsgptr = reinterpret_cast<struct cmsghdr *>(cbuf); struct msghdr msg; struct iovec vec; qt_sockaddr aa; memset(&msg, 0, sizeof(msg)); memset(&aa, 0, sizeof(aa)); vec.iov_base = const_cast<char *>(data); vec.iov_len = len; msg.msg_iov = &vec; msg.msg_iovlen = 1; msg.msg_name = &aa.a; msg.msg_control = &cbuf; setPortAndAddress(header.destinationPort, header.destinationAddress, &aa, &msg.msg_namelen); if (msg.msg_namelen == sizeof(aa.a6)) { if (header.hopLimit != -1) { msg.msg_controllen += CMSG_SPACE(sizeof(int)); cmsgptr->cmsg_len = CMSG_LEN(sizeof(int)); cmsgptr->cmsg_level = IPPROTO_IPV6; cmsgptr->cmsg_type = IPV6_HOPLIMIT; memcpy(CMSG_DATA(cmsgptr), &header.hopLimit, sizeof(int)); cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(int))); } if (header.ifindex != 0 || !header.senderAddress.isNull()) { struct in6_pktinfo *data = reinterpret_cast<in6_pktinfo *>(CMSG_DATA(cmsgptr)); memset(data, 0, sizeof(*data)); msg.msg_controllen += CMSG_SPACE(sizeof(*data)); cmsgptr->cmsg_len = CMSG_LEN(sizeof(*data)); cmsgptr->cmsg_level = IPPROTO_IPV6; cmsgptr->cmsg_type = IPV6_PKTINFO; data->ipi6_ifindex = header.ifindex; QIPv6Address tmp = header.senderAddress.toIPv6Address(); memcpy(&data->ipi6_addr, &tmp, sizeof(tmp)); cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(*data))); } } else { if (header.hopLimit != -1) { msg.msg_controllen += CMSG_SPACE(sizeof(int)); cmsgptr->cmsg_len = CMSG_LEN(sizeof(int)); cmsgptr->cmsg_level = IPPROTO_IP; cmsgptr->cmsg_type = IP_TTL; memcpy(CMSG_DATA(cmsgptr), &header.hopLimit, sizeof(int)); cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(int))); } #if defined(IP_PKTINFO) || defined(IP_SENDSRCADDR) if (header.ifindex != 0 || !header.senderAddress.isNull()) { # ifdef IP_PKTINFO struct in_pktinfo *data = reinterpret_cast<in_pktinfo *>(CMSG_DATA(cmsgptr)); memset(data, 0, sizeof(*data)); cmsgptr->cmsg_type = IP_PKTINFO; data->ipi_ifindex = header.ifindex; data->ipi_addr.s_addr = htonl(header.senderAddress.toIPv4Address()); # elif defined(IP_SENDSRCADDR) struct in_addr *data = reinterpret_cast<in_addr *>(CMSG_DATA(cmsgptr)); cmsgptr->cmsg_type = IP_SENDSRCADDR; data->s_addr = htonl(header.senderAddress.toIPv4Address()); # endif cmsgptr->cmsg_level = IPPROTO_IP; msg.msg_controllen += CMSG_SPACE(sizeof(*data)); cmsgptr->cmsg_len = CMSG_LEN(sizeof(*data)); cmsgptr = reinterpret_cast<cmsghdr *>(reinterpret_cast<char *>(cmsgptr) + CMSG_SPACE(sizeof(*data))); } #endif } if (msg.msg_controllen == 0) msg.msg_control = 0; ssize_t sentBytes = qt_safe_sendmsg(socketDescriptor, &msg, 0); if (sentBytes < 0) { switch (errno) { case EMSGSIZE: setError(QAbstractSocket::DatagramTooLargeError, DatagramTooLargeErrorString); break; default: setError(QAbstractSocket::NetworkError, SendDatagramErrorString); } } #if defined (QNATIVESOCKETENGINE_DEBUG) qDebug("QNativeSocketEngine::sendDatagram(%p \"%s\", %lli, \"%s\", %i) == %lli", data, qt_prettyDebug(data, qMin<int>(len, 16), len).data(), len, header.destinationAddress.toString().toLatin1().constData(), header.destinationPort, (qint64) sentBytes); #endif return qint64(sentBytes); }
QList<Task*> Kalign_Load_Align_Compare_Task::onSubTaskFinished(Task* subTask) { Q_UNUSED(subTask); QList<Task*> res; if (hasError() || isCanceled()) { return res; } if (subTask == loadTask1) { Document *doc = loadTask1->getDocument(); if(loadTask1->hasError()) { return res; } assert(doc!=NULL); QList<GObject*> list = doc->findGObjectByType(GObjectTypes::SEQUENCE); if (list.size() == 0) { stateInfo.setError( QString("container of object with type \"%1\" is empty").arg(GObjectTypes::SEQUENCE) ); return res; } MAlignment malign = dna_to_ma(list); if(hasError()) { return res; } ma1 = MAlignmentImporter::createAlignment(doc->getDbiRef(), malign, stateInfo); CHECK_OP(stateInfo, res); if(ma1 == NULL){ stateInfo.setError( QString("can't convert dna sequences to MAlignment") ); return res; } res << kalignTask; this->connect(kalignTask,SIGNAL(si_progressChanged()),SLOT(sl_kalignProgressChg())); } else if (subTask == kalignTask) { if(kalignTask->hasError()) { setError( kalignTask->getError() ); return res; } KalignTask * localKalign = qobject_cast<KalignTask*>( subTask ); assert( NULL != localKalign ); ma1->copyGapModel(localKalign->resultMA.getRows()); } else if (subTask == loadTask2) { if (loadTask2->hasError()) { return res; } Document *doc = loadTask2->getDocument(); if(loadTask2->hasError()) { return res; } assert(doc!=NULL); QList<GObject*> list = doc->findGObjectByType(GObjectTypes::SEQUENCE); if (list.size() == 0) { stateInfo.setError( QString("container of object with type \"%1\" is empty").arg(GObjectTypes::SEQUENCE) ); return res; } MAlignment malign = dna_to_ma(list); if(hasError()) { return res; } ma2 = MAlignmentImporter::createAlignment(doc->getDbiRef(), malign, stateInfo); CHECK_OP(stateInfo, res); if(ma2 == NULL){ stateInfo.setError( QString("can't convert dna sequences to MAlignment") ); return res; } } return res; }
void ReadShortReadsSubTask::run() { stateInfo.setProgress(0); GTIMER(cvar, tvar, "ReadSubTask"); GenomeAlignerTask *parent = static_cast<GenomeAlignerTask*>(getParentTask()); if (!alignContext.bestMode) { parent->pWriteTask->flush(); } alignContext.cleanVectors(); dataBunch = new DataBunch(); if (isCanceled()) { readingFinishedWakeAll(); return; } qint64 m = freeMemorySize; taskLog.details(QString("Memory size is %1").arg(m)); bool alignReversed = settings.getCustomValue(GenomeAlignerTask::OPTION_ALIGN_REVERSED, true).toBool(); int qualityThreshold = settings.getCustomValue(GenomeAlignerTask::OPTION_QUAL_THRESHOLD, 0).toInt(); DNATranslation* transl = AppContext::getDNATranslationRegistry()-> lookupTranslation(BaseDNATranslationIds::NUCL_DNA_DEFAULT_COMPLEMENT); alignContext.isReadingStarted = true; bunchSize = 0; int readNum = 0; while(!seqReader->isEnd()) { if (isCanceled()) { readingFinishedWakeAll(); return; } SearchQuery *query = seqReader->read(); if (NULL == query) { if (!seqReader->isEnd()) { setError("Short-reads object type must be a sequence, but not a multiple alignment"); readingFinishedWakeAll(); return; } break; } ++bunchSize; if (!checkDnaQuality(query, qualityThreshold)) { continue; } updateMinMaxReadLengths(alignContext, query->length()); int W = 0, q = 0; int CMAX = alignContext.nMismatches; if (!add(CMAX, W, q, readNum, query, parent)) { delete query; continue; } m -= query->memoryHint(); if (alignReversed) { SearchQuery *rQu = createRevComplQuery(query, transl); if (rQu) { add(CMAX, W, q, readNum, rQu, parent); m -= rQu->memoryHint(); } } qint64 alignContextMemoryHint = dataBunch->memoryHint(); if (m <= alignContextMemoryHint + prevMemoryHint) { break; } SAFE_POINT(NULL != dataBunch, "No dataBunch",); if (dataBunch->bitValuesV.size() > DROP_BUNCH_DATA_SIZE) { dropToAlignContext(); readNum = 0; alignContext.readShortReadsWait.wakeOne(); } } dropToAlignContext(); readingFinishedWakeAll(); }