Example #1
0
void Strategy::getMore(OperationContext* txn, Request& request) {
    Timer getMoreTimer;

    const char* ns = request.getns();
    const int ntoreturn = request.d().pullInt();
    const long long id = request.d().pullInt64();

    // TODO:  Handle stale config exceptions here from coll being dropped or sharded during op
    // for now has same semantics as legacy request
    const NamespaceString nss(ns);
    auto statusGetDb = grid.catalogCache()->getDatabase(txn, nss.db().toString());
    if (statusGetDb == ErrorCodes::DatabaseNotFound) {
        cursorCache.remove(id);
        replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0);
        return;
    }

    uassertStatusOK(statusGetDb);

    // Spigot which controls whether OP_QUERY style find on mongos uses the new ClusterClientCursor
    // code path.
    //
    // TODO: Delete the spigot and always use the new code.
    if (useClusterClientCursor) {
        boost::optional<long long> batchSize;
        if (ntoreturn) {
            batchSize = ntoreturn;
        }
        GetMoreRequest getMoreRequest(NamespaceString(ns), id, batchSize, boost::none);

        auto cursorResponse = ClusterFind::runGetMore(txn, getMoreRequest);
        if (cursorResponse == ErrorCodes::CursorNotFound) {
            replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0);
            return;
        }
        uassertStatusOK(cursorResponse.getStatus());

        // Build the response document.
        //
        // TODO: this constant should be shared between mongos and mongod, and should not be inside
        // ShardedClientCursor.
        BufBuilder buffer(ShardedClientCursor::INIT_REPLY_BUFFER_SIZE);

        int numResults = 0;
        for (const auto& obj : cursorResponse.getValue().batch) {
            buffer.appendBuf((void*)obj.objdata(), obj.objsize());
            ++numResults;
        }

        replyToQuery(0,
                     request.p(),
                     request.m(),
                     buffer.buf(),
                     buffer.len(),
                     numResults,
                     cursorResponse.getValue().numReturnedSoFar.value_or(0),
                     cursorResponse.getValue().cursorId);
        return;
    }

    shared_ptr<DBConfig> config = statusGetDb.getValue();

    ShardPtr primary;
    ChunkManagerPtr info;
    config->getChunkManagerOrPrimary(txn, ns, info, primary);

    //
    // TODO: Cleanup cursor cache, consolidate into single codepath
    //
    const string host = cursorCache.getRef(id);
    ShardedClientCursorPtr cursor = cursorCache.get(id);
    int cursorMaxTimeMS = cursorCache.getMaxTimeMS(id);

    // Cursor ids should not overlap between sharded and unsharded cursors
    massert(17012,
            str::stream() << "duplicate sharded and unsharded cursor id " << id << " detected for "
                          << ns << ", duplicated on host " << host,
            NULL == cursorCache.get(id).get() || host.empty());

    ClientBasic* client = ClientBasic::getCurrent();
    NamespaceString nsString(ns);
    AuthorizationSession* authSession = AuthorizationSession::get(client);
    Status status = authSession->checkAuthForGetMore(nsString, id, false);
    audit::logGetMoreAuthzCheck(client, nsString, id, status.code());
    uassertStatusOK(status);

    if (!host.empty()) {
        LOG(3) << "single getmore: " << ns;

        // we used ScopedDbConnection because we don't get about config versions
        // not deleting data is handled elsewhere
        // and we don't want to call setShardVersion
        ScopedDbConnection conn(host);

        Message response;
        bool ok = conn->callRead(request.m(), response);
        uassert(10204, "dbgrid: getmore: error calling db", ok);

        bool hasMore = (response.singleData().getCursor() != 0);

        if (!hasMore) {
            cursorCache.removeRef(id);
        }

        request.reply(response, "" /*conn->getServerAddress() */);
        conn.done();
        return;
    } else if (cursor) {
        if (cursorMaxTimeMS == kMaxTimeCursorTimeLimitExpired) {
            cursorCache.remove(id);
            uasserted(ErrorCodes::ExceededTimeLimit, "operation exceeded time limit");
        }

        // TODO: Try to match logic of mongod, where on subsequent getMore() we pull lots more data?
        BufBuilder buffer(ShardedClientCursor::INIT_REPLY_BUFFER_SIZE);
        int docCount = 0;
        const int startFrom = cursor->getTotalSent();
        bool hasMore = cursor->sendNextBatch(ntoreturn, buffer, docCount);

        if (hasMore) {
            // still more data
            cursor->accessed();

            if (cursorMaxTimeMS != kMaxTimeCursorNoTimeLimit) {
                // Update remaining amount of time in cursor cache.
                int cursorLeftoverMillis = cursorMaxTimeMS - getMoreTimer.millis();
                if (cursorLeftoverMillis <= 0) {
                    cursorLeftoverMillis = kMaxTimeCursorTimeLimitExpired;
                }
                cursorCache.updateMaxTimeMS(id, cursorLeftoverMillis);
            }
        } else {
            // we've exhausted the cursor
            cursorCache.remove(id);
        }

        replyToQuery(0,
                     request.p(),
                     request.m(),
                     buffer.buf(),
                     buffer.len(),
                     docCount,
                     startFrom,
                     hasMore ? cursor->getId() : 0);
        return;
    } else {
        LOG(3) << "could not find cursor " << id << " in cache for " << ns;

        replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0);
        return;
    }
}
Example #2
0
        void _update( Request& r , DbMessage& d, ChunkManagerPtr manager ){
            int flags = d.pullInt();
            
            BSONObj query = d.nextJsObj();
            uassert( 10201 ,  "invalid update" , d.moreJSObjs() );
            BSONObj toupdate = d.nextJsObj();

            BSONObj chunkFinder = query;
            
            bool upsert = flags & UpdateOption_Upsert;
            bool multi = flags & UpdateOption_Multi;

            uassert( 10202 ,  "can't mix multi and upsert and sharding" , ! ( upsert && multi ) );

            if ( upsert && !(manager->hasShardKey(toupdate) ||
                             (toupdate.firstElement().fieldName()[0] == '$' && manager->hasShardKey(query))))
            {
                throw UserException( 8012 , "can't upsert something without shard key" );
            }

            bool save = false;
            if ( ! manager->hasShardKey( query ) ){
                if ( multi ){
                }
                else if ( strcmp( query.firstElement().fieldName() , "_id" ) || query.nFields() != 1 ){
                    throw UserException( 8013 , "can't do non-multi update with query that doesn't have the shard key" );
                }
                else {
                    save = true;
                    chunkFinder = toupdate;
                }
            }

            
            if ( ! save ){
                if ( toupdate.firstElement().fieldName()[0] == '$' ){
                    BSONObjIterator ops(toupdate);
                    while(ops.more()){
                        BSONElement op(ops.next());
                        if (op.type() != Object)
                            continue;
                        BSONObjIterator fields(op.embeddedObject());
                        while(fields.more()){
                            const string field = fields.next().fieldName();
                            uassert(13123, "Can't modify shard key's value", ! manager->getShardKey().partOfShardKey(field));
                        }
                    }
                } else if ( manager->hasShardKey( toupdate ) ){
                    uassert( 8014, "change would move shards!", manager->getShardKey().compare( query , toupdate ) == 0 );
                } else {
                    uasserted(12376, "shard key must be in update object");
                }
            }
            
            if ( multi ){
                set<Shard> shards;
                manager->getShardsForQuery( shards , chunkFinder );
                int * x = (int*)(r.d().afterNS());
                x[0] |= UpdateOption_Broadcast;
                for ( set<Shard>::iterator i=shards.begin(); i!=shards.end(); i++){
                    doWrite( dbUpdate , r , *i , false );
                }
            }
            else {
                int left = 5;
                while ( true ){
                    try {
                        ChunkPtr c = manager->findChunk( chunkFinder );
                        doWrite( dbUpdate , r , c->getShard() );
                        c->splitIfShould( d.msg().header()->dataLen() );
                        break;
                    }
                    catch ( StaleConfigException& e ){
                        if ( left <= 0 )
                            throw e;
                        left--;
                        log() << "update failed b/c of StaleConfigException, retrying " 
                              << " left:" << left << " ns: " << r.getns() << " query: " << query << endl;
                        r.reset( false );
                        manager = r.getChunkManager();
                    }
                }
            }

        }
Example #3
0
int TcpClient::requestData(const int nSeq, const int nMsgId, const string& arg, NetworkProxy *pData)
{
	TopMessage msgrep;
	msgrep.set_protocol_version("1.0");
	msgrep.set_msg_type(REQUEST);
	msgrep.set_sub_msg_type(POST);
	msgrep.set_session_id(G.m_strSessionID);
	msgrep.set_seq(nSeq);
	msgrep.set_host(m_strIP);
	msgrep.set_user_name(G.m_strUserName);
	msgrep.set_version((float)NT_VERSION);
	
	Request req;
	req.set_domid(G.m_nDomID);
	req.set_msgid(nMsgId);
	req.set_arg(arg);

	int datalen = req.ByteSize();
	char *buf = new char[datalen];
	autoptr_arr<char> arrguard1(buf);
	if (!req.SerializeToArray(buf, datalen))
	{
		//closeAndReConn();
		return 1;
	}

	msgrep.set_data(buf, datalen);

	datalen = msgrep.ByteSize();
	int headlen = CodedOutputStream::VarintSize32(datalen);

	char *databuf = new char[datalen];
	autoptr_arr<char> arrguard(databuf);
	if (!msgrep.SerializeToArray(databuf, datalen))
	{
		//closeAndReConn();
		return 1;
	}

	//char *tmpArr = new char[datalen+headlen];
	//autoptr_arr<char> arrguard2(tmpArr);
	
	lock_guard<mutex> lg(m_writeMutex);
	if (m_writeData.expand(datalen+headlen))
	{
		ZeroCopyOutputStream* raw_output = new ArrayOutputStream(m_writeData.getBuf() + m_writeData.getPos(), datalen+headlen);
		CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
		coded_output->WriteVarint32(datalen);
		coded_output->WriteRaw(databuf, datalen);
		m_writeData.setPos(m_writeData.getPos() + (datalen+headlen));

		ReserveData *pReserveData = new ReserveData;
		pReserveData->pNetworkProxy = pData;
		pReserveData->nReqID = nMsgId;
		G.m_mapReserveData.insert(map<int, ReserveData*>::value_type(nSeq, pReserveData));
		G.m_setReqSource.insert(pData);
		m_writeCv.notify_one();

		delete coded_output;
		delete raw_output;	
	}

	return 0;
}
Example #4
0
void ZatData::loadChannels() {


    Json::Value favs = loadFavourites();

    ostringstream urlStream;
    urlStream << "zattoo.com/zapi/v2/cached/channels/" << powerHash << "?details=False";

    HTTPSocketRaw *socket = new HTTPSocketRaw();
    Request request;
    request.url = urlStream.str();
    request.AddHeader("Cookie", cookie);
    Response response;
    socket->Execute(request, response);
    cookie = response.cookie;
    std::string jsonString = response.body;

    Json::Value json;
    Json::Reader reader;
    
    if (!reader.parse(jsonString,json)){
        // report to the user the failure and their locations in the document.
        std::cout  << "Failed to parse configuration\n"
        << reader.getFormatedErrorMessages();
        return;
    }

    channelNumber = 1;
    Json::Value groups = json["channel_groups"];

    PVRZattooChannelGroup favGroup;
    favGroup.name = "Favoriten";
    //Load the channel groups and channels
    for ( int index = 0; index < groups.size(); ++index ) {
        PVRZattooChannelGroup group;
        group.name = groups[index]["name"].asString();
        Json::Value channels = groups[index]["channels"];
        for(int i = 0; i < channels.size(); ++i) {
            Json::Value qualities = channels[i]["qualities"];
            for(int q = 0; q < qualities.size(); ++q) {
                if(qualities[q]["availability"].asString() == "available") {
                    ZatChannel channel;
                    channel.name = qualities[q]["title"].asString();
                    channel.strStreamURL = "";
                    //cout << channel.name << endl;
                    std::string cid = channels[i]["cid"].asString(); //returns std::size_t
                    channel.iUniqueId = GetChannelId(cid.c_str());
                    channel.cid = cid;
                    channel.iChannelNumber = ++channelNumber;
                    channel.strLogoPath = "http://logos.zattic.com";
                    channel.strLogoPath.append(qualities[q]["logo_white_84"].asString());
                    group.channels.insert(group.channels.end(), channel);
                    //Yeah thats bad performance
                    for (int fav = 0; fav < favs.size(); fav++) {
                        if (favs[fav].asString() == cid) {
                            favGroup.channels.insert(favGroup.channels.end(), channel);
                        }
                    }
                    break;
                }   
            }
        }
        if (group.channels.size() > 0)
            channelGroups.insert(channelGroups.end(),group);
    }

    if (favGroup.channels.size() > 0)
        channelGroups.insert(channelGroups.end(),favGroup);
}
Example #5
0
void Dispatcher::handleRequestReceived(const JoynrMessage& message)
{
    std::string senderId = message.getHeaderFrom();
    std::string receiverId = message.getHeaderTo();

    // json request
    // lookup necessary data
    std::string jsonRequest = message.getPayload();
    std::shared_ptr<RequestCaller> caller = requestCallerDirectory.lookup(receiverId);
    if (caller == nullptr) {
        JOYNR_LOG_ERROR(
                logger,
                "caller not found in the RequestCallerDirectory for receiverId {}, ignoring",
                receiverId);
        return;
    }
    std::string interfaceName = caller->getInterfaceName();

    // Get the request interpreter that has been registered with this interface name
    std::shared_ptr<IRequestInterpreter> requestInterpreter =
            InterfaceRegistrar::instance().getRequestInterpreter(interfaceName);

    // deserialize json
    try {
        Request request = JsonSerializer::deserialize<Request>(jsonRequest);

        std::string requestReplyId = request.getRequestReplyId();
        JoynrTimePoint requestExpiryDate = message.getHeaderExpiryDate();

        std::function<void(std::vector<Variant>)> onSuccess =
                [requestReplyId, requestExpiryDate, this, senderId, receiverId](
                        std::vector<Variant> returnValueVar) {
            Reply reply;
            reply.setRequestReplyId(requestReplyId);
            reply.setResponse(std::move(returnValueVar));
            // send reply back to the original sender (ie. sender and receiver ids are reversed
            // on
            // purpose)
            JOYNR_LOG_DEBUG(logger,
                            "Got reply from RequestInterpreter for requestReplyId {}",
                            requestReplyId);
            JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>(
                    std::chrono::system_clock::now());
            std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>(
                                       requestExpiryDate - now).count();
            messageSender->sendReply(receiverId, // receiver of the request is sender of reply
                                     senderId,   // sender of request is receiver of reply
                                     MessagingQos(ttl),
                                     reply);
        };

        std::function<void(const exceptions::JoynrException&)> onError =
                [requestReplyId, requestExpiryDate, this, senderId, receiverId](
                        const exceptions::JoynrException& exception) {
            Reply reply;
            reply.setRequestReplyId(requestReplyId);
            reply.setError(joynr::exceptions::JoynrExceptionUtil::createVariant(exception));
            JOYNR_LOG_DEBUG(logger,
                            "Got error reply from RequestInterpreter for requestReplyId {}",
                            requestReplyId);
            JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>(
                    std::chrono::system_clock::now());
            std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>(
                                       requestExpiryDate - now).count();
            messageSender->sendReply(receiverId, // receiver of the request is sender of reply
                                     senderId,   // sender of request is receiver of reply
                                     MessagingQos(ttl),
                                     reply);
        };
        // execute request
        requestInterpreter->execute(caller,
                                    request.getMethodName(),
                                    request.getParams(),
                                    request.getParamDatatypes(),
                                    onSuccess,
                                    onError);
    } catch (const std::invalid_argument& e) {
        JOYNR_LOG_ERROR(logger,
                        "Unable to deserialize request object from: {} - error: {}",
                        jsonRequest,
                        e.what());
        return;
    }
}
	static size_t GotHeaderStatic( void *ptr, size_t size, size_t nmemb, void *userdata)
	{
		Request *mem = (Request *)userdata;
		return mem->GotHeader((const char *)ptr,size*nmemb);
	}
Example #7
0
onion_connection_status StaticHandler::operator()(Request &req, Response &res)
{
	return onion_shortcut_response_file((path+req.path()).c_str(), req.c_handler(), res.c_handler());
}
Example #8
0
void CIwHTTPQueue::Update()
{
	if (m_Request.size())
	{
		if (g_GotResult)
		{
			m_HTTP.Cancel();
			g_GotResult = false;

			Request request = m_Request[0];
			m_Request.erase(0);

			if (g_Result)
			{
				// Call the requests callback with the received data
				if (request.Callback)
				{
					request.Callback(request.pArgument, (const char*)g_szContentType, g_Result, g_ResultLen);
				}

				// Free result
				s3eFree(g_Result);
				g_szContentType[0] = 0;
				g_Result = 0;
			}
			else
			{
				if (request.CallbackError)
				{
					request.CallbackError(request.pArgument);
				}
			}

			delete[] (char*)request.pURL;

			// Begin fetching the next request
			if (m_Request.size())
			{
				if (m_Request[0].Callback)
				{
					if (m_Request[0].usePost)
					{
						m_timeout = m_Request[0].timeout;
						m_requestStart = s3eTimerGetMs();
						m_HTTP.Post(m_Request[0].pURL, m_Request[0].szBuffer, m_Request[0].bufferLen, GotHeaders, NULL);
					}
					else
					{
						m_timeout = m_Request[0].timeout;
						m_requestStart = s3eTimerGetMs();
						m_HTTP.Get(m_Request[0].pURL, GotHeaders, NULL);
					}
				}
				else
				{
					g_GotResult = true;
				}
			}
		}
		else
		{
			uint64 now = s3eTimerGetMs();

			if (m_Request[0].timeout != -1 && (now - m_requestStart) > m_Request[0].timeout)
			{
				m_Request[0].timeout = -1;
				g_GotResult = true;
				m_HTTP.Cancel();
				s3eDeviceYield(0);
			}
		}
	}
}
Example #9
0
    int PamBackend::converse(int n, const struct pam_message **msg, struct pam_response **resp) {
        qDebug() << "[PAM] Conversation with" << n << "messages";

        bool newRequest = false;

        if (n <= 0 || n > PAM_MAX_NUM_MSG)
            return PAM_CONV_ERR;

        for (int i = 0; i < n; i++) {
            switch(msg[i]->msg_style) {
                case PAM_PROMPT_ECHO_OFF:
                case PAM_PROMPT_ECHO_ON:
                    newRequest = m_data->insertPrompt(msg[i], n == 1);
                    break;
                case PAM_ERROR_MSG:
                    m_app->error(QString::fromLocal8Bit(msg[i]->msg), Auth::ERROR_AUTHENTICATION);
                    break;
                case PAM_TEXT_INFO:
                    // if there's only the info message, let's predict the prompts too
                    m_app->info(QString::fromLocal8Bit(msg[i]->msg), m_data->handleInfo(msg[i], n == 1));
                    break;
                default:
                    break;
            }
        }

        if (newRequest) {
            Request sent = m_data->getRequest();
            Request received;

            if (sent.valid()) {
                received = m_app->request(sent);

                if (!received.valid())
                    return PAM_CONV_ERR;

                m_data->completeRequest(received);
            }
        }

        *resp = (struct pam_response *) calloc(n, sizeof(struct pam_response));
        if (!*resp) {
            return PAM_BUF_ERR;
        }

        for (int i = 0; i < n; i++) {
            QByteArray response = m_data->getResponse(msg[i]);

            resp[i]->resp = (char *) malloc(response.length() + 1);
            // on error, get rid of everything
            if (!resp[i]->resp) {
                for (int j = 0; j < n; j++) {
                    free(resp[i]->resp);
                    resp[i]->resp = nullptr;
                }
                free(*resp);
                *resp = nullptr;
                return PAM_BUF_ERR;
            }

            memcpy(resp[i]->resp, response.constData(), response.length());
            resp[i]->resp[response.length()] = '\0';
        }

        return PAM_SUCCESS;
    }
bool HttpClient::init(HTTPRequest *ptHttpRequest,Request &request,ExecutionContent &executionContent)
{
	bool rtn = false;
	ptHttpRequest->delegate = this;
	ptHttpRequest->timeOutSeconds = _clientConfiguration.connectionTimeout;
	ptHttpRequest->userAgent = _clientConfiguration.userAgent;
	if ( !_clientConfiguration.proxyHost.empty() && _clientConfiguration.proxyPort > 0)
	{
		ptHttpRequest->proxyHost = _clientConfiguration.proxyHost;
		ptHttpRequest->proxyPort = _clientConfiguration.proxyPort;
		ptHttpRequest->proxyUserName = _clientConfiguration.proxyUserName;
		ptHttpRequest->proxyPassword = _clientConfiguration.proxyPassword;
		ptHttpRequest->proxyDomain = _clientConfiguration.proxyWorkstation;
	}
	ptHttpRequest->requestMethod = request.method;
	switch (request.method)
	{
	case HttpMethod_GET:
		{
		}
		break;
		case HttpMethod_PUT:
		{
			ptHttpRequest->addPostData(request.getContent(),request.getContentLength());
		}
		break;
		case HttpMethod_POST:
		{
			ptHttpRequest->addPostData(request.getContent(),request.getContentLength());
		}
		break;
		case HttpMethod_HEAD:
		{
		}
		break;
		case HttpMethod_DELETE:
		{
		}
		break;
		
	default:
		break;
	}
	map<string,string> dictHeaders = request.getHeaders();
	map < string, string >::iterator iter=dictHeaders.begin();
	for (iter = dictHeaders.begin(); iter != dictHeaders.end(); iter++ ) 
	{
		string key = iter->first;
		string value = iter->second;
	//	std::transform(key.begin(), key.end(), key.begin(), ::tolower);
		if(key.compare("Content-Length")==0 ||key.compare("Host")==0) 
		{
			continue;
		}
		ptHttpRequest->addRequestHeader(key,value);
	}

	iter= dictHeaders.find("Content-Type");
	if(iter == dictHeaders.end()) {
		ptHttpRequest->addRequestHeader("Content-Type","");
	}
	rtn = true;
	iter = request.userInfo.find("method");
	if(iter != request.userInfo.end())
	{
		if(iter->second.compare("FetchObject") == 0)
		{
			map < string, string >::iterator iter2 = request.userInfo.find("path");
			if(iter2 != request.userInfo.end())
			{
				rtn = ptHttpRequest->SetReciveFile(iter2->second);
			}
		}
	}

	return rtn ;
}
Example #11
0
 virtual std::shared_ptr<Response> handle(
         const CrackedUri &/*uri*/, const Request &request) override {
     return make_shared<AsyncResponse>(request.server());
 }
Example #12
0
void 
Ndbfs::execFSAPPENDREQ(Signal * signal)
{
  const FsAppendReq * const fsReq = (FsAppendReq *)&signal->theData[0];
  const Uint16 filePointer =  (Uint16)fsReq->filePointer;
  const UintR userPointer = fsReq->userPointer; 
  const BlockReference userRef = fsReq->userReference;
  const BlockNumber blockNumber = refToBlock(userRef);

  FsRef::NdbfsErrorCodeType errorCode;

  AsyncFile* openFile = theOpenFiles.find(filePointer);
  const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsReq->varIndex];

  const Uint32* tWA   = (const Uint32*)myBaseAddrRef->WA;
  const Uint32  tSz   = myBaseAddrRef->nrr;
  const Uint32 offset = fsReq->offset;
  const Uint32 size   = fsReq->size;
  const Uint32 synch_flag = fsReq->synch_flag;
  Request *request = theRequestPool->get();

  if (openFile == NULL) {
    jam();
    errorCode = FsRef::fsErrFileDoesNotExist;
    goto error;
  }

  if (myBaseAddrRef == NULL) {
    jam(); // Ensure that a valid variable is used
    errorCode = FsRef::fsErrInvalidParameters;
    goto error;
  }
  
  if (fsReq->varIndex >= getBatSize(blockNumber)) {
    jam();// Ensure that a valid variable is used    
    errorCode = FsRef::fsErrInvalidParameters;
    goto error;
  }
  
  if(offset + size > tSz){
    jam(); // Ensure that a valid variable is used
    errorCode = FsRef::fsErrInvalidParameters;
    goto error;
  }

  request->error = 0;
  request->set(userRef, userPointer, filePointer);
  request->file = openFile;
  request->theTrace = signal->getTrace();
  
  request->par.append.buf = (const char *)(tWA + offset);
  request->par.append.size = size << 2;

  if (!synch_flag)
    request->action = Request::append;
  else
    request->action = Request::append_synch;
  ndbrequire(forward(openFile, request));
  return;
  
error:
  jam();
  theRequestPool->put(request);
  FsRef * const fsRef = (FsRef *)&signal->theData[0];
  fsRef->userPointer = userPointer;
  fsRef->setErrorCode(fsRef->errorCode, errorCode);
  fsRef->osErrorCode = ~0; // Indicate local error

  jam();
  sendSignal(userRef, GSN_FSAPPENDREF, signal, 3, JBB);
  return;
}
Example #13
0
void 
Ndbfs::readWriteRequest(int action, Signal * signal)
{
  const FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0];
  Uint16 filePointer =  (Uint16)fsRWReq->filePointer;
  const UintR userPointer = fsRWReq->userPointer; 
  const BlockReference userRef = fsRWReq->userReference;
  const BlockNumber blockNumber = refToBlock(userRef);

  AsyncFile* openFile = theOpenFiles.find(filePointer);

  const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsRWReq->varIndex];
  UintPtr tPageSize;
  UintPtr tClusterSize;
  UintPtr tNRR;
  UintPtr tPageOffset;
  char*        tWA;
  FsRef::NdbfsErrorCodeType errorCode;

  Request *request = theRequestPool->get();
  request->error = 0;
  request->set(userRef, userPointer, filePointer);
  request->file = openFile;
  request->action = (Request::Action) action;
  request->theTrace = signal->getTrace();

  Uint32 format = fsRWReq->getFormatFlag(fsRWReq->operationFlag);

  if (fsRWReq->numberOfPages == 0) { //Zero pages not allowed
    jam();
    errorCode = FsRef::fsErrInvalidParameters;
    goto error;
  }

  if(format != FsReadWriteReq::fsFormatGlobalPage &&
     format != FsReadWriteReq::fsFormatSharedPage)
  {     
    if (fsRWReq->varIndex >= getBatSize(blockNumber)) {
      jam();// Ensure that a valid variable is used    
      errorCode = FsRef::fsErrInvalidParameters;
      goto error;
    }
    if (myBaseAddrRef == NULL) {
      jam(); // Ensure that a valid variable is used
      errorCode = FsRef::fsErrInvalidParameters;
      goto error;
    }
    if (openFile == NULL) {
      jam(); //file not open
      errorCode = FsRef::fsErrFileDoesNotExist;
      goto error;
    }
    tPageSize = pageSize(myBaseAddrRef);
    tClusterSize = myBaseAddrRef->ClusterSize;
    tNRR = myBaseAddrRef->nrr;
    tWA = (char*)myBaseAddrRef->WA;
    
    switch (format) {
      
      // List of memory and file pages pairs
    case FsReadWriteReq::fsFormatListOfPairs: { 
      jam();
      for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
	jam();
	const UintPtr varIndex = fsRWReq->data.listOfPair[i].varIndex;
	const UintPtr fileOffset = fsRWReq->data.listOfPair[i].fileOffset;
	if (varIndex >= tNRR) {
	  jam();
	  errorCode = FsRef::fsErrInvalidParameters;
	  goto error;
	}//if
	request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
	request->par.readWrite.pages[i].size = tPageSize;
	request->par.readWrite.pages[i].offset = fileOffset * tPageSize;
      }//for
      request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
      break;
    }//case
      
      // Range of memory page with one file page
    case FsReadWriteReq::fsFormatArrayOfPages: { 
      if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR) {
        jam();
        errorCode = FsRef::fsErrInvalidParameters;
        goto error;
      }//if
      const UintPtr varIndex = fsRWReq->data.arrayOfPages.varIndex;
      const UintPtr fileOffset = fsRWReq->data.arrayOfPages.fileOffset;
      
      request->par.readWrite.pages[0].offset = fileOffset * tPageSize;
      request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages;
      request->par.readWrite.numberOfPages = 1;
      request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize];
      break;
    }//case
      
      // List of memory pages followed by one file page
    case FsReadWriteReq::fsFormatListOfMemPages: { 
      
      tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages];
      tPageOffset *= tPageSize;
      
      for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
	jam();
	UintPtr varIndex = fsRWReq->data.listOfMemPages.varIndex[i];
	
	if (varIndex >= tNRR) {
	  jam();
	  errorCode = FsRef::fsErrInvalidParameters;
	  goto error;
	}//if
	request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
	request->par.readWrite.pages[i].size = tPageSize;
	request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize);
      }//for
      request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
      break;
      // make it a writev or readv
    }//case
      
    default: {
      jam();
      errorCode = FsRef::fsErrInvalidParameters;
      goto error;
    }//default
    }//switch
  } 
  else if (format == FsReadWriteReq::fsFormatGlobalPage)
  {
    Ptr<GlobalPage> ptr;
    m_global_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]);
    request->par.readWrite.pages[0].buf = (char*)ptr.p;
    request->par.readWrite.pages[0].size = ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages;
    request->par.readWrite.pages[0].offset= ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex;
    request->par.readWrite.numberOfPages = 1;
  }
  else
  {
    ndbrequire(format == FsReadWriteReq::fsFormatSharedPage);
    Ptr<GlobalPage> ptr;
    m_shared_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]);
    request->par.readWrite.pages[0].buf = (char*)ptr.p;
    request->par.readWrite.pages[0].size = ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages;
    request->par.readWrite.pages[0].offset= ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex;
    request->par.readWrite.numberOfPages = 1;
  }
  
  ndbrequire(forward(openFile, request));
  return;
  
error:
  theRequestPool->put(request);
  FsRef * const fsRef = (FsRef *)&signal->theData[0];
  fsRef->userPointer = userPointer;
  fsRef->setErrorCode(fsRef->errorCode, errorCode);
  fsRef->osErrorCode = ~0; // Indicate local error
  switch (action) {
  case Request:: write:
  case Request:: writeSync: {
    jam();
    sendSignal(userRef, GSN_FSWRITEREF, signal, 3, JBB);
    break;
  }//case
  case Request:: readPartial: 
  case Request:: read: {
    jam();
    sendSignal(userRef, GSN_FSREADREF, signal, 3, JBB);
  }//case
  }//switch
  return;
}
Example #14
0
void 
Ndbfs::execFSOPENREQ(Signal* signal)
{
  jamEntry();
  const FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0];
  const BlockReference userRef = fsOpenReq->userReference;
  AsyncFile* file = getIdleFile();
  ndbrequire(file != NULL);
  Filename::NameSpec spec(theFileSystemPath, theBackupFilePath);

  Uint32 userPointer = fsOpenReq->userPointer;
  
  if(fsOpenReq->fileFlags & FsOpenReq::OM_INIT)
  {
    Ptr<GlobalPage> page_ptr;
    if(m_global_page_pool.seize(page_ptr) == false)
    {
      FsRef * const fsRef = (FsRef *)&signal->theData[0];
      fsRef->userPointer  = userPointer; 
      fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrOutOfMemory);
      fsRef->osErrorCode  = ~0; // Indicate local error
      sendSignal(userRef, GSN_FSOPENREF, signal, 3, JBB);
      return;
    }
    file->m_page_ptr = page_ptr;
  } 
  else
  {
    ndbassert(file->m_page_ptr.isNull());
    file->m_page_ptr.setNull();
  }
  
  if(signal->getNoOfSections() == 0){
    jam();
    file->theFileName.set(spec, userRef, fsOpenReq->fileNumber);
  } else {
    jam();
    SegmentedSectionPtr ptr;
    signal->getSection(ptr, FsOpenReq::FILENAME);
    file->theFileName.set(spec, ptr, g_sectionSegmentPool);
    releaseSections(signal);
  }
  file->reportTo(&theFromThreads);
  if (getenv("NDB_TRACE_OPEN"))
    ndbout_c("open(%s)", file->theFileName.c_str());
  
  Request* request = theRequestPool->get();
  request->action = Request::open;
  request->error = 0;
  request->set(userRef, userPointer, newId() );
  request->file = file;
  request->theTrace = signal->getTrace();
  request->par.open.flags = fsOpenReq->fileFlags;
  request->par.open.page_size = fsOpenReq->page_size;
  request->par.open.file_size = fsOpenReq->file_size_hi;
  request->par.open.file_size <<= 32;
  request->par.open.file_size |= fsOpenReq->file_size_lo;
  request->par.open.auto_sync_size = fsOpenReq->auto_sync_size;
  
  ndbrequire(forward(file, request));
}
	static int GotProgressStatic(void *clientp,double dltotal,double dlnow,double ultotal,double ulnow)
	{
		Request *mem = (Request *)clientp;
		return mem->GotProgress(dltotal,dlnow,ultotal,ulnow);
	}
Example #16
0
 void set_connection_header(Request& req) const
 {
   req.header().set_field(header::Connection,
   (keep_alive_) ? std::string{"keep-alive"} : std::string{"close"});
 }
	static void GotResolveStatic(void *arg, int status, int timeouts, struct hostent *hostent)
	{
		Request *mem = (Request *)arg;
		mem->GotResolve(status,timeouts,hostent);
	}
Example #18
0
 void execute(const Request& request, Response& response) {
     log_debug(GET_LOGGER("agent"), "Getting memory chunk info.");
     response.set_chunk(ComputeComponents::get_instance()->
                                 get_memory_chunk_manager().get_entry(
                                         request.get_chunk()));
 }
/** Executes the corresponding header for client's request.
 *
 *	\param request Is the user's request.
 */
void WebServer::handleRequest(Request &request){
	RequestHandler &hdlr = requestManager.getHanlder(request.getUri());
	hdlr.run(request);
}
Example #20
0
int main(int argc, char **argv)
{
    const char *jobid, *user, *title, *options, *ppdFile, *file;
    unsigned long copies;
    Request request;
    PPDFile ppd;


    // Check the given arguments
    if (argc != 6 && argc != 7) {
        fprintf(stderr, _("Usage: %s job-id user title copies options "
            "[file]\n"), argv[0]);
        return 1;
    }
    jobid = argv[1];
    user = argv[2];
    title = argv[3];
    options = argv[5];
    file = argc == 7 ? argv[6] : NULL;
    copies = strtol(argv[4], (char **)NULL, 10);
    ppdFile = getenv("PPD");


    // Get more information on the SpliX environment (for debugging)
    DEBUGMSG(_("SpliX filter V. %s by Aurélien Croc (AP²C)"), VERSION);
    DEBUGMSG(_("More information at: http://splix.ap2c.org"));
    DEBUGMSG(_("Compiled with: Threads=%s (#=%u, Cache=%u), JBIG=%s, "
        "BlackOptim=%s"), opt_threads ? _("enabled") : _("disabled"), 
        THREADS, CACHESIZE, opt_jbig ? _("enabled") : _("disabled"), 
        opt_blackoptim ? _("enabled") : _("disabled"));

    // Open the given file
    if (file && !freopen(file, "r", stdin)) {
        ERRORMSG(_("Cannot open file %s"), file);
        return errno;
    }

    // Open the PPD file
    if (!ppd.open(ppdFile, PPDVERSION, options))
        return 1;

    // Load the request
    if (!request.loadRequest(&ppd, jobid, user, title, copies))
        return 2;

#ifndef DISABLE_THREADS
    if (!initializeCache())
        return 3;
#endif /* DISABLE_THREADS */

    // Render the request
    if (!render(request)) {
        uninitializeCache();
        return 4;
    }

#ifndef DISABLE_THREADS
    if (!uninitializeCache())
        return 5;
#endif /* DISABLE_THREADS */

    return 0;
}
Example #21
0
bool
BluetoothParent::RecvPBluetoothRequestConstructor(
                                                PBluetoothRequestParent* aActor,
                                                const Request& aRequest)
{
  BluetoothRequestParent* actor = static_cast<BluetoothRequestParent*>(aActor);

#ifdef DEBUG
  actor->mRequestType = aRequest.type();
#endif

  switch (aRequest.type()) {
    case Request::TGetAdaptersRequest:
      return actor->DoRequest(aRequest.get_GetAdaptersRequest());
    case Request::TStartBluetoothRequest:
      return actor->DoRequest(aRequest.get_StartBluetoothRequest());
    case Request::TStopBluetoothRequest:
      return actor->DoRequest(aRequest.get_StopBluetoothRequest());
    case Request::TSetPropertyRequest:
      return actor->DoRequest(aRequest.get_SetPropertyRequest());
    case Request::TStartDiscoveryRequest:
      return actor->DoRequest(aRequest.get_StartDiscoveryRequest());
    case Request::TStopDiscoveryRequest:
      return actor->DoRequest(aRequest.get_StopDiscoveryRequest());
    case Request::TStartLeScanRequest:
      return actor->DoRequest(aRequest.get_StartLeScanRequest());
    case Request::TStopLeScanRequest:
      return actor->DoRequest(aRequest.get_StopLeScanRequest());
    case Request::TPairRequest:
      return actor->DoRequest(aRequest.get_PairRequest());
    case Request::TUnpairRequest:
      return actor->DoRequest(aRequest.get_UnpairRequest());
    case Request::TPairedDevicePropertiesRequest:
      return actor->DoRequest(aRequest.get_PairedDevicePropertiesRequest());
    case Request::TConnectedDevicePropertiesRequest:
      return actor->DoRequest(aRequest.get_ConnectedDevicePropertiesRequest());
    case Request::TFetchUuidsRequest:
      return actor->DoRequest(aRequest.get_FetchUuidsRequest());
    case Request::TPinReplyRequest:
      return actor->DoRequest(aRequest.get_PinReplyRequest());
    case Request::TSspReplyRequest:
      return actor->DoRequest(aRequest.get_SspReplyRequest());
    case Request::TSetPinCodeRequest:
      return actor->DoRequest(aRequest.get_SetPinCodeRequest());
    case Request::TSetPasskeyRequest:
      return actor->DoRequest(aRequest.get_SetPasskeyRequest());
    case Request::TConfirmPairingConfirmationRequest:
      return actor->DoRequest(aRequest.get_ConfirmPairingConfirmationRequest());
    case Request::TDenyPairingConfirmationRequest:
      return actor->DoRequest(aRequest.get_DenyPairingConfirmationRequest());
    case Request::TConnectRequest:
      return actor->DoRequest(aRequest.get_ConnectRequest());
    case Request::TDisconnectRequest:
      return actor->DoRequest(aRequest.get_DisconnectRequest());
    case Request::TSendFileRequest:
      return actor->DoRequest(aRequest.get_SendFileRequest());
    case Request::TStopSendingFileRequest:
      return actor->DoRequest(aRequest.get_StopSendingFileRequest());
    case Request::TConfirmReceivingFileRequest:
      return actor->DoRequest(aRequest.get_ConfirmReceivingFileRequest());
    case Request::TDenyReceivingFileRequest:
      return actor->DoRequest(aRequest.get_DenyReceivingFileRequest());
    case Request::TConnectScoRequest:
      return actor->DoRequest(aRequest.get_ConnectScoRequest());
    case Request::TDisconnectScoRequest:
      return actor->DoRequest(aRequest.get_DisconnectScoRequest());
    case Request::TIsScoConnectedRequest:
      return actor->DoRequest(aRequest.get_IsScoConnectedRequest());
    case Request::TSetObexPasswordRequest:
      return actor->DoRequest(aRequest.get_SetObexPasswordRequest());
    case Request::TRejectObexAuthRequest:
      return actor->DoRequest(aRequest.get_RejectObexAuthRequest());
    case Request::TReplyTovCardPullingRequest:
      return actor->DoRequest(aRequest.get_ReplyTovCardPullingRequest());
    case Request::TReplyToPhonebookPullingRequest:
      return actor->DoRequest(aRequest.get_ReplyToPhonebookPullingRequest());
    case Request::TReplyTovCardListingRequest:
      return actor->DoRequest(aRequest.get_ReplyTovCardListingRequest());
    case Request::TReplyToFolderListingRequest:
      return actor->DoRequest(aRequest.get_ReplyToFolderListingRequest());
    case Request::TReplyToMessagesListingRequest:
      return actor->DoRequest(aRequest.get_ReplyToMessagesListingRequest());
    case Request::TReplyToGetMessageRequest:
      return actor->DoRequest(aRequest.get_ReplyToGetMessageRequest());
    case Request::TReplyToSetMessageStatusRequest:
      return actor->DoRequest(aRequest.get_ReplyToSetMessageStatusRequest());
    case Request::TReplyToSendMessageRequest:
      return actor->DoRequest(aRequest.get_ReplyToSendMessageRequest());
    case Request::TReplyToMessageUpdateRequest:
      return actor->DoRequest(aRequest.get_ReplyToMessageUpdateRequest());
#ifdef MOZ_B2G_RIL
    case Request::TAnswerWaitingCallRequest:
      return actor->DoRequest(aRequest.get_AnswerWaitingCallRequest());
    case Request::TIgnoreWaitingCallRequest:
      return actor->DoRequest(aRequest.get_IgnoreWaitingCallRequest());
    case Request::TToggleCallsRequest:
      return actor->DoRequest(aRequest.get_ToggleCallsRequest());
#endif
    case Request::TSendMetaDataRequest:
      return actor->DoRequest(aRequest.get_SendMetaDataRequest());
    case Request::TSendPlayStatusRequest:
      return actor->DoRequest(aRequest.get_SendPlayStatusRequest());
    case Request::TConnectGattClientRequest:
      return actor->DoRequest(aRequest.get_ConnectGattClientRequest());
    case Request::TDisconnectGattClientRequest:
      return actor->DoRequest(aRequest.get_DisconnectGattClientRequest());
    case Request::TDiscoverGattServicesRequest:
      return actor->DoRequest(aRequest.get_DiscoverGattServicesRequest());
    case Request::TGattClientStartNotificationsRequest:
      return actor->DoRequest(
        aRequest.get_GattClientStartNotificationsRequest());
    case Request::TGattClientStopNotificationsRequest:
      return actor->DoRequest(
        aRequest.get_GattClientStopNotificationsRequest());
    case Request::TUnregisterGattClientRequest:
      return actor->DoRequest(aRequest.get_UnregisterGattClientRequest());
    case Request::TGattClientReadRemoteRssiRequest:
      return actor->DoRequest(aRequest.get_GattClientReadRemoteRssiRequest());
    case Request::TGattClientReadCharacteristicValueRequest:
      return actor->DoRequest(
        aRequest.get_GattClientReadCharacteristicValueRequest());
    case Request::TGattClientWriteCharacteristicValueRequest:
      return actor->DoRequest(
        aRequest.get_GattClientWriteCharacteristicValueRequest());
    case Request::TGattClientReadDescriptorValueRequest:
      return actor->DoRequest(
        aRequest.get_GattClientReadDescriptorValueRequest());
    case Request::TGattClientWriteDescriptorValueRequest:
      return actor->DoRequest(
        aRequest.get_GattClientWriteDescriptorValueRequest());
    case Request::TGattServerConnectPeripheralRequest:
      return actor->DoRequest(
        aRequest.get_GattServerConnectPeripheralRequest());
    case Request::TGattServerDisconnectPeripheralRequest:
      return actor->DoRequest(
        aRequest.get_GattServerDisconnectPeripheralRequest());
    case Request::TUnregisterGattServerRequest:
      return actor->DoRequest(aRequest.get_UnregisterGattServerRequest());
    case Request::TGattServerAddServiceRequest:
      return actor->DoRequest(aRequest.get_GattServerAddServiceRequest());
    case Request::TGattServerAddIncludedServiceRequest:
      return actor->DoRequest(
               aRequest.get_GattServerAddIncludedServiceRequest());
    case Request::TGattServerAddCharacteristicRequest:
      return actor->DoRequest(
               aRequest.get_GattServerAddCharacteristicRequest());
    case Request::TGattServerAddDescriptorRequest:
      return actor->DoRequest(aRequest.get_GattServerAddDescriptorRequest());
    case Request::TGattServerRemoveServiceRequest:
      return actor->DoRequest(aRequest.get_GattServerRemoveServiceRequest());
    case Request::TGattServerStartServiceRequest:
      return actor->DoRequest(aRequest.get_GattServerStartServiceRequest());
    case Request::TGattServerStopServiceRequest:
      return actor->DoRequest(aRequest.get_GattServerStopServiceRequest());
    case Request::TGattServerSendResponseRequest:
      return actor->DoRequest(aRequest.get_GattServerSendResponseRequest());
    case Request::TGattServerSendIndicationRequest:
      return actor->DoRequest(
        aRequest.get_GattServerSendIndicationRequest());
    default:
      MOZ_CRASH("Unknown type!");
  }

  MOZ_CRASH("Should never get here!");
}
Example #22
0
void
PagerLoader::traverse(osg::NodeVisitor& nv)
{
    // only called when _mergesPerFrame > 0
    if ( nv.getVisitorType() == nv.UPDATE_VISITOR )
    {
        if ( nv.getFrameStamp() )
        {
            setFrameStamp(nv.getFrameStamp());
        }

        int count;
        for(count=0; count < _mergesPerFrame && !_mergeQueue.empty(); ++count)
        {
            Request* req = _mergeQueue.begin()->get();
            if ( req && req->_lastTick >= _checkpoint )
            {
                OE_START_TIMER(req_apply);
                req->apply( getFrameStamp() );
                double s = OE_STOP_TIMER(req_apply);

                req->setState(Request::FINISHED);
            }

            _mergeQueue.erase( _mergeQueue.begin() );
        }

        // cull finished requests.
        {
            Threading::ScopedMutexLock lock( _requestsMutex );

            unsigned fn = 0;
            if ( nv.getFrameStamp() )
                fn = nv.getFrameStamp()->getFrameNumber();

            // Purge expired requests.
            for(Requests::iterator i = _requests.begin(); i != _requests.end(); )
            {
                Request* req = i->second.get();

                if ( req->isFinished() )
                {
                    //OE_INFO << LC << req->getName() << "(" << i->second->getUID() << ") finished." << std::endl; 
                    req->setState( Request::IDLE );
                    if ( REPORT_ACTIVITY )
                        Registry::instance()->endActivity( req->getName() );
                    _requests.erase( i++ );
                }

                else if ( !req->isMerging() && (fn - req->getLastFrameSubmitted() > 2) )
                {
                    //OE_INFO << LC << req->getName() << "(" << i->second->getUID() << ") died waiting after " << fn-req->getLastFrameSubmitted() << " frames" << std::endl; 
                    req->setState( Request::IDLE );
                    if ( REPORT_ACTIVITY )
                        Registry::instance()->endActivity( req->getName() );
                    _requests.erase( i++ );
                }

                else // still valid.
                {
                    ++i;
                }
            }

            //OE_NOTICE << LC << "PagerLoader: requests=" << _requests.size() << "; mergeQueue=" << _mergeQueue.size() << std::endl;
        }
    }

    LoaderGroup::traverse( nv );
}
Example #23
0
bool ZatData::LoadEPG(time_t iStart, time_t iEnd) {


//    iStart -= (iStart % (3600/2)) - 86400; // Do s
//    iEnd = iStart + 3600*3;


    //Do some time magic that the start date is not to far in the past because zattoo doesnt like that
    time_t tempStart = iStart - (iStart % (3600/2)) - 86400;
    time_t tempEnd = tempStart + 3600*5; //Add 5 hours

    while(tempEnd < iEnd) {
        ostringstream urlStream;
        urlStream << "zattoo.com/zapi/v2/cached/program/power_guide/" << powerHash << "?end=" << tempEnd << "&start=" << tempStart << "&format=json";

        HTTPSocket *socket = new HTTPSocketRaw();
        Request request;
        request.url = urlStream.str();
        request.AddHeader("Cookie", cookie);
        Response response;
        socket->Execute(request,response);
        cookie = response.cookie;

        std::string jsonString = response.body;

        Json::Value json;
        Json::Reader reader;
        bool parsingSuccessful = reader.parse(jsonString,json);

        //D(cout << json << endl);



        Json::Value channels = json["channels"];

        //Load the channel groups and channels
        for ( int index = 0; index < channels.size(); ++index ) {

            string cid = channels[index]["cid"].asString();
            for (int i = 0; i < channels[index]["programs"].size(); ++i) {

                Json::Value program = channels[index]["programs"][i];
                int channelId = GetChannelId(cid.c_str());
                ZatChannel *channel = FindChannel(channelId);

                if (!channel) {
                    continue;
                }

                PVRIptvEpgEntry entry;
                entry.strTitle = program["t"].asString();
                entry.startTime = program["s"].asInt();
                entry.endTime = program["e"].asInt();
                entry.iBroadcastId = program["id"].asInt();
                entry.strIconPath = program["i_url"].asString();
                entry.iChannelId = channel->iChannelNumber;
                entry.strPlot = program["et"].asString();

                Json::Value genres = program["g"];
                ostringstream generesStream;
                for (int genre = 0; genre < genres.size(); genre++) {
                    generesStream << genres[genre].asString() << " ";
                }
                entry.strGenreString = generesStream.str();

                if (channel)
                    channel->epg.insert(channel->epg.end(), entry);


            }
        }

        tempStart = tempEnd;
        tempEnd = tempStart + 3600*5; //Add 5 hours
    }





    return true;
}
		void ReservationUserUpdateAction::run(Request& request)
		{
			stringstream s;
			DBLogModule::appendToLogIfChange(s, "Login", _user->getLogin(), _login);
			DBLogModule::appendToLogIfChange(s, "Adresse", _user->getAddress(), _address);
			DBLogModule::appendToLogIfChange(s, "E-mail", _user->getEMail(), _email);
			DBLogModule::appendToLogIfChange(s, "Code postal", _user->getPostCode(), _postalCode);
			DBLogModule::appendToLogIfChange(s, "Ville", _user->getCityText(), _city);
			DBLogModule::appendToLogIfChange(s, "Téléphone", _user->getPhone(), _phone);
			if(_authorizedLogin)
			{
				DBLogModule::appendToLogIfChange(s, "Autorisation de connexion", lexical_cast<string>(_user->getConnectionAllowed()), lexical_cast<string>(*_authorizedLogin));
			}
			DBLogModule::appendToLogIfChange(s, "Nom", _user->getName(), _name);
			DBLogModule::appendToLogIfChange(s, "Prénom", _user->getSurname(), _surname);

			_user->setLogin(_login);
			_user->setAddress(_address);
			_user->setEMail(_email);
			_user->setPostCode(_postalCode);
			_user->setCityText(_city);
			_user->setPhone(_phone);
			if(_authorizedLogin)
			{
				_user->setConnectionAllowed(*_authorizedLogin);
			}
			_user->setName(_name);
			_user->setSurname(_surname);

			if(!s.str().empty())
			{
				SecurityLog::addUserAdmin(request.getUser().get(), _user.get(), s.str());
				ResaDBLog::AddUserAdminEntry(*request.getSession(), *_user, s.str());
			}


			if(	_autoResaActivated &&
				(	_user->getProfile()->getKey() == ResaModule::GetBasicResaCustomerProfile()->getKey() ||
					_user->getProfile()->getKey() == ResaModule::GetAutoResaResaCustomerProfile()->getKey()
			)	){
				stringstream s2;
				DBLogModule::appendToLogIfChange(
					s2,
					"Activation auto-réservation",
					_user->getProfile()->getKey() == ResaModule::GetAutoResaResaCustomerProfile()->getKey() ? "OUI" : "NON",
					*_autoResaActivated ? "OUI" : "NON"
				);
				_user->setProfile(
					(*_autoResaActivated ? ResaModule::GetAutoResaResaCustomerProfile() : ResaModule::GetBasicResaCustomerProfile()).get()
				);

				// Change detection
				if(!s2.str().empty())
				{
					ResaDBLog::AddUserChangeAutoResaActivationEntry(*request.getSession(), *_user);

					// Send confirmation e-mail to the customer
					if(_autoResaActivated)
					{
						// Create a login if empty
						if(_user->getLogin().empty())
						{
							string idealLogin(_user->getSurname().substr(0,1) + _user->getName());
							algorithm::replace_all(idealLogin, " ", string());
							algorithm::replace_all(idealLogin, "'", string());
							algorithm::to_lower(idealLogin);

							UserTableSync::SearchResult logins(UserTableSync::Search(*_env, idealLogin));

							if(logins.empty())
							{
								_user->setLogin(idealLogin);
							}
							else
							{
								for(int i=0; i<999999; ++i)
								{
									UserTableSync::SearchResult logins(UserTableSync::Search(*_env, idealLogin + lexical_cast<string>(i)));

									if(logins.empty())
									{
										_user->setLogin(idealLogin + lexical_cast<string>(i));
										break;
									}
								}
							}
						}

						// Create random password if empty
						if(_user->getPassword().empty())
						{
							_user->setRandomPassword();
						}

						// Send confirmation email
						if(ResaModule::GetReservationContact())
						{
							if(ResaModule::GetReservationContact()->sendCustomerEMail(*_user))
							{
								ResaDBLog::AddEMailEntry(*request.getSession(), *_user, "Message d'activation de réservation en ligne");
							}
						}
					}
				}
			}

			UserTableSync::Save(_user.get());
		}
Example #25
0
inline void notFoundHandler(const Request& request, Response* pResponse)
{
   pResponse->setNotFoundError(request.uri());
}
Example #26
0
int main( void ){

    // Backup the stdio streambufs
    streambuf * cin_streambuf  = cin.rdbuf();
    streambuf * cout_streambuf = cout.rdbuf();
    streambuf * cerr_streambuf = cerr.rdbuf();

    FCGX_Request fastcgi_request;

    FCGX_Init();
    FCGX_InitRequest(&fastcgi_request, 0, 0);


    Timer my_timer;

    int x = 0;

    Request *request = new Request( &fastcgi_request );
    map<string,string>::iterator parameter_iterator;

    while( FCGX_Accept_r(&fastcgi_request) == 0 ){

        x++;

        my_timer.start();

        request->reload();

        //cout << request->message_body << endl;
        print_as_hex( request->message_body, cout );
        cout << endl;

        fcgi_streambuf cin_fcgi_streambuf( fastcgi_request.in );
        fcgi_streambuf cout_fcgi_streambuf( fastcgi_request.out );
        fcgi_streambuf cerr_fcgi_streambuf( fastcgi_request.err );

        cin.rdbuf( &cin_fcgi_streambuf );
        cout.rdbuf( &cout_fcgi_streambuf );
        cerr.rdbuf( &cerr_fcgi_streambuf );

        cout << "Content-type: text/html\r\n"
             << "\r\n"
             << "<html>\n"
             << "  <head>\n"
             << "    <title>Hello, World!</title>\n"
             << "  </head>\n"
             << "  <body>\n"
             << "    <h1>Hello, World!</h1>\n"
             ;

        //usleep(10000000);
        //cin >> input;

        cout << sha256(request->message_body) << endl;
        //cout << request->message_body << endl;



        cout << endl;

        cout << sizeof( FCGX_Request ) << endl;

        cout << x << "<br/>" << endl;

        for( parameter_iterator = request->parameters.begin(); parameter_iterator != request->parameters.end(); parameter_iterator++ ){
            cout << parameter_iterator->first << " => " << parameter_iterator->second << "<br/>" << endl;
        }

        cout << "</body></html>" << endl;

        my_timer.stop();
        cout << my_timer.getComment() << endl;

        // Note: the fcgi_streambuf destructor will auto flush
    }

    // restore stdio streambufs
    cin.rdbuf( cin_streambuf );
    cout.rdbuf( cout_streambuf );
    cerr.rdbuf( cerr_streambuf );

    delete request;

    return 0;

}
Example #27
0
        virtual void queryOp( Request& r ){
            QueryMessage q( r.d() );

            log(3) << "shard query: " << q.ns << "  " << q.query << endl;
            
            if ( q.ntoreturn == 1 && strstr(q.ns, ".$cmd") )
                throw UserException( 8010 , "something is wrong, shouldn't see a command here" );

            ChunkManagerPtr info = r.getChunkManager();
            assert( info );
            
            Query query( q.query );

            set<Shard> shards;
            info->getShardsForQuery( shards , query.getFilter()  );
            
            set<ServerAndQuery> servers;
            for ( set<Shard>::iterator i = shards.begin(); i != shards.end(); i++ ){
                servers.insert( ServerAndQuery( i->getConnString() , BSONObj() ) ); 
            }
            
            if ( logLevel > 4 ){
                StringBuilder ss;
                ss << " shard query servers: " << servers.size() << '\n';
                for ( set<ServerAndQuery>::iterator i = servers.begin(); i!=servers.end(); i++ ){
                    const ServerAndQuery& s = *i;
                    ss << "       " << s.toString() << '\n';
                }
                log() << ss.str();
            }

            ClusteredCursor * cursor = 0;
            
            BSONObj sort = query.getSort();
            
            if ( sort.isEmpty() ){
                cursor = new SerialServerClusteredCursor( servers , q );
            }
            else {
                cursor = new ParallelSortClusteredCursor( servers , q , sort );
            }

            assert( cursor );

            try {
                cursor->init();

                log(5) << "   cursor type: " << cursor->type() << endl;
                shardedCursorTypes.hit( cursor->type() );
            
                if ( query.isExplain() ){
                    BSONObj explain = cursor->explain();
                    replyToQuery( 0 , r.p() , r.m() , explain );
                    delete( cursor );
                    return;
                }
            } catch(...) {
                delete cursor;
                throw;
            }

            ShardedClientCursorPtr cc (new ShardedClientCursor( q , cursor ));
            if ( ! cc->sendNextBatch( r ) ){
                return;
            }
            log(6) << "storing cursor : " << cc->getId() << endl;
            cursorCache.store( cc );
        }
	static size_t GotData(void *ptr, size_t size, size_t nmemb, void *data)
	{
	  size_t realsize = size * nmemb;
	  Request *mem = (Request *)data;
	  return mem->GotContent(ptr,realsize);
	}
Example #29
0
        virtual void queryOp( Request& r ){
            QueryMessage q( r.d() );

            log(3) << "shard query: " << q.ns << "  " << q.query << endl;
            
            if ( q.ntoreturn == 1 && strstr(q.ns, ".$cmd") )
                throw UserException( 8010 , "something is wrong, shouldn't see a command here" );

            ChunkManager * info = r.getChunkManager();
            assert( info );
            
            Query query( q.query );

            vector<Chunk*> shards;
            info->getChunksForQuery( shards , query.getFilter()  );
            
            set<ServerAndQuery> servers;
            map<string,int> serverCounts;
            for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){
                servers.insert( ServerAndQuery( (*i)->getShard() , (*i)->getFilter() ) );
                int& num = serverCounts[(*i)->getShard()];
                num++;
            }
            
            if ( logLevel > 4 ){
                StringBuilder ss;
                ss << " shard query servers: " << servers.size() << "\n";
                for ( set<ServerAndQuery>::iterator i = servers.begin(); i!=servers.end(); i++ ){
                    const ServerAndQuery& s = *i;
                    ss << "       " << s.toString() << "\n";
                }
                log() << ss.str();
            }

            ClusteredCursor * cursor = 0;
            
            BSONObj sort = query.getSort();
            
            if ( sort.isEmpty() ){
                // 1. no sort, can just hit them in serial
                cursor = new SerialServerClusteredCursor( servers , q );
            }
            else {
                int shardKeyOrder = info->getShardKey().canOrder( sort );
                if ( shardKeyOrder ){
                    // 2. sort on shard key, can do in serial intelligently
                    set<ServerAndQuery> buckets;
                    for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){
                        Chunk * s = *i;
                        buckets.insert( ServerAndQuery( s->getShard() , s->getFilter() , s->getMin() ) );
                    }
                    cursor = new SerialServerClusteredCursor( buckets , q , shardKeyOrder );
                }
                else {
                    // 3. sort on non-sharded key, pull back a portion from each server and iterate slowly
                    cursor = new ParallelSortClusteredCursor( servers , q , sort );
                }
            }

            assert( cursor );
            
            log(5) << "   cursor type: " << cursor->type() << endl;

            ShardedClientCursor * cc = new ShardedClientCursor( q , cursor );
            if ( ! cc->sendNextBatch( r ) ){
                delete( cursor );
                return;
            }
            log(6) << "storing cursor : " << cc->getId() << endl;
            cursorCache.store( cc );
        }
Example #30
0
void Strategy::clientCommandOp(OperationContext* txn, Request& request) {
    QueryMessage q(request.d());

    LOG(3) << "command: " << q.ns << " " << q.query << " ntoreturn: " << q.ntoreturn
           << " options: " << q.queryOptions;

    if (q.queryOptions & QueryOption_Exhaust) {
        uasserted(18527,
                  string("the 'exhaust' query option is invalid for mongos commands: ") + q.ns +
                      " " + q.query.toString());
    }

    NamespaceString nss(request.getns());
    // Regular queries are handled in strategy_shard.cpp
    verify(nss.isCommand() || nss.isSpecialCommand());

    if (handleSpecialNamespaces(txn, request, q))
        return;

    int loops = 5;
    bool cmChangeAttempted = false;

    while (true) {
        BSONObjBuilder builder;
        try {
            BSONObj cmdObj = q.query;
            {
                BSONElement e = cmdObj.firstElement();
                if (e.type() == Object &&
                    (e.fieldName()[0] == '$' ? str::equals("query", e.fieldName() + 1)
                                             : str::equals("query", e.fieldName()))) {
                    // Extract the embedded query object.

                    if (cmdObj.hasField(Query::ReadPrefField.name())) {
                        // The command has a read preference setting. We don't want
                        // to lose this information so we copy this to a new field
                        // called $queryOptions.$readPreference
                        BSONObjBuilder finalCmdObjBuilder;
                        finalCmdObjBuilder.appendElements(e.embeddedObject());

                        BSONObjBuilder queryOptionsBuilder(
                            finalCmdObjBuilder.subobjStart("$queryOptions"));
                        queryOptionsBuilder.append(cmdObj[Query::ReadPrefField.name()]);
                        queryOptionsBuilder.done();

                        cmdObj = finalCmdObjBuilder.obj();
                    } else {
                        cmdObj = e.embeddedObject();
                    }
                }
            }

            Command::runAgainstRegistered(txn, q.ns, cmdObj, builder, q.queryOptions);
            BSONObj x = builder.done();
            replyToQuery(0, request.p(), request.m(), x);
            return;
        } catch (const StaleConfigException& e) {
            if (loops <= 0)
                throw e;

            loops--;
            log() << "retrying command: " << q.query;

            // For legacy reasons, ns may not actually be set in the exception :-(
            string staleNS = e.getns();
            if (staleNS.size() == 0)
                staleNS = q.ns;

            ShardConnection::checkMyConnectionVersions(txn, staleNS);
            if (loops < 4)
                versionManager.forceRemoteCheckShardVersionCB(txn, staleNS);
        } catch (const DBException& e) {
            if (e.getCode() == ErrorCodes::IncompatibleCatalogManager) {
                fassert(28791, !cmChangeAttempted);
                cmChangeAttempted = true;

                grid.forwardingCatalogManager()->waitForCatalogManagerChange(txn);
            } else {
                Command::appendCommandStatus(builder, e.toStatus());
                BSONObj x = builder.done();
                replyToQuery(0, request.p(), request.m(), x);
                return;
            }
        }
    }
}