Esempio n. 1
0
	}END_TEST

START_TEST(ReadSingleAttributeAccessLevelWithoutTimestamp)
	{
		UA_Server *server = makeTestSequence();

		UA_DataValue resp;
		UA_DataValue_init(&resp);
		UA_ReadRequest rReq;
		UA_ReadRequest_init(&rReq);
		rReq.nodesToRead = UA_ReadValueId_new();
		rReq.nodesToReadSize = 1;
		rReq.nodesToRead[0].nodeId = UA_NODEID_STRING(1, "the.answer");
		rReq.nodesToRead[0].attributeId = UA_ATTRIBUTEID_ACCESSLEVEL;

		readValue(server, UA_TIMESTAMPSTORETURN_NEITHER, &rReq.nodesToRead[0],
				&resp);

		ck_assert_int_eq(-1, resp.value.arrayLength);
		ck_assert_ptr_eq(&UA_TYPES[UA_TYPES_BYTE], resp.value.type);
		ck_assert_int_eq(*(UA_Byte*)resp.value.data, 0);
	}END_TEST
Esempio n. 2
0
	}END_TEST

START_TEST(ReadSingleAttributeArrayDimensionsWithoutTimestamp)
	{
		UA_Server *server = makeTestSequence();

		UA_DataValue resp;
		UA_DataValue_init(&resp);
		UA_ReadRequest rReq;
		UA_ReadRequest_init(&rReq);
		rReq.nodesToRead = UA_ReadValueId_new();
		rReq.nodesToReadSize = 1;
		rReq.nodesToRead[0].nodeId = UA_NODEID_STRING(1, "the.answer");
		rReq.nodesToRead[0].attributeId = UA_ATTRIBUTEID_ARRAYDIMENSIONS;

		readValue(server, UA_TIMESTAMPSTORETURN_NEITHER, &rReq.nodesToRead[0],
				&resp);

		ck_assert_int_eq(-1, resp.value.arrayLength);
		ck_assert_ptr_eq(&UA_TYPES[UA_TYPES_INT32], resp.value.type);
		ck_assert_ptr_eq((UA_Int32*)resp.value.data,0);
	}END_TEST
Esempio n. 3
0
	}END_TEST

START_TEST(ReadSingleAttributeEventNotifierWithoutTimestamp)
	{
		UA_Server *server = makeTestSequence();

		UA_DataValue resp;
		UA_DataValue_init(&resp);
		UA_ReadRequest rReq;
		UA_ReadRequest_init(&rReq);
		rReq.nodesToRead = UA_ReadValueId_new();
		rReq.nodesToReadSize = 1;
		rReq.nodesToRead[0].nodeId = UA_NODEID_NUMERIC(1, 50);
		rReq.nodesToRead[0].attributeId = UA_ATTRIBUTEID_EVENTNOTIFIER;

		readValue(server, UA_TIMESTAMPSTORETURN_NEITHER, &rReq.nodesToRead[0],
				&resp);

		ck_assert_int_eq(-1, resp.value.arrayLength);
		ck_assert_ptr_eq(&UA_TYPES[UA_TYPES_BYTE],resp.value.type);
		ck_assert_int_eq(*(UA_Byte*)resp.value.data, 0);
	}END_TEST
Esempio n. 4
0
	}END_TEST

START_TEST(ReadSingleAttributeContainsNoLoopsWithoutTimestamp)
	{
		UA_Server *server = makeTestSequence();

		UA_DataValue resp;
		UA_DataValue_init(&resp);
		UA_ReadRequest rReq;
		UA_ReadRequest_init(&rReq);
		rReq.nodesToRead = UA_ReadValueId_new();
		rReq.nodesToReadSize = 1;
		rReq.nodesToRead[0].nodeId.identifier.numeric = UA_NS0ID_VIEWNODE;
		rReq.nodesToRead[0].attributeId = UA_ATTRIBUTEID_CONTAINSNOLOOPS;

		readValue(server, UA_TIMESTAMPSTORETURN_NEITHER, &rReq.nodesToRead[0],
				&resp);

		ck_assert_int_eq(-1, resp.value.arrayLength);
		ck_assert_ptr_eq(&UA_TYPES[UA_TYPES_BOOLEAN], resp.value.type);
		ck_assert(*(UA_Boolean* )resp.value.data==UA_FALSE);
	}END_TEST
WebInputTemp::WebInputTemp(Params &p):
    InputTemp(p)
{

    ioDoc->friendlyNameSet("WebInputTemp");
    ioDoc->descriptionSet(_("Temperature input read from a web document"));
    ioDoc->paramAdd("url", _("URL where to download the document from.\n"
                             "If URL begins with file:// the data is read from the local file"),
                    IODoc::TYPE_STRING, true);
    ioDoc->paramAdd("file_type",_("File type of the document. Values can be xml, json or text."),
                    IODoc::TYPE_STRING, true);
    ioDoc->paramAdd("path",_("The path where to found the value. This value can take multiple values "
                             "depending on the file type. If file_type is JSON, the json file "
                             "downloaded will be read, and the informations will be extracted from "
                             "the path. for example weather[0]/description, try to read the "
                             "description value of the 1 element of the array of the weather object.\n"
                             "If file_type is XML, the path is an xpath expression; Look here for "
                             "syntax : http://www.w3schools.com/xsl/xpath_syntax.asp "
                             "If file_type is TEXT, the downloaded file is returned as "
                             "plain text file, and path must be in the form line/pos/separator "
                             "Line is read, and is split using separator as delimiters "
                             "The value returned is the value at pos in the split list. "
                             "If the separator is not found, the whole line is returned. "
                             "Example the file contains \n"
                             "10.0,10.1,10.2,10.3\n"
                             "20.0,20.1,20.2,20.3\n"
                             "If the path is 2/4/, the value returne wil be 20.3\n"),
                             IODoc::TYPE_STRING, true);

    cInfoDom("input") << "WebInputTemp::WebInputTemp()";
    Calaos::StartReadRules::Instance().addIO();

    // Add input to WebCtrl instance
    WebCtrl::Instance(p).Add(get_param("path"), readTime, [=]()
    {
        readValue();
        Calaos::StartReadRules::Instance().ioRead();
    });
}
int IioSensorBase::readEvents(sensors_event_t* data, int count)
{
    if (count < 1)
        return -EINVAL;

    pthread_mutex_lock(&mLock);
    int numEventReceived = 0;

    if (mHasPendingEvent) {
        mHasPendingEvent = false;
        if (mEnabled) {
            mPendingEvent.timestamp = getTimestamp();
            *data = mPendingEvent;
            numEventReceived++;
        }
        goto done;
    }

    iio_event_data const* event;

    while (count && mInputReader.readEvent(mDataFd, &event)) {
        int value;
        if (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id) == mIioChanType) {
            if (mEnabled && readValue(&value)) {
                handleData(value);
                mPendingEvent.timestamp = event->timestamp;
                *data++ = mPendingEvent;
                count--;
                numEventReceived++;
            }
        }
        mInputReader.next();
    }

done:
    pthread_mutex_unlock(&mLock);
    return numEventReceived;
}
Esempio n. 7
0
EnumMap<OptionId, Options::Value> Options::readValues() {
  EnumMap<OptionId, Value> ret = defaults;
  ifstream in(filename);
  while (1) {
    char buf[100];
    in.getline(buf, 100);
    if (!in)
      break;
    vector<string> p = split(string(buf), {','});
    if (p.empty())
      continue;
    if (p.size() == 1)
      p.push_back("");
    OptionId optionId;
    if (auto id = EnumInfo<OptionId>::fromStringSafe(p[0]))
      optionId = *id;
    else
      continue;
    if (auto val = readValue(optionId, p[1]))
      ret[optionId] = *val;
  }
  return ret;
}
bool Reader::readArray(Token& tokenStart) {
  Value init(arrayValue);
  currentValue().swapPayload(init);
  currentValue().setOffsetStart(tokenStart.start_ - begin_);
  skipSpaces();
  if (*current_ == ']') // empty array
  {
    Token endArray;
    readToken(endArray);
    return true;
  }
  int index = 0;
  for (;;) {
    Value& value = currentValue()[index++];
    nodes_.push(&value);
    bool ok = readValue();
    nodes_.pop();
    if (!ok) // error already set
      return recoverFromError(tokenArrayEnd);

    Token token;
    // Accept Comment after last item in the array.
    ok = readToken(token);
    while (token.type_ == tokenComment && ok) {
      ok = readToken(token);
    }
    bool badTokenType =
        (token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd);
    if (!ok || badTokenType) {
      return addErrorAndRecover(
          "Missing ',' or ']' in array declaration", token, tokenArrayEnd);
    }
    if (token.type_ == tokenArrayEnd)
      break;
  }
  return true;
}
    bool parseStructure(VLXStructure* st)
    {
      std::string str;
      
      // tag
      if (!readString(str))
        return false;
      st->setTag(str.c_str());

      // ID
      if (!readString(str))
        return false;
      st->setID(str.c_str());

      // read key/value count
      long long count = 0;
      if (!readInteger(count))
        return false;

      // values
      for(int i=0; i<count; ++i)
      {
        VLXStructure::Value val;
        
        // key
        if (!readString(str))
          return false;
        val.setKey(str.c_str());

        // value
        if (!readValue(val.value()))
          return false;
        st->value().push_back(val);
      }
      
      return true;
    }
Esempio n. 10
0
Hash* Parser::readHash()
{
    Tokenizer::TokenType tok = tokenizer->nextToken();
    if (tok != Tokenizer::TokenBeginGroup)
    {
        tokenizer->pushBack();
        return NULL;
    }

    Hash* hash = new Hash();

    tok = tokenizer->nextToken();
    while (tok != Tokenizer::TokenEndGroup)
    {
        if (tok != Tokenizer::TokenName)
        {
            tokenizer->pushBack();
            delete hash;
            return NULL;
        }
        string name = tokenizer->getNameValue();

        Value* value = readValue();
        if (value == NULL)
        {
            delete hash;
            return NULL;
        }
        
        hash->addValue(name, *value);

        tok = tokenizer->nextToken();
    }

    return hash;
}
Esempio n. 11
0
void * QgsRasterNuller::readBlock( int bandNo, QgsRectangle  const & extent, int width, int height )
{
  QgsDebugMsg( "Entered" );
  if ( !mInput ) return 0;

  //QgsRasterDataProvider *provider = dynamic_cast<QgsRasterDataProvider*>( mInput->srcInput() );

  void * rasterData = mInput->block( bandNo, extent, width, height );

  QgsRasterInterface::DataType dataType =  mInput->dataType( bandNo ); 
  int pixelSize = mInput->typeSize( dataType ) / 8; 

  double noDataValue = mInput->noDataValue ( bandNo );

  for ( int i = 0; i < height; ++i )
  {
    for ( int j = 0; j < width; ++j )
    {
      int index = pixelSize * ( i * width + j );

      double value = readValue( rasterData, dataType, index );
  
      foreach ( NoData noData, mNoData )
      {
        if ( ( value >= noData.min && value <= noData.max ) ||
             doubleNear( value, noData.min ) ||
             doubleNear( value, noData.max ) )
        {
          writeValue( rasterData, dataType, index, noDataValue );
        }
      }
    }
  }

  return rasterData;
}
Esempio n. 12
0
void ConfigXml::readEntryElement(int *id)
{
    QString type = reader.attributes().value("type").toString();

    reader.readNext();
    while (!reader.atEnd()) {
        if (reader.isEndElement()) {
            reader.readNext();
            break;
        }

        if (reader.isStartElement()) {
            if (reader.name() == "entry") {
                readEntryElement(id);
            } else if (reader.name() == "value") {
                readValue(id, type);
            } else {
                skipUnknownElement();
            }
        } else {
            reader.readNext();
        }
    }
}
Esempio n. 13
0
size_t readInstructionFromBuffer(const char* buf, Instruction* instr)
{
	size_t nRead = 0;

	instr->iType = *buf;
	buf += 2; nRead += 2;

	int nCol = instr->table->nCol;
	if (instr->iType == SQLITE_UPDATE) {
		nCol *= 2;
	}

	for (int i=0; i < nCol; i++) {
		sqlite_value* val_p = instr->values + i;
		size_t read = readValue(buf, val_p);
		if (read == 0) {
			return 0;
		}
		buf += read;
		nRead += read;
	}

	return nRead;
}
Esempio n. 14
0
void VCalParser::readEvent()
{
	//qDebug() << "[calendar] reading event";
	//QTime time;

	QString key, val;
	TEvent event;

	//time.start();
	while( key != "END" && !atEnd ) {
		key = readKey();
		val = readValue();

		if( key == "UID" )				event.setUid(val);
		else if( key == "DESCRIPTION")  event.setDescription(val);
		else if( key == "SUMMARY")      event.setSummary(val);
		else if( key == "LOCATION")     event.setLocation(val);
		else if( key == "LAST-MODIFIED")event.setLastModified(decodeDate(val));
		else if( key == "CLASS")        event.setClass(val);
		else if( key == "STATUS")       event.setStatus(val);
		else if( key == "DTSTART" ||
				 key == "DTSTART;VALUE=DATE") {
			if( val.size() > 1 )		event.setStart(decodeDate(val));
		} else if( key == "DTEND" ||
				   key == "DTEND;VALUE=DATE") {
			if( val.size() > 1 )		event.setEnd(decodeDate(val));
		}

		// event is in the future
		if(event.getStart() > QDateTime::currentDateTime()) {
			if(event < nextEvent) nextEvent = event;
		}
	}

	m_events.append(event);
}
Esempio n. 15
0
bool 
Reader::parse( const char *beginDoc, const char *endDoc, 
               Value &root,
               bool collectComments )
{
   begin_ = beginDoc;
   end_ = endDoc;
   collectComments_ = collectComments;
   current_ = begin_;
   lastValueEnd_ = 0;
   lastValue_ = 0;
   commentsBefore_ = "";
   errors_.clear();
   while ( !nodes_.empty() )
      nodes_.pop();
   nodes_.push( &root );
   
   bool successful = readValue();
   Token token;
   skipCommentTokens( token );
   if ( collectComments_  &&  !commentsBefore_.empty() )
      root.setComment( commentsBefore_, commentAfter );
   return successful;
}
void MtpProperty::read(MtpDataPacket& packet) {
    mCode = packet.getUInt16();
    bool deviceProp = isDeviceProperty();
    mType = packet.getUInt16();
    mWriteable = (packet.getUInt8() == 1);
    switch (mType) {
        case MTP_TYPE_AINT8:
        case MTP_TYPE_AUINT8:
        case MTP_TYPE_AINT16:
        case MTP_TYPE_AUINT16:
        case MTP_TYPE_AINT32:
        case MTP_TYPE_AUINT32:
        case MTP_TYPE_AINT64:
        case MTP_TYPE_AUINT64:
        case MTP_TYPE_AINT128:
        case MTP_TYPE_AUINT128:
            mDefaultArrayValues = readArrayValues(packet, mDefaultArrayLength);
            if (deviceProp)
                mCurrentArrayValues = readArrayValues(packet, mCurrentArrayLength);
            break;
        default:
            readValue(packet, mDefaultValue);
            if (deviceProp)
                readValue(packet, mCurrentValue);
    }
    if (!deviceProp)
        mGroupCode = packet.getUInt32();
    mFormFlag = packet.getUInt8();

    if (mFormFlag == kFormRange) {
            readValue(packet, mMinimumValue);
            readValue(packet, mMaximumValue);
            readValue(packet, mStepSize);
    } else if (mFormFlag == kFormEnum) {
        mEnumLength = packet.getUInt16();
        mEnumValues = new MtpPropertyValue[mEnumLength];
        for (int i = 0; i < mEnumLength; i++)
            readValue(packet, mEnumValues[i]);
    }
}
Esempio n. 17
0
bool
SimpleProperties::Reader::next(){
  return readValue();
}
Esempio n. 18
0
int TestMain::readValue2(const int ver)
{
    const int def = readValue(ver, 0);
    log->log("value for %d = %d", ver, def);
    return def;
}
Esempio n. 19
0
int main(int argc, char *argv[])
{

	char mdesc[2][MAXLEN] = {"#Motordescription (text)",""};
	char pdesc[2][MAXLEN] = {"#Propellerdescription (text)",""};
	char psdesc[2][MAXLEN] = {"#size [in] (eg. 8x4)",""};
	char wbdesc[2][MAXLEN] = {"#weight battery [kg]",""};
	char wrvdesc[2][MAXLEN] = {"#weight receiver + voltmeter [kg]",""};
	char wmspdesc[2][MAXLEN] = {"#weight motor + speedcontroller + propeller [kg]",""};
	char wcdesc[2][MAXLEN] = {"#weight camera [kg]",""};
	char wfdesc[2][MAXLEN] = {"#weight fuselage (center piece) [kg]",""};
	char wadesc[2][MAXLEN] = {"#weight arms [kg]",""};
	char wtdesc[2][MAXLEN] = {"#weight tilt mechanism + servo [kg]",""};
	char again[MAXLEN];
	double bsize;
	double I;
	double m[7];
	double mges;
	int n;
	int nmax;

	if (argc < 2) {
		fprintf(stderr, "Fehlender Dateiname! Aufruf des Programms:\ncopter.exe data.txt\n");
		exit(1);
	}


	readFile(argv[1], mdesc[0], mdesc[1]);

	readFile(argv[1], pdesc[0], pdesc[1]);

	readFile(argv[1], psdesc[0], psdesc[1]);

	readFile(argv[1], wbdesc[0], wbdesc[1]);
	m[0] = readValue(wbdesc[1]);

	readFile(argv[1], wrvdesc[0], wrvdesc[1]);
	m[1] = readValue(wrvdesc[1]);

	readFile(argv[1], wmspdesc[0], wmspdesc[1]);
	m[2] = readValue(wmspdesc[1]);

	readFile(argv[1], wcdesc[0], wcdesc[1]);
	m[3] = readValue(wcdesc[1]);

	readFile(argv[1], wfdesc[0], wfdesc[1]);
	m[4] = readValue(wfdesc[1]);

	readFile(argv[1], wadesc[0], wadesc[1]);
	m[5] = readValue(wadesc[1]);

	readFile(argv[1], wtdesc[0], wtdesc[1]);
	m[6] = readValue(wtdesc[1]);


	while(1) {
		nmax = scanInt("\nMaximale Motorenanzahl: ");
		bsize = scanDouble("Akkukapazitaet [mAh]:");
		printf("\n");		
			printf("Anzahl | I(ges) | m(ges) | Schwebeflugdauer\n");			
			printf("-------------------------------------------\n");
		for ( n = 1; n <= nmax; n++ ) {
			if ( (n % 2) != 0) {

				mges = m[0] + m[1] + n * (m[2] + m[5]) + m[3] + m[4] + 1 * m[6];
			}
			else {

				mges = m[0] + m[1] + n * (m[2] + m[5]) + m[3] + m[4] + 0 * m[6];
			}	

			I = copter_funktion(1,argv[1], mges/n);

			printf("%6d |%6.1lfA |%6.0lfg |\t%5.1lfmin\n", n, I*n,  mges*1000, ((0.8 * (bsize / 1000)) / (I*n) ) * 60 );			
		};

		scanString("\nNochmal? (j/n) : ", again, MAXLEN);
		if (strcasecmp(again, "n") == 0)
			exit(1);
	}

	return 0;
}
Esempio n. 20
0
unsigned short PhotoresistorSensor::readValue()
{
	return readValue(true);
}
Esempio n. 21
0
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
                  UA_ReadResponse *response) {
    if(request->nodesToReadSize <= 0) {
        response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
        return;
    }

    if(request->timestampsToReturn > 3){
    	response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
    	return;
    }

    size_t size = request->nodesToReadSize;

    response->results = UA_Array_new(&UA_TYPES[UA_TYPES_DATAVALUE], size);
    if(!response->results) {
        response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
        return;
    }

    response->resultsSize = size;

    if(request->maxAge < 0) {
    	response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
        return;
    }

    /* ### Begin External Namespaces */
    UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
    UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
    UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
    for(UA_Int32 j = 0;j<server->externalNamespacesSize;j++) {
        size_t indexSize = 0;
        for(size_t i = 0;i < size;i++) {
            if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
                continue;
            isExternal[i] = UA_TRUE;
            indices[indexSize] = i;
            indexSize++;
        }
        if(indexSize == 0)
            continue;
        UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
        ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
                       indices, indexSize, response->results, UA_FALSE, response->diagnosticInfos);
    }
    /* ### End External Namespaces */

    for(size_t i = 0;i < size;i++) {
        if(!isExternal[i])
            readValue(server, request->timestampsToReturn, &request->nodesToRead[i], &response->results[i]);
    }

#ifdef EXTENSION_STATELESS
    if(session==&anonymousSession){
		/* expiry header */
		UA_ExtensionObject additionalHeader;
		UA_ExtensionObject_init(&additionalHeader);
		additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;

		UA_Variant variant;
		UA_Variant_init(&variant);
		variant.type = &UA_TYPES[UA_TYPES_DATETIME];
		variant.arrayLength = request->nodesToReadSize;

		UA_DateTime* expireArray = UA_NULL;
		expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
		variant.data = expireArray;

		UA_ByteString str;
		UA_ByteString_init(&str);

		/*expires in 20 seconds*/
		for(UA_Int32 i = 0;i < response->resultsSize;i++) {
			expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
		}
		size_t offset = 0;
		str.data = UA_malloc(UA_Variant_calcSizeBinary(&variant));
		str.length = UA_Variant_calcSizeBinary(&variant);
		UA_Variant_encodeBinary(&variant, &str, &offset);
		additionalHeader.body = str;
		response->responseHeader.additionalHeader = additionalHeader;
    }
#endif
}
asynStatus daedataDriver::readInt32(asynUser *pasynUser, epicsInt32 *value)
{
	return readValue(pasynUser, "readInt32", value);
}
Esempio n. 23
0
static void miniShell()
{
	static bool inMiniShell = false;
	
	// Stop if the user didn't ask for the minishell
	if (inMiniShell || Serial.available()==0)
	{
		//DbgPrintf("<No commands>");
		return;
	}

	// If the command was not for a shell, exit
	unsigned char cmd = readValue();
	if(cmd != SHELL_REQUESTED)
	{
		DbgPrintf("<error>Unknown command %i</error>", cmd);
		return;
	}
	else
		DbgPrintf("<ret v=\"OK\" />");
	
	inMiniShell = true;

	// Enter the miniShell
	while(true)
	{
		// Get the command
		unsigned char cmd = readValue();
		if(cmd == DIGITAL_READ)
		{
			unsigned char pin = readValue();
			int pin_val = digitalRead(pin);
			const char* ret = (pin_val==HIGH?"HIGH":"LOW");
			DbgPrintf("<ret v=\"%s\"/>", ret);
		}
		else if(cmd == DIGITAL_WRITE)
		{
			unsigned char pin = readValue();
			unsigned char value = readValue();
			digitalWrite(pin, value==1?HIGH:LOW);
			DbgPrintf("<ret v=\"OK\"/>");
		}
		else if(cmd == ANALOG_READ)
		{
			unsigned char pin = readValue();
			int pin_val = analogRead(pin);
			DbgPrintf("<ret v=\"%i\"/>", pin_val);
		}
		else if(cmd == ANALOG_WRITE)
		{
			unsigned char pin = readValue();
			unsigned char value = readValue();
			analogWrite(pin, value);
			DbgPrintf("<ret v=\"OK\"/>");
		}
		else if(cmd == PIN_MODE)
		{
			unsigned char pin = readValue();
			unsigned char mode = readValue();
			pinMode(pin, mode==1?OUTPUT:INPUT);
			DbgPrintf("<ret v=\"OK\"/>");
		}
		else if(cmd == VAR_WRITE)
		{
			DbgSendTrace("Will read string");
			char* frameName=readString();
			char* varName=readString();
			char* value=readString();
			DbgSendTrace("frame=%s, varName=%s, value=%s", frameName, varName, value);
			free(frameName);
			free(varName);
			free(value);
			
			DbgPrintf("<ret v=\"OK\"/>");
		}
		else if(cmd == EXIT_SHELL)
		{
			DbgPrintf("<ret v=\"OK\"/>");
			break;
		}
		else
		{
			DbgPrintf("<error>Unknown command %i</error>", cmd);

			//Empty the input buffer
			while (Serial.available()>0)
				Serial.read();

			// Leave the minishell
			break;
		}
	}
	
	inMiniShell = false;
}
Esempio n. 24
0
File: config.c Progetto: K1N62/Rhino
int parseConfig(configuration *config)
{
  FILE *configFile;
  char buffert[PATH_MAX], realPathBuff[PATH_MAX];
  char *line = NULL;
  char value[256] = {'\0'};
  size_t  lineIndex = 0, len = sizeof(value);

  sprintf(buffert, "%s/%s", config->rootDir, config->configPath);
  realpath(buffert, realPathBuff);

  if ((configFile = fopen(realPathBuff, "r")) == NULL) {
    printf("CRITICAL: Unable to open config file %s, %s\n", config->accLogPath, strerror(errno));
    return -1;
  }

  while( getline(&line, &len, configFile) != EOF )
  {
    lineIndex = 0;
    // Ignore spaces
    while (line[lineIndex] == ' ')
      lineIndex++;

    // Ignore commented and empty lines
    if( line[lineIndex] != '#' && line[lineIndex] != '\n' )
    {
      // Parse the line
      if (startsWith("Servername", line + lineIndex))
      {
        // Move pass variable name
        lineIndex += strlen("Servername:");

        readValue(lineIndex, line, value, sizeof(value));

        // Check if value is an valid ip address
        if (isValidIpAddress(value))
        {
          strncpy(config->servername,  value, BUF_CFG);
        }
        // Otherwise check if it's an valid domain name and resolve it
        else if(hostnameToIp(value))
        {
          strncpy(config->servername,  value, BUF_CFG);
        }
        // Else this is not a valid config
        else
          printf("Invalid config, hostname\n");

      }
      else if (startsWith("Listen", line + lineIndex))
      {
        int  port = 0;

        // Move pass variable name
        lineIndex += strlen("Listen:");

        readValue(lineIndex, line, value, sizeof(value));

        // Check if valid port number
        if((port = atoi(value)) != 0 && port < 65536)
        {
          config->listenPort = port;
        }
        // Else invalid
        else
        {
          printf("Invalid config, port\n");
        }
      }
      else if (startsWith("Basedir", line + lineIndex))
      {
        // Move pass variable name
        lineIndex += strlen("Basedir:");

        readValue(lineIndex, line, value, sizeof(value));

        // relative the root dir
        sprintf(buffert, "%s/%s", config->rootDir, value);

        // Get the realpath
        if(realpath(buffert, realPathBuff) == NULL){
          printf("Invalid config, basedirectory: %s, %s\n", realPathBuff, strerror(errno));
          exit(-1);
        }

        // Change basedirectory to the realpath
        strncpy(config->basedir, realPathBuff, BUF_CFG);
      }
      else if (startsWith("Method", line + lineIndex))
      {
        // Move pass variable name
        lineIndex += strlen("Method:");

        readValue(lineIndex, line, value, sizeof(value));

        // If selected logging method is to a file
        if((strcmp(value, "file")) == 0)
        {
          config->syslog = false;

          if (startsWith("Access_logpath", line + lineIndex))
          {
            // Move pass variable name
            lineIndex += strlen("Access_logpath:");

            readValue(lineIndex, line, value, sizeof(value));

            // relative the root dir
            sprintf(buffert, "%s/%s", config->rootDir, value);

            // Get the realpath
            realpath(buffert, realPathBuff);

            // Change accLogPath to the realpath
            strncpy(config->accLogPath, realPathBuff, BUF_CFG);
          }
          else if (startsWith("Server_logpath", line + lineIndex))
          {
            // Move pass variable name
            lineIndex += strlen("Server_logpath:");

            readValue(lineIndex, line, value, sizeof(value));

            // relative the root dir
            sprintf(buffert, "%s/%s", config->rootDir, value);

            // Get the realpath
            realpath(buffert, realPathBuff);

            // Change srvLogPath to the realpath
            strncpy(config->srvLogPath, realPathBuff, BUF_CFG);
          }
        }
      }
      else if (startsWith("Fifo_path", line + lineIndex))
      {
        // Move pass variable name
        lineIndex += strlen("Fifo_path:");

        readValue(lineIndex, line, value, sizeof(value));

        // relative the root dir
        sprintf(buffert, "%s/%s", config->rootDir, value);

        // Get the realpath
        realpath(buffert, realPathBuff);

        // Change srvLogPath to the realpath
        strncpy(config->fifoPath, realPathBuff, BUF_CFG);
      }
    }
  }

  fclose(configFile);
  return 0;
}
	private: void loadDataFromFile(){
		string str;
		int year, month, day, hour, minute, sec, msec;
		double Bx, By, Bz, Vx, Vy, Vz, rho, T;

		int start_time_in_sec = readStartTime();

		ifstream f(td->getSwDataFilePath().c_str());
		while(!f.eof()){
			getline(f, str);
			if(str == "") continue;

			//Format: Year Month Day Hour Min Sec Msec Bx[nT] By[nT] Bz[nT] Vx[km/s] Vy[km/s] Vz[km/s] N[cm^(-3)] T[Kelvin]

			year = Utils::getIntFromString(readValue(str));
			month = Utils::getIntFromString(readValue(str));
			day = Utils::getIntFromString(readValue(str));
			hour = Utils::getIntFromString(readValue(str));
			minute = Utils::getIntFromString(readValue(str));
			sec = Utils::getIntFromString(readValue(str));
			msec = Utils::getIntFromString(readValue(str));

			Bx = Utils::getDoubleFromString(readValue(str)) * 1.0e-5;
			By = Utils::getDoubleFromString(readValue(str)) * 1.0e-5;
			Bz = Utils::getDoubleFromString(readValue(str)) * 1.0e-5;
			Vx = Utils::getDoubleFromString(readValue(str)) * 1.0e+5;
			Vy = Utils::getDoubleFromString(readValue(str)) * 1.0e+5;
			Vz = Utils::getDoubleFromString(readValue(str)) * 1.0e+5;
			rho = Utils::getDoubleFromString(readValue(str)) * Constants::mp;
			T = Utils::getDoubleFromString(readValue(str));

			int time_in_sec = 3600*24*day + 3600 * hour + 60 * minute + sec - start_time_in_sec;

			vector<double> p(9);
			p[0] = time_in_sec;
			p[1] = rho;
			p[2] = Vx;
			p[3] = Vy;
			p[4] = Vz;
			p[5] = T;
			p[6] = Bx;
			p[7] = By;
			p[8] = Bz;

			swData.push_back(p);
		}
		f.close();
	}
Esempio n. 26
0
void ClientSocket::onReadyRead()
{
    if (!m_socket) {
        SOCKET_LOG("Cannot read message from client. Socket is already deleted.");
        return;
    }

    const qint64 available = m_socket->bytesAvailable();
    m_message.append( m_socket->read(available) );

    while ( !m_message.isEmpty() ) {
        if (!m_hasMessageLength) {
            const int preambleSize = headerDataSize() + streamDataSize(m_messageLength);
            if ( m_message.length() < preambleSize )
                break;

            {
                QDataStream stream(m_message);
                stream.setVersion(QDataStream::Qt_5_0);
                quint32 magicNumber;
                quint32 version;
                stream >> magicNumber >> version >> m_messageLength;
                if ( stream.status() != QDataStream::Ok ) {
                    error("Failed to read message length from client!");
                    return;
                }

                if (magicNumber != protocolMagicNumber) {
                    error("Unexpected message magic number from client!");
                    return;
                }

                if (version != protocolVersion) {
                    error("Unexpected message version from client!");
                    return;
                }
            }

            m_message.remove(0, preambleSize);
            m_hasMessageLength = true;

            if (m_messageLength > bigMessageThreshold)
                COPYQ_LOG( QString("Receiving big message: %1 MiB").arg(m_messageLength / 1024 / 1024) );
        }

        const auto length = static_cast<int>(m_messageLength);
        if ( m_message.length() < length )
            break;

        QByteArray msg = m_message.mid(0, length);
        qint32 messageCode;

        if ( !readValue(&messageCode, &msg) ) {
            error("Failed to read message code from client!");
            return;
        }

        m_hasMessageLength = false;
        m_message = m_message.mid(length);

        emit messageReceived(msg, messageCode, id());
    }
}
Esempio n. 27
0
// read object at file pos
bool
CJson::
readObject(CStrParse &parse, Object *&obj)
{
  if (! parse.isChar('{'))
    return false;

  bool open = false;

  parse.skipChar();

  obj = createObject();

  while (! parse.eof()) {
    parse.skipSpace();

    if (parse.isChar('}'))
      break;

    std::string name;

    if (! readString(parse, name)) {
      delete obj;
      return false;
    }

    parse.skipSpace();

    if (! parse.isChar(':')) {
      delete obj;
      return false;
    }

    parse.skipChar();

    parse.skipSpace();

    ValueP value;

    if (! readValue(parse, value)) {
      delete obj;
      return false;
    }

    value->setParent(obj);

    parse.skipSpace();

    obj->setNamedValue(name, value);

    open = false;

    if (! parse.isChar(','))
      break;

    parse.skipChar();

    open = true;
  }

  if (open) {
    delete obj;
    return false;
  }

  if (! parse.isChar('}')) {
    delete obj;
    return false;
  }

  parse.skipChar();

  return true;
}
Esempio n. 28
0
daeElementRef
daeLIBXMLPlugin::startParse(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
	// The original parsing system would drop everything up to the first element open, usually <COLLADA>
	// This behavior will have to be replicated here till we have someplace to put the headers/comments

	int ret = xmlTextReaderRead(reader);
	if(ret != 1)
	{
		// empty or hit end of file
		return NULL;
	}
	  //printf("xmlTextReaderConstBaseUri is %s\n",xmlTextReaderConstBaseUri(reader));
	  //printf("xmlTextReaderConstNamespaceUri is %s\n",xmlTextReaderConstNamespaceUri(reader));
	  //printf("xmlTextReaderConstPrefix is %s\n",xmlTextReaderConstPrefix(reader));
	  //printf("xmlTextReaderName is %s\n",xmlTextReaderName(reader));

	// Process the current element
	// Skip over things we don't understand
	while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
	{
		ret = xmlTextReaderRead(reader);
		if(ret != 1)
			return(NULL);
	}

	// Create the element that we found
	daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
	if(!element)
	{
		char err[256];
		memset( err, 0, 256 );
		const xmlChar * mine =xmlTextReaderConstName(reader);
#if LIBXML_VERSION >= 20620
		sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
		sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
		daeErrorHandler::get()->handleWarning( err );
		xmlTextReaderNext(reader);
		return NULL;
	}
	int currentDepth = xmlTextReaderDepth(reader);

	//try and read attributes
	readAttributes( element, reader );

	//Check COLLADA Version
	if ( strcmp( element->getTypeName(), "COLLADA" ) != 0 ) {
		//invalid root
		daeErrorHandler::get()->handleError("Loading document with invalid root element!");
		return NULL;
	}
	daeURI *xmlns = (daeURI*)(element->getMeta()->getMetaAttribute( "xmlns" )->getWritableMemory( element ));
	if ( strcmp( xmlns->getURI(), COLLADA_NAMESPACE ) != 0 ) {
		//invalid COLLADA version
		daeErrorHandler::get()->handleError("Trying to load an invalid COLLADA version for this DOM build!");
		return NULL;
	}

	
	ret = xmlTextReaderRead(reader);
	// If we're out of data, return the element
	if(ret != 1)
		return(element);

	// Read all the tags that are part of this tag
	bool trew = true;
	while(trew)
	{
		int thisType = xmlTextReaderNodeType(reader);
		if(thisType == XML_READER_TYPE_ELEMENT)
		{
			// Is the new element at the same depth as this one?
			if(currentDepth == xmlTextReaderDepth(reader))
			{
				// Same depth means the current element ended in a /> so this is a sibling
				// so we return and let our parent process it.
				return(element);
			}
			else
			{
				// The element is a child of this one, so we recurse
				if(!element->placeElement(nextElement(element->getMeta(), reader)))
				{
					char err[256];
					memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
				sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
				sprintf(err,"placeElement failed\n");
#endif
				daeErrorHandler::get()->handleWarning(err);
				ret = xmlTextReaderRead(reader);
				if ( ret != 1 ) {
					return element;
				}
				}
			}
		}
		else if(thisType == XML_READER_TYPE_TEXT)
		{
			readValue( element, reader );
		}
		else if(thisType == XML_READER_TYPE_END_ELEMENT)
		{
			// Done with this element so read again and return
			ret = xmlTextReaderRead(reader);
			return(element);
		}
		else
		{	// Skip element types we don't care about
			ret = xmlTextReaderRead(reader);
			// If we're out of data, return the element
			if(ret != 1)
				return(element);
		}
	}
	// Return NULL on an error
	return NULL;
}
Esempio n. 29
0
daeElementRef
daeLIBXMLPlugin::nextElement(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
	int ret;
	// Process the current element
	// Skip over things we don't understand
	while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
	{
		ret = xmlTextReaderRead(reader);
		if(ret != 1)
			return(NULL);
	}

	// Create the element that we found
	daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
	if(!element)
	{
		const xmlChar * mine =xmlTextReaderConstName(reader);
		char err[256];
		memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
		sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
		sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
		daeErrorHandler::get()->handleWarning( err );
		if ( xmlTextReaderNext(reader) == -1 ) {
			int x = 12312412;
		}
		return NULL;
	}
	int currentDepth = xmlTextReaderDepth(reader);

	//try and read attributes
	readAttributes( element, reader );
	
	ret = xmlTextReaderRead(reader);
	// If we're out of data, return the element
	if(ret != 1)
		return(element);

	// Read all the tags that are part of this tag
	bool trew = true;
	while(trew)
	{
		int thisType = xmlTextReaderNodeType(reader);
		if(thisType == XML_READER_TYPE_ELEMENT)
		{
			// Is the new element at the same depth as this one?
			if(currentDepth == xmlTextReaderDepth(reader))
			{
				// Same depth means the current element ended in a /> so this is a sibling
				// so we return and let our parent process it.
				return(element);
			}
			else
			{
				// The element is a child of this one, so we recurse
				if(!element->placeElement(nextElement(element->getMeta(), reader)))
				{
					char err[256];
					memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
				sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
				sprintf(err,"placeElement failed\n");
#endif
				daeErrorHandler::get()->handleWarning( err );
				ret = xmlTextReaderRead(reader);
				if ( ret != 1 ) {
					return element;
				}
				}
			}
		}
		else if(thisType == XML_READER_TYPE_TEXT)
		{
			readValue( element, reader );
		}
		else if(thisType == XML_READER_TYPE_END_ELEMENT)
		{
			// Done with this element so read again and return
			ret = xmlTextReaderRead(reader);
			return(element);
		}
		else
		{	// Skip element types we don't care about
			ret = xmlTextReaderRead(reader);
			// If we're out of data, return the element
			if(ret != 1)
				return(element);
		}
	}
	//program will never get here but this line is needed to supress a warning
	return NULL;
}
Esempio n. 30
0
bool 
SimpleProperties::Reader::first(){
  reset();
  m_itemLen = 0;
  return readValue();
}