int main(int argc, char **argv ) { int status; longword host; if (argc > 2) { puts("Quote of the Day (Cookie) - retrieves a witty message"); puts("Usage: COOKIE [server]"); exit( 3 ); } sock_init(); if ( argc == 1) { status = cookie ((longword) NULL); } else { if ( (host = resolve( argv[1])) != 0uL ) { status = cookie( host ); } else { printf("Could not resolve host '%s'\n", argv[1]); status = 3; } } exit( status ); return (0); /* not reached */ }
void VcsCommand::run(QFutureInterface<void> &future) { // Check that the binary path is not empty if (binaryPath().isEmpty()) { emit errorText(tr("Unable to start process, binary is empty")); return; } QString stdOut; QString stdErr; if (d->m_progressParser) d->m_progressParser->setFuture(&future); else future.setProgressRange(0, 1); const int count = d->m_jobs.size(); d->m_lastExecExitCode = -1; d->m_lastExecSuccess = true; for (int j = 0; j < count; j++) { const Internal::VcsCommandPrivate::Job &job = d->m_jobs.at(j); const int timeOutSeconds = job.timeout; Utils::SynchronousProcessResponse resp = runVcs( job.arguments, timeOutSeconds >= 0 ? timeOutSeconds * 1000 : -1, job.exitCodeInterpreter); stdOut += resp.stdOut; stdErr += resp.stdErr; d->m_lastExecExitCode = resp.exitCode; d->m_lastExecSuccess = resp.result == Utils::SynchronousProcessResponse::Finished; if (!d->m_lastExecSuccess) break; } if (!d->m_aborted) { if (!d->m_progressiveOutput) { emit output(stdOut); if (!stdErr.isEmpty()) emit errorText(stdErr); } emit finished(d->m_lastExecSuccess, d->m_lastExecExitCode, cookie()); if (d->m_lastExecSuccess) emit success(cookie()); future.setProgressValue(future.progressMaximum()); } if (d->m_progressParser) d->m_progressParser->setFuture(0); // As it is used asynchronously, we need to delete ourselves this->deleteLater(); }
AbstractSession& BaseSessionStore::getSession(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response) { // Get the cookies from the client. Poco::Net::NameValueCollection cookies; // Get the cookies request.getCookies(cookies); // Try to find a cookie with our session key name. Poco::Net::NameValueCollection::ConstIterator cookieIter = cookies.begin(); std::string sessionId; while (cookieIter != cookies.end()) { if (0 == cookieIter->first.compare(_sessionKeyName)) { if (sessionId.empty()) { sessionId = cookieIter->second; } else { Poco::Net::HTTPCookie cookie(_sessionKeyName); cookie.setMaxAge(0); // Invalidate the cookie. response.addCookie(cookie); } } ++cookieIter; } if (hasSession(sessionId)) { return getSession(sessionId); } else { // Create a new sesssion and return a reference. AbstractSession& session = createSession(); // Create a cookie with the session id. Poco::Net::HTTPCookie cookie(_sessionKeyName, session.getId()); // Send our cookie with the response. response.addCookie(cookie); return session; } }
//_______________________________________________________ bool ShadowHelper::checkSupported( void ) const { // create atom #if MENDA_HAVE_X11 // make sure we are on X11 if( !Helper::isX11() ) return false; // create atom xcb_atom_t netSupportedAtom( _helper.createAtom( "_NET_SUPPORTED" ) ); if( !netSupportedAtom ) return false; // store connection locally xcb_connection_t* connection( Helper::connection() ); // get property const quint32 maxLength = std::string().max_size(); xcb_get_property_cookie_t cookie( xcb_get_property( connection, 0, QX11Info::appRootWindow(), netSupportedAtom, XCB_ATOM_ATOM, 0, (maxLength+3) / 4 ) ); ScopedPointer<xcb_get_property_reply_t> reply( xcb_get_property_reply( connection, cookie, nullptr ) ); if( !reply ) return false; // get reply length and data const int count( xcb_get_property_value_length( reply.data() )/sizeof( xcb_atom_t ) ); xcb_atom_t *atoms = reinterpret_cast<xcb_atom_t*>( xcb_get_property_value( reply.data() ) ); bool found( false ); for( int i = 0; i < count && !found; ++i ) { // get atom name and print xcb_atom_t atom( atoms[i] ); xcb_get_atom_name_cookie_t cookie( xcb_get_atom_name( connection, atom ) ); ScopedPointer<xcb_get_atom_name_reply_t> reply( xcb_get_atom_name_reply( connection, cookie, 0 ) ); if( !reply ) continue; // get name and compare const QString name( QByteArray( xcb_get_atom_name_name( reply.data() ), xcb_get_atom_name_name_length( reply.data() ) ) ); if( strcmp( netWMShadowAtomName, xcb_get_atom_name_name( reply.data() ) ) == 0 ) found = true; } return found; #else return false; #endif }
int move_g(GUSANO *g) { POINT *p, *q; int item; if(!g->growth) { p = extract_l(g->cuerpo); item = tablero[p->x/GORDO][p->y/GORDO]; tablero[p->x/GORDO][p->y/GORDO] = 0; } else p = (POINT *)malloc(sizeof(POINT)); q = tail_l(g->cuerpo); p->x = q->x; p->y = q->y; switch(g->dir) { case 0: /* N */ p->y = q->y-GORDO; break; case 1: /* E */ p->x = q->x+GORDO; break; case 2: /* S */ p->y = q->y+GORDO; break; case 3: /* W */ p->x = q->x-GORDO; break; } if(p->x >= MAXX || p->x < 0 || p->y >= MAXY || p->y < 0 || (tablero[p->x/GORDO][p->y/GORDO] != 0 && (galleta.x != p->x || galleta.y != p->y))) { if(!g->growth) delete_w(item); free(p); return 0; } add_l(g->cuerpo, p); if(g->growth) { g->growth--; item = create_obj_w(p->x, p->y, GORDO, "oval", "red"); } else coords_w(item, p->x, p->y, GORDO); /* A comerse la galleta */ if(galleta.x == p->x && galleta.y == p->y) { g->growth += tablero[p->x/GORDO][p->y/GORDO]; tablero[p->x/GORDO][p->y/GORDO] = 0; cookie(MAXX, MAXY); } tablero[p->x/GORDO][p->y/GORDO] = item; return 1; }
int main(int argc, char** argv) { avhttp::cookies cookie; cookie("sf_mirror_attempt=avplayer:optimate|softlayer-ams:/avplayer/exe/release-2013-03-13.7z; expires=Tue, 3-Dec-2013 14:52:55 GMT; Path=/"); BOOST_ASSERT(cookie["sf_mirror_attempt"] == std::string("avplayer:optimate|softlayer-ams:/avplayer/exe/release-2013-03-13.7z")); return 0; }
void BaseSessionStore::destroySession(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response) { // Get the cookies from the client. Poco::Net::NameValueCollection cookies; // Get the cookies request.getCookies(cookies); // Try to find a cookie with our session key name. Poco::Net::NameValueCollection::ConstIterator cookieIter = cookies.begin(); while (cookieIter != cookies.end()) { if (0 == cookieIter->first.compare(_sessionKeyName)) { // Destroy the session data. destroySession(cookieIter->second); // Invalidate the cookies. Poco::Net::HTTPCookie cookie(_sessionKeyName, cookieIter->second); cookie.setMaxAge(0); response.addCookie(cookie); } ++cookieIter; } }
//_____________________________________________________________ WindowManager::WindowManager( QObject* parent ): QObject( parent ), _enabled( true ), _useWMMoveResize( true ), _dragMode( StyleConfigData::WD_FULL ), _dragDistance( QApplication::startDragDistance() ), _dragDelay( QApplication::startDragTime() ), _dragAboutToStart( false ), _dragInProgress( false ), _locked( false ), _cursorOverride( false ), _isX11( false ) { // install application wise event filter _appEventFilter = new AppEventFilter( this ); qApp->installEventFilter( _appEventFilter ); #if HAVE_X11 _isX11 = QGuiApplication::platformName() == QStringLiteral("xcb"); _moveResizeAtom = 0; if( _isX11 ) { // create move-resize atom xcb_connection_t* connection( QX11Info::connection() ); const QString atomName( QStringLiteral( "_NET_WM_MOVERESIZE" ) ); xcb_intern_atom_cookie_t cookie( xcb_intern_atom( connection, false, atomName.size(), qPrintable( atomName ) ) ); Helper::ScopedPointer<xcb_intern_atom_reply_t> reply( xcb_intern_atom_reply( connection, cookie, nullptr) ); _moveResizeAtom = reply ? reply->atom:0; } #endif }
void LocalCookieStore::doGetCookies() { Cookies cookies; m_db.setDatabaseName(m_dbPath); if (Q_UNLIKELY(!m_db.open())) { qCritical() << "Could not open cookie database:" << m_dbPath << m_db.lastError(); return; } QSqlQuery q(m_db); q.exec("SELECT host_key, name, value, path, expires_utc, secure, httponly, has_expires FROM cookies;"); while (q.next()) { /* Build the cookie string from its parts */ QNetworkCookie cookie(q.value(1).toString().toUtf8(), q.value(2).toString().toUtf8()); cookie.setSecure(q.value(5).toBool()); cookie.setHttpOnly(q.value(6).toBool()); if (q.value(7).toBool()) { QDateTime expires = dateTimeFromChrome(q.value(4).toULongLong()); cookie.setExpirationDate(expires); } cookie.setDomain(q.value(0).toString()); cookie.setPath(q.value(3).toString()); cookies.append(cookie); } m_db.close(); emit gotCookies(cookies); }
void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value) { SoupCookieJar* jar = cookieJarForSession(session); if (!jar) return; GUniquePtr<SoupURI> origin = url.createSoupURI(); GUniquePtr<SoupURI> firstPartyURI = firstParty.createSoupURI(); // Get existing cookies for this origin. GSList* existingCookies = soup_cookie_jar_get_cookie_list(jar, origin.get(), TRUE); Vector<String> cookies; value.split('\n', cookies); const size_t cookiesCount = cookies.size(); for (size_t i = 0; i < cookiesCount; ++i) { GUniquePtr<SoupCookie> cookie(soup_cookie_parse(cookies[i].utf8().data(), origin.get())); if (!cookie) continue; // Make sure the cookie is not httpOnly since such cookies should not be set from JavaScript. if (soup_cookie_get_http_only(cookie.get())) continue; // Make sure we do not overwrite httpOnly cookies from JavaScript. if (httpOnlyCookieExists(existingCookies, soup_cookie_get_name(cookie.get()), soup_cookie_get_path(cookie.get()))) continue; soup_cookie_jar_add_cookie_with_first_party(jar, firstPartyURI.get(), cookie.release()); } soup_cookies_free(existingCookies); }
//_________________________________________________________ WId DetectDialog::findWindow() { #if BREEZE_HAVE_X11 if (!QX11Info::isPlatformX11()) { return 0; } // check atom if( !m_wmStateAtom ) return 0; xcb_connection_t* connection( QX11Info::connection() ); xcb_window_t parent( QX11Info::appRootWindow() ); // why is there a loop of only 10 here for( int i = 0; i < 10; ++i ) { // query pointer xcb_query_pointer_cookie_t pointerCookie( xcb_query_pointer( connection, parent ) ); QScopedPointer<xcb_query_pointer_reply_t, QScopedPointerPodDeleter> pointerReply( xcb_query_pointer_reply( connection, pointerCookie, nullptr ) ); if( !( pointerReply && pointerReply->child ) ) return 0; const xcb_window_t child( pointerReply->child ); xcb_get_property_cookie_t cookie( xcb_get_property( connection, 0, child, m_wmStateAtom, XCB_GET_PROPERTY_TYPE_ANY, 0, 0 ) ); QScopedPointer<xcb_get_property_reply_t, QScopedPointerPodDeleter> reply( xcb_get_property_reply( connection, cookie, nullptr ) ); if( reply && reply->type ) return child; else parent = child; } #endif return 0; }
void AbstractRequestHandler::sessionStart() { if (app_->sessionStart(this)) { QNetworkCookie cookie(C_SID.toUtf8(), session_->id.toUtf8()); cookie.setPath("/"); header(HEADER_SET_COOKIE, cookie.toRawForm()); } }
void add_cookie(struct pt_regs *regs, int cpu) { unsigned long pc; off_t off; if (regs == 0) return; pc = profile_pc(regs); if (user_mode(regs)) { struct mm_struct *mm; struct vm_area_struct *vma; struct path *ppath; mm = current->mm; for (vma = find_vma(mm, s.pc); vma; vma = vma->vm_next) { if (s.pc < vma->vm_start || s.pc >= vma->vm_end) continue; if (vma->vm_file) { ppath = &(vma->vm_file->f_path); off = (vma->vm_pgoff << PAGE_SHIFT) + s.pc - vma->vm_start; cookie(current->comm, pc, (char *)(ppath->dentry->d_name.name), off, 0); } else { /* must be an anonymous map */ cookie(current->comm, pc, "nofile", pc, 0); } break; } } else { struct module *mod = __module_address(s.pc); if (mod) { s.off = s.pc - (unsigned long)mod->module_core; cookie(current->comm, pc, mod->name, off, 1); } else { s.off = 0; cookie(current->comm, pc, "vmlinux", off, 0); } } }
void open(const GUID &p_owner, bool p_decode, t_size p_param1, const void *p_param2, t_size p_param2size, abort_callback &p_abort) { auto setup = static_cast<const matroska_setup *>(p_param2); std::vector<char> cookie(4); /* 4 bytes room for version and flags */ auto p = static_cast<const char*>(setup->codec_private); std::copy(p, p + 24, std::back_inserter(cookie)); packet_decoder::g_open(m_decoder, p_decode, owner_MP4_ALAC, 0, cookie.data(), cookie.size(), p_abort); }
void AccessManager::setRawCookie(const QByteArray &rawCookie, const QUrl &url) { QNetworkCookie cookie(rawCookie.left(rawCookie.indexOf('=')), rawCookie.mid(rawCookie.indexOf('=')+1)); qDebug() << Q_FUNC_INFO << cookie.name() << cookie.value(); QList<QNetworkCookie> cookieList; cookieList.append(cookie); QNetworkCookieJar *jar = cookieJar(); jar->setCookiesFromUrl(cookieList, url); }
/*! \~english Adds the cookie to the internal list of cookies. \~japanese クッキーをHTTPレスポンスに追加する */ bool TActionController::addCookie(const QByteArray &name, const QByteArray &value, const QDateTime &expire, const QString &path, const QString &domain, bool secure, bool httpOnly) { TCookie cookie(name, value); cookie.setExpirationDate(expire); cookie.setPath(path); cookie.setDomain(domain); cookie.setSecure(secure); cookie.setHttpOnly(httpOnly); return addCookie(cookie); }
const prop_info *__system_property_find_nth(unsigned n) { find_nth_cookie cookie(n); const int err = __system_property_foreach(find_nth_fn, &cookie); if (err < 0) { return NULL; } return cookie.pi; }
void getHostnamesWithCookies(NetworkingContext* context, HashSet<String>& hostnames) { SoupCookieJar* cookieJar = context ? cookieJarForContext(context) : soupCookieJar(); GOwnPtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar)); for (GSList* item = cookies.get(); item; item = g_slist_next(item)) { GOwnPtr<SoupCookie> cookie(static_cast<SoupCookie*>(item->data)); if (!cookie->domain) continue; hostnames.add(String::fromUTF8(cookie->domain)); } }
int commit(Request& req, Response& resp, int program_status , boost::system::error_code& ec) { typedef typename Request::string_type string_type; #ifdef BOOST_CGI_ENABLE_SESSIONS if (!program_status) { string_type path( Request::traits::session_options == path_session ? req.script_name() : "/" ); if (req.session.id().empty()) resp<< cookie(BOOST_CGI_SESSION_COOKIE_NAME, "", path, BOOST_CGI_DATE_IN_THE_PAST); else resp<< cookie(BOOST_CGI_SESSION_COOKIE_NAME, req.session.id(), path); } #endif // BOOST_CGI_ENABLE_SESSIONS resp.send(req.client(), ec); return ec ? -1 : req.close(resp.status(), program_status, ec); }
void WebSessionManager::addCookie(const std::string& appName, const Poco::Net::HTTPServerRequest& request, WebSession::Ptr pSession) { Poco::Net::HTTPCookie cookie(cookieName(appName), pSession->id()); if (_cookiePersistence == COOKIE_PERSISTENT) { cookie.setMaxAge(pSession->timeout()); } cookie.setPath(cookiePath(appName)); cookie.setDomain(cookieDomain(appName)); cookie.setHttpOnly(); request.response().addCookie(cookie); }
void StaticObject::setTree(int i){ m_type = ObjectType::TREE; m_name = "CookieTree"; Item cookie(1); cookie.setName("Cookie"); cookie.setTypeId(ItemType::COOKIE); Item branch(2); branch.setName("Branch"); branch.setTypeId(ItemType::BRANCH); m_inventory->addItem(&cookie, 25); m_inventory->addItem(&branch, i); }
XnStatus XnSensorStreamHelper::MapFirmwareProperty(XnActualIntProperty& Property, XnActualIntProperty& FirmwareProperty, XnBool bAllowChangeWhileOpen, XnSensorStreamHelper::ConvertCallback pStreamToFirmwareFunc /* = 0 */) { XnStatus nRetVal = XN_STATUS_OK; // init data XnSensorStreamHelperCookie cookie(&Property, &FirmwareProperty, bAllowChangeWhileOpen, pStreamToFirmwareFunc); // add it to the list nRetVal = m_FirmwareProperties.Set(&Property, cookie); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
void CookieTest::DomainMatchingTest() { const BUrl setter("http://testsuites.opera.com/cookies/304.php"); const BUrl getter("http://testsuites.opera.com/cookies/304-1.php"); BString bigData("304-12=1; Domain=\""); for (int i = 0; i < 1500; i++) bigData << "abcdefghijklmnopqrstuvwxyz"; bigData << "\";"; struct Test { const char* cookieString; bool shouldMatch; }; const Test tests[] = { { "304-01=1; Domain=\"opera.com\"", true }, { "304-02=1; Domain=\".opera.com\"", true }, { "304-03=1; Domain=\".com\"", false }, { "304-04=1; Domain=\"pera.com\"", false }, { "304-05=1; Domain=\"?pera.com\"", false }, { "304-06=1; Domain=\"*.opera.com\"", false }, { "304-07=1; Domain=\"300.300.300.300\"", false }, { "304-08=1; Domain=\"123456123456123456\"", false }, { "304-09=1; Domain=\"/opera.com\"", false }, { "304-10=1; Domain=\"opera.com/\"", false }, { "304-11=1; Domain=\"example.com\"", false }, { bigData, false }, { "304-13=1; Domain=\"opera com\"", false }, { "304-14=1; Domain=opera.com\"", false }, { "304-15=1; Domain=\"opera.com", false }, { "304-16=1; Domain=opera.com", true }, { "304-17=1; Domain=\"*.com\"", false }, { "304-18=1; Domain=\"*opera.com\"", false }, { "304-19=1; Domain=\"*pera.com\"", false }, { "304-20=1; Domain=\"\"", false }, { "304-21=1; Domain=\"\346\227\245\346\234\254\"", false }, { "304-22=1; Domain=\"OPERA.COM\"", true }, { "304-23=1; Domain=\"195.189.143.182\"", false }, }; for (unsigned int i = 0; i < sizeof(tests) / sizeof(Test); i++) { NextSubTest(); BNetworkCookie cookie(tests[i].cookieString, setter); CPPUNIT_ASSERT_EQUAL(tests[i].shouldMatch, cookie.IsValidForUrl(getter)); } }
//------------------------------------------------------------------------------ bool ofxWebServerBaseRouteHandler::isValidRequest(const Settings& settings, HTTPServerRequest& request, HTTPServerResponse& response) { string sessionId = ""; // extract cookie from request NameValueCollection cookies; request.getCookies(cookies); NameValueCollection::ConstIterator it = cookies.find(settings.sessionCookieName); if (it != cookies.end()) { sessionId = it->second; } else { sessionId = ofxWebServerSessionManager::generateSessionKey(request); HTTPCookie cookie(settings.sessionCookieName,sessionId); cookie.setPath("/"); // set no age, so it expires @ end of session response.addCookie(cookie); } // TODO: update session manager URI uri(request.getURI()); const string path = uri.getPath(); // just get the path if(settings.requireAuthentication) { if(request.hasCredentials()) { HTTPBasicCredentials credentials(request); const string& user = credentials.getUsername(); const string& pwd = credentials.getPassword(); if(settings.username == credentials.getUsername() && settings.password == credentials.getPassword()) { // add an authentication cookie? return true; } else { response.setStatusAndReason(HTTPResponse::HTTP_UNAUTHORIZED); sendErrorResponse(response); return false; } } else { response.requireAuthentication(settings.realm); response.setContentLength(0); response.send(); return false; } } else { return true; } }
void makeacthash(stralloc *act) /* act is expected to be -reject-ddddd.ttttt or -accept-ddddd.ttttt and * has to be 0-terminated. */ /* The routine will add .hash@outhost to act. act will NOT be 0-terminated */ { int d; d = 2 + str_chr(act->s + 1,'-'); cookie(hash,key.s,key.len,act->s + d,"","a"); *(act->s + act->len - 1) = '.'; /* we put a '.' Bad, but works */ if (!stralloc_catb(act,hash,COOKIE)) die_nomem(); if (!stralloc_cats(act,"@")) die_nomem(); if (!stralloc_cat(act,&outhost)) die_nomem(); }
main() { GUSANO *g; int i,j; int dir = 1; /* 0: N, 1: E, 2: S, 3: W */ char s[200]; srandom(time(NULL)); for(i=0; i<MAXX/GORDO; i++) for(j=0; j<MAXY/GORDO; j++) tablero[i][j] = 0; init_w(MAXX, MAXY); g = init_g(MAXX/2, MAXY/2, dir, 4); /* x,y,dir,largo */ if(!galleta_id) cookie(MAXX, MAXY); for(;;) { usleep(100000); switch(getchar()) { case 'h': /* back */ dir = 3; break; case 'j': /* down */ dir = 2; break; case 'k': /* up */ dir = 0; break; case 'l': /* forward */ dir = 1; break; case EOF: goto fin; break; default: continue; break; } g->dir = dir; if( !move_g(g) ) { fin: sprintf(s, "Boing!!, score = %d", size_l(g->cuerpo)); free_g(g); close_w(s, 100, 100); exit(0); } } }
void AbstractRequestHandler::sessionEnd() { if (sessionActive()) { QNetworkCookie cookie(C_SID.toUtf8(), session_->id.toUtf8()); cookie.setPath("/"); cookie.setExpirationDate(QDateTime::currentDateTime()); if (app_->sessionEnd(this)) { header(HEADER_SET_COOKIE, cookie.toRawForm()); } } }
bool AbstractWebApplication::sessionStart() { if (session_ == 0) { session_ = new WebSession(generateSid()); session_->updateTimestamp(); sessions_[session_->id] = session_; QNetworkCookie cookie(C_SID, session_->id.toUtf8()); cookie.setPath(QLatin1String("/")); header(Http::HEADER_SET_COOKIE, cookie.toRawForm()); return true; } return false; }
InfoExtractor::InfoExtractor(QObject *parent) : QObject(parent), m_queue(), m_url(), m_replyTimer(new QTimer(this)), m_accessManager(new QNetworkAccessManager(this)), m_reply(NULL) { //Définition du cookie pour avoir la page en anglais QNetworkCookieJar *jar = new QNetworkCookieJar(this); QNetworkCookie cookie("l", "en"); QList<QNetworkCookie> liste; liste << cookie; jar->setCookiesFromUrl(liste, MEGAUPLOAD); m_accessManager->setCookieJar(jar); m_replyTimer->setSingleShot(true); m_replyTimer->setInterval(INFO_EXTRACTION_TIMEOUT); connect(m_replyTimer, SIGNAL(timeout()), this, SLOT(replyTimeout())); }
void Site::initManager() { if (m_manager == NULL) { m_cookieJar = new QNetworkCookieJar(this); // Hotfix "giantessbooru.com" QNetworkCookie cookie("agreed", "true"); cookie.setPath("/"); cookie.setDomain("giantessbooru.com"); m_cookieJar->insertCookie(cookie); m_manager = new QNetworkAccessManager(this); m_manager->setCookieJar(m_cookieJar); connect(m_manager, SIGNAL(finished(QNetworkReply*)), this, SIGNAL(finished(QNetworkReply*))); connect(m_manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)), this, SLOT(sslErrorHandler(QNetworkReply*,QList<QSslError>))); }