Example #1
0
QString Transfer::statusString() const {
    switch (status()) {
    case Paused:
        return tr("Paused");
    case Canceled:
        return tr("Canceled");
    case Failed:
        return tr("Failed: %1").arg(errorString());
    case Completed:
        return tr("Completed");
    case Queued:
        return tr("Queued");
    case Connecting:
        return tr("Connecting");
    case Downloading:
        return tr("Downloading");
    case Uploading:
        return tr("Uploading");
    case ExecutingCustomCommand:
        return tr("Executing custom command");
    default:
        return QString();
    }
}
Example #2
0
bool AgarServer::setupNetworking()
{
    /****************Networking Setup*********************/

    //based on max number of players and threads we determine the number of
    //connections each thread manages
    int numPerThread = Config::gameMaxPlayers/Config::maxConnectionThreads;
    if(numPerThread == 0){
        numPerThread = 1;
    }

    for(int i=0;i<Config::maxConnectionThreads;i++){
        createAgarThread(numPerThread);
    }

    //listen on port 57488 for whatever reason
    if(!listen(QHostAddress::Any,port)){
        qCritical("Error listening: %s",errorString().toUtf8().constData());
        return false;
    }
    qDebug("Listening on %i.",port);

    return true;
}
Example #3
0
//====================================
// Constructor...
//------------------------------------
SaXImportSysp::SaXImportSysp (int section) {
	// .../
	//! An object of this type is used to create a SYSP based
	//! SaX import. Refering to the given section ID the correct
	//! sysp.pl options are set.
	// ----
	mOptions.append ((const char*)"-q");
	switch (section) { 
		case SYSP_MOUSE:
			mSectionName = "Mouse";
			mOptions.append ((const char*)"mouse"); 
		break;
		case SYSP_KEYBOARD:
			mSectionName = "Keyboard";
			mOptions.append ((const char*)"keyboard");
		break;
		case SYSP_CARD:
			mSectionName = "Card";
			mOptions.append ((const char*)"server");
		break;
		case SYSP_DESKTOP:
			mSectionName = "Desktop";
			mOptions.append ((const char*)"xstuff");
		break;
		case SYSP_3D:
			mSectionName = "3D";
			mOptions.append ((const char*)"3d");
		break;
		default:
			excImportSectionFailed();
			qError (errorString(),EXC_IMPORTSECTIONFAILED);
			mSectionName = "Undefined";
		break;
	}
	mSection = section;
}
void DialogNewCamera::listCameras(std::function<void(const QJsonArray &arr)> dataCb)
{
    QString url = listUrl;
    url += QStringLiteral("&_sid=%1").arg(apiSid);

    QUrl u(url);
    QNetworkRequest request(u);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

    auto reply = nm->get(request);
    connect(reply, &QNetworkReply::finished, [=]()
    {
        reply->deleteLater();
        if (reply->error() != QNetworkReply::NoError)
        {
            QMessageBox::warning(this, tr("Calaos Installer"), reply->errorString());
            dataCb({});
            return;
        }

        QByteArray bytes = reply->readAll();
        bool err;
        QJsonObject jdata = parseResult(bytes, err);

        if (err)
            QMessageBox::warning(this, tr("Calaos Installer"), tr("Failed to list cameras"));

        if (err || !jdata["cameras"].isArray())
        {
            dataCb({});
            return;
        }

        dataCb(jdata["cameras"].toArray());
    });
}
Example #5
0
// -------------------------------------------------------------------
StringArray
PosixRegEx::grep(const StringArray &src, int eflags)
{
	if( !compiled)
	{
		BLOCXX_THROW(RegExCompileException,
			"Regular expression is not compiled");
	}

	m_ecode = REG_NOERROR;
	m_error.erase();

	StringArray out;
	if( !src.empty())
	{
		StringArray::const_iterator i=src.begin();
		for( ; i != src.end(); ++i)
		{
			int ret = ::regexec(&m_regex, i->c_str(),
			                    0, NULL, eflags);
			if( ret == REG_NOERROR)
			{
				out.push_back(*i);
			}
			else if(ret != REG_NOMATCH)
			{
				m_ecode = ret;
				m_error = getError(&m_regex, m_ecode);
				BLOCXX_THROW_ERR(RegExExecuteException,
					errorString().c_str(), m_ecode);
			}
		}
	}

	return out;
}
/**
 * This function is used for activating the socket listener.
 * @param filename Full path to a file to be used as the socket.
 * @param perm Permissions to be used on the socket.
 * @return Returns true on success, otherwise returns an error.
 */
ReturnValue QtRpc::ServerProtocolListenerSocket::listen(QString filename, SocketPermission perm)
{
	//Remove old socket if it exists
	if (QFile::exists(filename))
	{
		if (!QFile::remove(filename))
		{
			qWarning() << "Unable to remove old socket file" << filename;
		}
	}

	//listen on the socket
	if (!QLocalServer::listen(filename))
	{
		//an error occured
		return(ReturnValue(1, errorString()));
	}

	//set up permissions
	switch (perm)
	{
		case Owner:
			QFile::setPermissions(filename, QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner);
			break;
		case Group:
			QFile::setPermissions(filename, QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner
			                      | QFile::ReadGroup | QFile::WriteGroup | QFile::ExeGroup);
			break;
		case Everyone:
			QFile::setPermissions(filename, QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner
			                      | QFile::ReadGroup | QFile::WriteGroup | QFile::ExeGroup
			                      | QFile::ReadOther | QFile::WriteOther | QFile::ExeOther);
			break;
	}
	return ReturnValue(true);
}
Example #7
0
//====================================
// addInputDevice
//------------------------------------
int SaXManipulateDevices::addInputDevice (const char* fashion) {
	// .../
	//! add a new input device at the end of the current input
	//! device list. The new input device ID is returned. pointer
	//! input devices are following the odd order (1,3,5,7...)
	//! whereas keyboard input devices use the even order (0,2,4,6...)
	// ----
	if (! inputHandlingAllowed) {
		return -1;
	}
	//====================================
	// check fashion string...
	//------------------------------------
	QString inputFashion (fashion);
	if (
		(inputFashion != SAX_INPUT_TOUCHPANEL) &&
		(inputFashion != SAX_INPUT_TABLET)     &&
		(inputFashion != SAX_INPUT_PEN)        &&
		(inputFashion != SAX_INPUT_ERASER)     &&
		(inputFashion != SAX_INPUT_MOUSE)      &&
		(inputFashion != SAX_INPUT_VNC)        &&
		(inputFashion != SAX_INPUT_KEYBOARD)
	) {
		excWrongInputFashion (fashion);
		qError (errorString(),EXC_WRONGINPUTFASHION);
		return -1;
	}
	//====================================
	// determine new input device ID...
	//------------------------------------
	QString baseID ("Mouse");
	QString baseDriver ("mouse");
	if (fashion == SAX_INPUT_VNC) {
		baseDriver = "rfbmouse";
	}
	QDict<QString>* data = mInput->getTablePointer (0);
	int newID = mInput->getCount (true) * 2 + 1;
	if ((data) && (! data->isEmpty())) {
		baseDriver ="kbd";
		if (fashion == SAX_INPUT_VNC) {
			baseDriver = "rfbkeyb";
		}
		baseID = "Keyboard";
		newID  = mInput->getCount (true) * 2;
	}
	if (! mInput -> addID (newID)) {
		return -1;
	}
	//====================================
	// add new input device section...
	//------------------------------------
	QString newIDstring;
	newIDstring.sprintf ("%d",newID);
	mInput -> setItem ("Identifier",baseID + "[" + newIDstring + "]");
	mInput -> setItem ("InputFashion",fashion);
	//====================================
	// set some defaults...
	//------------------------------------
	mInput -> setItem ("Driver",baseDriver);
	//====================================
	// update server layout
	//------------------------------------
	if (baseID == "Mouse") {
		QString inputDevice; QTextOStream (&inputDevice) 
			<< mLayout -> getItem ("InputDevice")
			<< ",Mouse[" << newIDstring << "]";
		mLayout -> setItem ("InputDevice",inputDevice);
	}
	if (baseID == "Keyboard") {
		QString inputDevice; QTextOStream (&inputDevice)
			<< mLayout -> getItem ("Keyboard")
			<< ",Keyboard[" << newIDstring << "]";
		mLayout -> setItem ("Keyboard",inputDevice);
	}
	return mInput -> getCurrentID();
}
Example #8
0
bool TSReader::read(Translator &translator)
{
    STRING(both);
    STRING(byte);
    STRING(comment);
    STRING(context);
    STRING(defaultcodec);
    STRING(encoding);
    STRING(extracomment);
    STRING(filename);
    STRING(id);
    STRING(language);
    STRING(line);
    STRING(location);
    STRING(message);
    STRING(name);
    STRING(numerus);
    STRING(numerusform);
    STRING(obsolete);
    STRING(oldcomment);
    STRING(oldsource);
    STRING(source);
    STRING(sourcelanguage);
    STRING(translation);
    STRING(translatorcomment);
    STRING(true);
    STRING(TS);
    STRING(type);
    STRING(unfinished);
    STRING(userdata);
    STRING(utf8);
    STRING(value);
    //STRING(version);
    STRING(yes);

    static const QString strextrans(QLatin1String("extra-"));
    static const QString strUtf8(QLatin1String("UTF-8"));

    while (!atEnd()) {
        readNext();
        if (isStartDocument()) {
            // <!DOCTYPE TS>
            //qDebug() << attributes();
        } else if (isEndDocument()) {
            // <!DOCTYPE TS>
            //qDebug() << attributes();
        } else if (isDTD()) {
            // <!DOCTYPE TS>
            //qDebug() << tokenString();
        } else if (elementStarts(strTS)) {
            // <TS>
            //qDebug() << "TS " << attributes();
            QHash<QString, int> currentLine;
            QString currentFile;

            QXmlStreamAttributes atts = attributes();
            //QString version = atts.value(strversion).toString();
            translator.setLanguageCode(atts.value(strlanguage).toString());
            translator.setSourceLanguageCode(atts.value(strsourcelanguage).toString());
            while (!atEnd()) {
                readNext();
                if (isEndElement()) {
                    // </TS> found, finish local loop
                    break;
                } else if (isWhiteSpace()) {
                    // ignore these, just whitespace
                } else if (elementStarts(strdefaultcodec)) {
                    // <defaultcodec>
                    const QString &codec = readElementText();
                    if (!codec.isEmpty())
                        translator.setCodecName(codec.toLatin1());
                    // </defaultcodec>
                } else if (isStartElement()
                        && name().toString().startsWith(strextrans)) {
                    // <extra-...>
                    QString tag = name().toString();
                    translator.setExtra(tag.mid(6), readContents());
                    // </extra-...>
                } else if (elementStarts(strcontext)) {
                    // <context>
                    QString context;
                    while (!atEnd()) {
                        readNext();
                        if (isEndElement()) {
                            // </context> found, finish local loop
                            break;
                        } else if (isWhiteSpace()) {
                            // ignore these, just whitespace
                        } else if (elementStarts(strname)) {
                            // <name>
                            context = readElementText();
                            // </name>
                        } else if (elementStarts(strmessage)) {
                            // <message>
                            TranslatorMessage::References refs;
                            QString currentMsgFile = currentFile;

                            TranslatorMessage msg;
                            msg.setId(attributes().value(strid).toString());
                            msg.setContext(context);
                            msg.setType(TranslatorMessage::Finished);
                            msg.setPlural(attributes().value(strnumerus) == stryes);
                            const QStringRef &utf8Attr = attributes().value(strutf8);
                            msg.setNonUtf8(utf8Attr == strboth);
                            msg.setUtf8(msg.isNonUtf8() || utf8Attr == strtrue
                                 ||  attributes().value(strencoding) == strUtf8);
                            while (!atEnd()) {
                                readNext();
                                if (isEndElement()) {
                                    // </message> found, finish local loop
                                    msg.setReferences(refs);
                                    translator.append(msg);
                                    break;
                                } else if (isWhiteSpace()) {
                                    // ignore these, just whitespace
                                } else if (elementStarts(strsource)) {
                                    // <source>...</source>
                                    msg.setSourceText(readContents());
                                } else if (elementStarts(stroldsource)) {
                                    // <oldsource>...</oldsource>
                                    msg.setOldSourceText(readContents());
                                } else if (elementStarts(stroldcomment)) {
                                    // <oldcomment>...</oldcomment>
                                    msg.setOldComment(readContents());
                                } else if (elementStarts(strextracomment)) {
                                    // <extracomment>...</extracomment>
                                    msg.setExtraComment(readContents());
                                } else if (elementStarts(strtranslatorcomment)) {
                                    // <translatorcomment>...</translatorcomment>
                                    msg.setTranslatorComment(readContents());
                                } else if (elementStarts(strlocation)) {
                                    // <location/>
                                    QXmlStreamAttributes atts = attributes();
                                    QString fileName = atts.value(strfilename).toString();
                                    if (fileName.isEmpty()) {
                                        fileName = currentMsgFile;
                                    } else {
                                        if (refs.isEmpty())
                                            currentFile = fileName;
                                        currentMsgFile = fileName;
                                    }
                                    const QString lin = atts.value(strline).toString();
                                    if (lin.isEmpty()) {
                                        translator.setLocationsType(Translator::RelativeLocations);
                                        refs.append(TranslatorMessage::Reference(fileName, -1));
                                    } else {
                                        bool bOK;
                                        int lineNo = lin.toInt(&bOK);
                                        if (bOK) {
                                            if (lin.startsWith(QLatin1Char('+')) || lin.startsWith(QLatin1Char('-'))) {
                                                lineNo = (currentLine[fileName] += lineNo);
                                                translator.setLocationsType(Translator::RelativeLocations);
                                            } else {
                                                translator.setLocationsType(Translator::AbsoluteLocations);
                                            }
                                            refs.append(TranslatorMessage::Reference(fileName, lineNo));
                                        }
                                    }
                                    readContents();
                                } else if (elementStarts(strcomment)) {
                                    // <comment>...</comment>
                                    msg.setComment(readContents());
                                } else if (elementStarts(struserdata)) {
                                    // <userdata>...</userdata>
                                    msg.setUserData(readContents());
                                } else if (elementStarts(strtranslation)) {
                                    // <translation>
                                    QXmlStreamAttributes atts = attributes();
                                    QStringRef type = atts.value(strtype);
                                    if (type == strunfinished)
                                        msg.setType(TranslatorMessage::Unfinished);
                                    else if (type == strobsolete)
                                        msg.setType(TranslatorMessage::Obsolete);
                                    if (msg.isPlural()) {
                                        QStringList translations;
                                        while (!atEnd()) {
                                            readNext();
                                            if (isEndElement()) {
                                                break;
                                            } else if (isWhiteSpace()) {
                                                // ignore these, just whitespace
                                            } else if (elementStarts(strnumerusform)) {
                                                translations.append(readTransContents());
                                            } else {
                                                handleError();
                                                break;
                                            }
                                        }
                                        msg.setTranslations(translations);
                                    } else {
                                        msg.setTranslation(readTransContents());
                                    }
                                    // </translation>
                                } else if (isStartElement()
                                        && name().toString().startsWith(strextrans)) {
                                    // <extra-...>
                                    QString tag = name().toString();
                                    msg.setExtra(tag.mid(6), readContents());
                                    // </extra-...>
                                } else {
                                    handleError();
                                }
                            }
                            // </message>
                        } else {
                            handleError();
                        }
                    }
                    // </context>
                } else {
                    handleError();
                }
            } // </TS>
        } else {
            handleError();
        }
    }
    if (hasError()) {
        m_cd.appendError(errorString());
        return false;
    }
    return true;
}
int main (int argc, char **argv) {
  std::string brokers = "localhost";
  std::string errstr;
  std::vector<std::string> topics;
  std::string conf_file;
  std::string mode = "P";
  int throughput = 0;
  int32_t partition = RdKafka::Topic::PARTITION_UA;
  bool do_conf_dump = false;
  MyHashPartitionerCb hash_partitioner;

  /*
   * Create configuration objects
   */
  RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
  RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);

  {
    char hostname[128];
    gethostname(hostname, sizeof(hostname)-1);
    conf->set("client.id", std::string("rdkafka@") + hostname, errstr);
  }

  conf->set("debug", "cgrp,topic", errstr);

  for (int i = 1 ; i < argc ; i++) {
    const char *name = argv[i];
    const char *val = i+1 < argc ? argv[i+1] : NULL;

    if (val && !strncmp(val, "--", 2))
      val = NULL;

    std::cout << now() << ": argument: " << name << " " <<
        (val?val:"") << std::endl;
    
    if (val) {
      if (!strcmp(name, "--topic"))
	topics.push_back(val);
      else if (!strcmp(name, "--broker-list"))
	brokers = val;
      else if (!strcmp(name, "--max-messages"))
	state.maxMessages = atoi(val);
      else if (!strcmp(name, "--throughput"))
	throughput = atoi(val);
      else if (!strcmp(name, "--producer.config") ||
	       !strcmp(name, "--consumer.config"))
	read_conf_file(val);
      else if (!strcmp(name, "--group-id"))
	conf->set("group.id", val, errstr);
      else if (!strcmp(name, "--session-timeout"))
	conf->set("session.timeout.ms", val, errstr);
      else if (!strcmp(name, "--reset-policy")) {
	if (tconf->set("auto.offset.reset", val, errstr)) {
	  std::cerr << now() << ": " << errstr << std::endl;
	  exit(1);
	}
      } else if (!strcmp(name, "--debug")) {
	conf->set("debug", val, errstr);
      } else {
	std::cerr << now() << ": Unknown option " << name << std::endl;
	exit(1);
      }

      i++;

    } else {
      if (!strcmp(name, "--consumer"))
	mode = "C";
      else if (!strcmp(name, "--producer"))
	mode = "P";
      else if (!strcmp(name, "--enable-autocommit")) {
	state.consumer.useAutoCommit = true;
	conf->set("enable.auto.commit", "true", errstr);
      } else {
	std::cerr << now() << ": Unknown option or missing argument to " << name << std::endl;
	exit(1);
      }
    }
  }

  if (topics.empty() || brokers.empty()) {
    std::cerr << now() << ": Missing --topic and --broker-list" << std::endl;
    exit(1);
  }


  /*
   * Set configuration properties
   */
  conf->set("metadata.broker.list", brokers, errstr);

  ExampleEventCb ex_event_cb;
  conf->set("event_cb", &ex_event_cb, errstr);

  if (do_conf_dump) {
    int pass;

    for (pass = 0 ; pass < 2 ; pass++) {
      std::list<std::string> *dump;
      if (pass == 0) {
        dump = conf->dump();
        std::cerr << now() << ": # Global config" << std::endl;
      } else {
        dump = tconf->dump();
        std::cerr << now() << ": # Topic config" << std::endl;
      }

      for (std::list<std::string>::iterator it = dump->begin();
           it != dump->end(); ) {
        std::cerr << *it << " = ";
        it++;
        std::cerr << *it << std::endl;
        it++;
      }
      std::cerr << std::endl;
    }
    exit(0);
  }

  signal(SIGINT, sigterm);
  signal(SIGTERM, sigterm);
  signal(SIGALRM,  sigwatchdog);


  if (mode == "P") {
    /*
     * Producer mode
     */

    ExampleDeliveryReportCb ex_dr_cb;

    /* Set delivery report callback */
    conf->set("dr_cb", &ex_dr_cb, errstr);

    /*
     * Create producer using accumulated global configuration.
     */
    RdKafka::Producer *producer = RdKafka::Producer::create(conf, errstr);
    if (!producer) {
      std::cerr << now() << ": Failed to create producer: " << errstr << std::endl;
      exit(1);
    }

    std::cerr << now() << ": % Created producer " << producer->name() << std::endl;

    /*
     * Create topic handle.
     */
    RdKafka::Topic *topic = RdKafka::Topic::create(producer, topics[0],
						   tconf, errstr);
    if (!topic) {
      std::cerr << now() << ": Failed to create topic: " << errstr << std::endl;
      exit(1);
    }

    static const int delay_us = throughput ? 1000000/throughput : 0;

    if (state.maxMessages == -1)
      state.maxMessages = 1000000; /* Avoid infinite produce */

    for (int i = 0 ; run && i < state.maxMessages ; i++) {
      /*
       * Produce message
       */
      std::ostringstream msg;
      msg << i;
      RdKafka::ErrorCode resp =
	producer->produce(topic, partition,
			  RdKafka::Producer::RK_MSG_COPY /* Copy payload */,
			  const_cast<char *>(msg.str().c_str()),
			  msg.str().size(), NULL, NULL);
      if (resp != RdKafka::ERR_NO_ERROR) {
	errorString("producer_send_error",
		    RdKafka::err2str(resp), topic->name(), NULL, msg.str());
	state.producer.numErr++;
      } else {
	std::cerr << now() << ": % Produced message (" <<
	  msg.str().size() << " bytes)" << std::endl;
	state.producer.numSent++;
      }

      producer->poll(delay_us / 1000);
      watchdog_kick();
    }
    run = true;

    while (run && producer->outq_len() > 0) {
      std::cerr << now() << ": Waiting for " << producer->outq_len() << std::endl;
      producer->poll(50);
      watchdog_kick();
    }

    std::cerr << now() << ": " << state.producer.numAcked << "/" <<
      state.producer.numSent << "/" << state.maxMessages <<
      " msgs acked/sent/max, " << state.producer.numErr <<
      " errored" << std::endl;

    delete topic;
    delete producer;


  } else if (mode == "C") {
    /*
     * Consumer mode
     */

    tconf->set("auto.offset.reset", "smallest", errstr);

    /* Set default topic config */
    conf->set("default_topic_conf", tconf, errstr);

    ExampleRebalanceCb ex_rebalance_cb;
    conf->set("rebalance_cb", &ex_rebalance_cb, errstr);

    ExampleOffsetCommitCb ex_offset_commit_cb;
    conf->set("offset_commit_cb", &ex_offset_commit_cb, errstr);


    /*
     * Create consumer using accumulated global configuration.
     */
    consumer = RdKafka::KafkaConsumer::create(conf, errstr);
    if (!consumer) {
      std::cerr << now() << ": Failed to create consumer: " <<
	errstr << std::endl;
      exit(1);
    }

    std::cerr << now() << ": % Created consumer " << consumer->name() <<
      std::endl;

    /*
     * Subscribe to topic(s)
     */
    RdKafka::ErrorCode resp = consumer->subscribe(topics);
    if (resp != RdKafka::ERR_NO_ERROR) {
      std::cerr << now() << ": Failed to subscribe to " << topics.size() << " topics: "
		<< RdKafka::err2str(resp) << std::endl;
      exit(1);
    }

    /*
     * Consume messages
     */
    while (run) {
      RdKafka::Message *msg = consumer->consume(500);
      msg_consume(consumer, msg, NULL);
      delete msg;
      watchdog_kick();
    }

    /* Final commit */
    do_commit(consumer, 1);

    /*
     * Stop consumer
     */
    consumer->close();

    delete consumer;
  }


  /*
   * Wait for RdKafka to decommission.
   * This is not strictly needed (when check outq_len() above), but
   * allows RdKafka to clean up all its resources before the application
   * exits so that memory profilers such as valgrind wont complain about
   * memory leaks.
   */
  RdKafka::wait_destroyed(5000);

  std::cerr << now() << ": EXITING WITH RETURN VALUE 0" << std::endl;
  return 0;
}
Example #10
0
void QMLManager::loadDivesWithValidCredentials()
{
	QString url;
	timestamp_t currentDiveTimestamp = selectedDiveTimestamp();
	if (getCloudURL(url)) {
		QString errorString(get_error_string());
		appendTextToLog(errorString);
		setStartPageText(RED_FONT + tr("Cloud storage error: %1").arg(errorString) + END_FONT);
		revertToNoCloudIfNeeded();
		return;
	}
	QByteArray fileNamePrt = QFile::encodeName(url);
	git_repository *git;
	const char *branch;
	int error;
	if (check_git_sha(fileNamePrt.data(), &git, &branch) == 0) {
		qDebug() << "local cache was current, no need to modify dive list";
		appendTextToLog("Cloud sync shows local cache was current");
		goto successful_exit;
	}
	appendTextToLog("Cloud sync brought newer data, reloading the dive list");

	clear_dive_file_data();
	if (git != dummy_git_repository) {
		appendTextToLog(QString("have repository and branch %1").arg(branch));
		error = git_load_dives(git, branch);
	} else {
		appendTextToLog(QString("didn't receive valid git repo, try again"));
		error = parse_file(fileNamePrt.data());
	}
	setAccessingCloud(-1);
	if (!error) {
		report_error("filename is now %s", fileNamePrt.data());
		const char *error_string = get_error_string();
		appendTextToLog(error_string);
		set_filename(fileNamePrt.data(), true);
	} else {
		report_error("failed to open file %s", fileNamePrt.data());
		QString errorString(get_error_string());
		appendTextToLog(errorString);
		revertToNoCloudIfNeeded();
		return;
	}
	consumeFinishedLoad(currentDiveTimestamp);

successful_exit:
	alreadySaving = false;
	setLoadFromCloud(true);
	// if we came from local storage mode, let's merge the local data into the local cache
	// for the remote data - which then later gets merged with the remote data if necessary
	if (oldStatus() == NOCLOUD) {
		git_storage_update_progress(false, "import dives from nocloud local storage");
		dive_table.preexisting = dive_table.nr;
		mergeLocalRepo();
		DiveListModel::instance()->clear();
		DiveListModel::instance()->addAllDives();
		appendTextToLog(QStringLiteral("%1 dives loaded after importing nocloud local storage").arg(dive_table.nr));
		saveChangesLocal();
		if (syncToCloud() == false) {
			appendTextToLog(QStringLiteral("taking things back offline now that storage is synced"));
			prefs.git_local_only = syncToCloud();
		}
	}
	setAccessingCloud(-1);
	// if we got here just for an initial connection to the cloud, reset to offline
	if (currentGitLocalOnly) {
		currentGitLocalOnly = false;
		prefs.git_local_only = true;
	}
	return;
}
QList<QCharsetMatch> QCharsetDetector::detectAll()
{
    Q_D(QCharsetDetector);
    clearError();
    // get list of matches from ICU:
    qint32 matchesFound;
    const UCharsetMatch **uCharsetMatch
        = ucsdet_detectAll(d->_uCharsetDetector, &matchesFound, &(d->_status));
    if(hasError()) {
        qWarning() << __PRETTY_FUNCTION__ << errorString();
        return QList<QCharsetMatch>();
    }
    // sometimes the number of matches found by ucsdet_detectAll()
    // maybe 0 (matchesFound == 0) but d->_status has no error. Do not
    // return here with an error if this happens because the fine
    // tuning below may add more matches.  Better check whether no
    // matches were found at all *after* the fine tuning.

    // fill list of matches into a QList<QCharsetMatch>:
    QList<QCharsetMatch> qCharsetMatchList;
    for (qint32 i = 0; i < matchesFound; ++i) {
        QCharsetMatch qCharsetMatch;
        qCharsetMatch.setName(
            QString::fromLatin1(ucsdet_getName(uCharsetMatch[i], &(d->_status))));
        if(hasError()) {
            qWarning() << __PRETTY_FUNCTION__ << errorString();
            return QList<QCharsetMatch>();
        }
        qCharsetMatch.setConfidence(
            static_cast<qint32>(ucsdet_getConfidence (uCharsetMatch[i], &(d->_status))));
        if(hasError()) {
            qWarning() << __PRETTY_FUNCTION__ << errorString();
            return QList<QCharsetMatch>();
        }
        qCharsetMatch.setLanguage(
            QString::fromLatin1(ucsdet_getLanguage(uCharsetMatch[i], &(d->_status))));
        if(hasError()) {
            qWarning() << __PRETTY_FUNCTION__ << errorString();
            return QList<QCharsetMatch>();
        }
        qCharsetMatchList << qCharsetMatch;
    }
    if(d->_allDetectableCharsets.isEmpty())
        getAllDetectableCharsets();
    // libicu sometimes does not detect single byte encodings at all
    // even if they can encode the input without error. This seems to
    // contradict the documentation on
    // http://icu-project.org/apiref/icu4c/ucsdet_8h.html which says:
    //
    //     A confidence value of ten does have a general meaning - it is
    //     used for charsets that can represent the input data, but for
    //     which there is no other indication that suggests that the
    //     charset is the correct one. Pure 7 bit ASCII data, for example,
    //     is compatible with a great many charsets, most of which will
    //     appear as possible matches with a confidence of 10.
    //
    // But if such a single byte encoding has been set as the declared
    // encoding, it should at least be tried, therefore add it here to
    // the list of matches with the confidence value of 10. If it
    // cannot encode the complete input, the iteration over the list
    // of matches will detect that and remove it again.
    if(!d->_declaredEncoding.isEmpty()
        && (d->_declaredEncoding.startsWith(QLatin1String("ISO-8859-"))
            || d->_declaredEncoding.startsWith(QLatin1String("windows-12"))
            || d->_declaredEncoding.startsWith(QLatin1String("KOI8"))))
            qCharsetMatchList << QCharsetMatch(d->_declaredEncoding, QString(), 10);
    // Similar as for declaredEncoding, when declaredLocale is used
    // and it is a locale where the legacy encoding is a single byte
    // encoding, it should at least be tried, therefore add the legacy
    // single byte encoding for the declared locale here.  If it
    // cannot encode the complete input, it will be removed again
    // later.  Multibyte encodings like Shift_JIS, EUC-JP, Big5,
    // etc. ...  do not need to be added, contrary to the single byte
    // encodings I could find no case where the matches returned by
    // libicu did omit a multibyte encoding when it should have been
    // included.
    if(!d->_declaredLocale.isEmpty()) {
        QString language = d->_declaredLocale.left(2);
        if(language ==  QLatin1String("ru")) {
            qCharsetMatchList << QCharsetMatch(QLatin1String("KOI8-R"), language, 10);
            qCharsetMatchList << QCharsetMatch(QLatin1String("windows-1251"), language, 10);
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-5"), language, 10);
        }
        else if(language == QLatin1String("tr"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-9"), language, 10);
        else if(language == QLatin1String("el"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-7"), language, 10);
        else if(language == QLatin1String("en")
                || language == QLatin1String("da")
                || language == QLatin1String("de")
                || language == QLatin1String("es")
                || language == QLatin1String("fi")
                || language == QLatin1String("fr")
                || language == QLatin1String("it")
                || language == QLatin1String("nl")
                || language == QLatin1String("no")
                || language == QLatin1String("nn")
                || language == QLatin1String("nb")
                || language == QLatin1String("pt")
                || language == QLatin1String("sv"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-1"), language, 10);
        else if(language == QLatin1String("cs")
                || language == QLatin1String("hu")
                || language == QLatin1String("pl")
                || language == QLatin1String("ro"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-1"), language, 10);
        else if(language == QLatin1String("ar")
                || language == QLatin1String("fa")
                || language == QLatin1String("ur"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-6"), language, 10);
        else if(language == QLatin1String("he"))
            qCharsetMatchList << QCharsetMatch(QLatin1String("ISO-8859-8"), language, 10);
    }
    // iterate over the detected matches and do some fine tuning:
    bool sortNeeded = false;
    qint32 koi8rConfidence = 0;
    qint32 iso88595Confidence = 0;
    qint32 windows1251Confidence = 0;
    QList<QCharsetMatch>::iterator it = qCharsetMatchList.begin();
    while(it != qCharsetMatchList.end()) {
        if((*it).name() == QLatin1String("KOI8-R"))
            koi8rConfidence += (*it).confidence();
        if((*it).name() == QLatin1String("ISO-8859-5"))
            iso88595Confidence += (*it).confidence();
        if((*it).name() == QLatin1String("windows-1251"))
            windows1251Confidence += (*it).confidence();
        if((*it).name() == QLatin1String("ISO-2022-JP")) {
            // non-Japanese text in ISO-2022-JP encoding is possible
            // but very unlikely:
            (*it).setLanguage(QLatin1String("ja"));
        }
        if((*it).name() == QLatin1String("UTF-8")
           && (*it).confidence() >= 80 && (*it).confidence() < 99) {
            // Actually libicu currently only returns confidence
            // values of 100, 80, 25, and 10 for UTF-8.  A value of 80
            // can mean two things:
            //
            // 1)  (hasBOM && numValid > numInvalid*10)
            // 2)  (numValid > 0 && numInvalid == 0)
            //
            // If it is case 1), the match will be removed anyway by
            // the check below which tests whether the complete input
            // can be encoded. I.e. we don’t need to care about this.
            //
            // If it is case 2) *and* the check below whether the
            // complete input can be encoded does not remove it, we
            // have valid UTF-8 and it is very unlikely that it is
            // anything else, therefore I think the confidence of 80
            // is too low and should be increased.
            // With a confidence of only 80, a longer ASCII text with
            // less than 4 UTF-8 characters will detect as ISO-8859-1
            // which is most certainly wrong.
            (*it).setConfidence(99);
            sortNeeded = true;
        }
        if(!d->_declaredEncoding.isEmpty()
           && (*it).name() == d->_declaredEncoding
           && (*it).confidence() == 10) {
            // A confidence value of 10 means the charset can
            // represent the input data, but there is no other
            // indication that suggests that the charset is the
            // correct one. But if the user has set this to be the
            // declared encoding, it should be preferred over the
            // other encodings which also got confidence 10 (there are
            // often many with confidence 10). Do not increase the
            // confidence too much though in order not to override
            // real evidence that the input does really use something
            // different than the declared encoding.
            (*it).setConfidence(40);
            sortNeeded = true;
        }
        if(!d->_declaredLocale.isEmpty()
           && d->_declaredLocale.startsWith((*it).language())
           && (*it).confidence() == 10) {
            // A confidence value of 10 means the charset can
            // represent the input data, but there is no other
            // indication that suggests that the charset is the
            // correct one. But if the detected language for this
            // charset matches the language declared by the user, this
            // charset should be preferred over the others which also
            // got confidence 10 (there are often many with confidence
            // 10). Do not increase the confidence too much though in
            // order not to override real evidence that the input does
            // really use something different than the declared
            // encoding.  Use a slightly lower value than for the
            // declared encoding. Setting the declared encoding
            // is more precise and should have somewhat higher priority
            if (d->_declaredLocale.startsWith(QLatin1String("ru"))) {
                // Treat the Russian setDeclaredLocale("ru") case a
                // bit different than the single byte encodings for
                // other languages: Only increase the weight of
                // Russian encodings if setDeclaredLocale("ru") has
                // been used if libicu has really detected the same
                // Russian encoding as well. libicu usually detects
                // these Russian encodings with very low confidences <
                // 10 for short input.  But if we are already pretty
                // sure that it is Russian because of
                // setDeclaredLocale("ru"), then these low confidences
                // detected by libicu seem to be useful to distinguish
                // between the different Russian legacy encodings.
                //
                // If the setDeclareLocale("ru") has been used, the
                // accumulated confidence for the Russian single byte
                // encoding is 10 (because of setDeclaredLocale("ru"))
                // plus whatever libicu has detected. If libicu has
                // not detected anything, the accumulated confidence
                // is exactly 10 here and there is no way to
                // distinguish between the Russian legacy
                // encodings. Therefore, don’t increase the confidence
                // if the accumulated confidence is not > 10.
                //
                // But if libicu has detected something with small
                // confidence, the accumulated confidence is 10 plus
                // something small. In that case, adding something
                // around 20 seems to work reasonably well.
                //
                // I add 20 to the confidence for KOI8-R and
                // ISO-8859-5 but 21 to the confidence for
                // windows-1251 to prefer windows-1251 a little bit
                // over ISO-8859-5.
                if((*it).name() == QLatin1String("KOI8-R")
                   && koi8rConfidence > 10 && koi8rConfidence < 30)
                    (*it).setConfidence(20 + koi8rConfidence);
                else if((*it).name() == QLatin1String("ISO-8859-5")
                   && iso88595Confidence > 10 && iso88595Confidence < 30)
                    (*it).setConfidence(20 + iso88595Confidence);
                else if((*it).name() == QLatin1String("windows-1251")
                   && windows1251Confidence > 10 && windows1251Confidence < 30)
                    (*it).setConfidence(21 + windows1251Confidence);
            }
            else if ((d->_declaredLocale.contains(QLatin1String("TW"))
                || d->_declaredLocale.contains(QLatin1String("HK"))
                || d->_declaredLocale.contains(QLatin1String("MO")))
               && (*it).name() == QLatin1String("Big5")) {
                 // Traditional Chinese, Big5 more likely
                (*it).setConfidence(39);
            }
            else if ((d->_declaredLocale.contains(QLatin1String("CN"))
                     || d->_declaredLocale.contains(QLatin1String("SG"))
                     || d->_declaredLocale == QLatin1String("zh"))
                    && (*it).name() == QLatin1String("GB18030")) {
                // Simplified Chinese, GB18030/GB2312 more likely.
                // Simplified Chinese is also assumed if only “zh”
                // is set. If the variant is unknown, simplified
                // Chinese seems a bit more likely. On top of that,
                // the settings application sets only “zh” for
                // simplified Chinese and the translations for
                // simplified Chinese are also in files like
                // “foo_zh.qm” which makes simplified Chinese more
                // likely when only “zh” is set on the device (see
                // also NB#242154).
                (*it).setConfidence(39);
            }
            else {
                (*it).setConfidence(38);
            }
            sortNeeded = true;
        }
        if(!d->_allDetectableCharsets.contains((*it).name())) {
            // remove matches for charsets not supported by QTextCodec
            // then it is probably some weird charset we cannot use anyway
            it = qCharsetMatchList.erase(it);
        }
        else {
            // test whether the complete input text can be encoded
            // using this match, if not remove the match
            clearError();
            text(*it);
            if(hasError()) {
                // qMailLog(Messaging) << __PRETTY_FUNCTION__
                //          << "removing match" << (*it).name()
                //          << "because it cannot encode the complete input"
                //          << errorString();
                it = qCharsetMatchList.erase(it);
                clearError();
            }
            else
                ++it;
        }
    }
    // sort the list of matches again if confidences have been changed:
    if(sortNeeded)
        std::sort(qCharsetMatchList.begin(), qCharsetMatchList.end(),
              std::greater<QCharsetMatch>());
    if(qCharsetMatchList.isEmpty()) {
        // is there any better status to describe this case?
        d->_status = U_CE_NOT_FOUND_ERROR;
        qWarning() << __PRETTY_FUNCTION__
                 << "number of matches found=0"
                 << errorString();
        return QList<QCharsetMatch>();
    }
    return qCharsetMatchList;
}
Example #12
0
void CL::check_error(const cl_int &err, const char * context) {
	if(err != CL_SUCCESS) {
		fprintf(stderr,"[OpenCL] %s: %s\n", context, errorString(err));
		util_abort();
	}
}
Example #13
0
// TODO: Instead of doing all in this slot, we should iteratively parse in readyRead(). This
// would allow us to be more asynchronous in processing while data is coming from the network,
// not all in one big blob at the end.
bool LsColJob::finished()
{
    qCInfo(lcLsColJob) << "LSCOL of" << reply()->request().url() << "FINISHED WITH STATUS"
                       << reply()->error()
                       << (reply()->error() == QNetworkReply::NoError ? QLatin1String("") : errorString());

    QString contentType = reply()->header(QNetworkRequest::ContentTypeHeader).toString();
    int httpCode = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
    if (httpCode == 207 && contentType.contains("application/xml; charset=utf-8")) {
        LsColXMLParser parser;
        connect(&parser, &LsColXMLParser::directoryListingSubfolders,
            this, &LsColJob::directoryListingSubfolders);
        connect(&parser, &LsColXMLParser::directoryListingIterated,
            this, &LsColJob::directoryListingIterated);
        connect(&parser, &LsColXMLParser::finishedWithError,
            this, &LsColJob::finishedWithError);
        connect(&parser, &LsColXMLParser::finishedWithoutError,
            this, &LsColJob::finishedWithoutError);

        QString expectedPath = reply()->request().url().path(); // something like "/owncloud/remote.php/webdav/folder"
        if (!parser.parse(reply()->readAll(), &_sizes, expectedPath)) {
            // XML parse error
            emit finishedWithError(reply());
        }
    } else if (httpCode == 207) {
        // wrong content type
        emit finishedWithError(reply());
    } else {
        // wrong HTTP code or any other network error
        emit finishedWithError(reply());
    }

    return true;
}
Example #14
0
bool MkColJob::finished()
{
    qCInfo(lcMkColJob) << "MKCOL of" << reply()->request().url() << "FINISHED WITH STATUS"
                       << reply()->error()
                       << (reply()->error() == QNetworkReply::NoError ? QLatin1String("") : errorString());

    emit finished(reply()->error());
    return true;
}
OpenNI2Interface::OpenNI2Interface(int inWidth, int inHeight, int fps)
 : width(inWidth),
   height(inHeight),
   fps(fps),
   initSuccessful(true)
{
    //Setup
    openni::Status rc = openni::STATUS_OK;

    const char * deviceURI = openni::ANY_DEVICE;

    rc = openni::OpenNI::initialize();

    std::string errorString(openni::OpenNI::getExtendedError());

    if(errorString.length() > 0)
    {
        errorText.append(errorString);
        initSuccessful = false;
    }
    else
    {
        rc = device.open(deviceURI);
        if (rc != openni::STATUS_OK)
        {
            errorText.append(openni::OpenNI::getExtendedError());
            openni::OpenNI::shutdown();
            initSuccessful = false;
        }
        else
        {
            openni::VideoMode depthMode;
            depthMode.setFps(fps);
            depthMode.setPixelFormat(openni::PIXEL_FORMAT_DEPTH_1_MM);
            depthMode.setResolution(width, height);

            openni::VideoMode colorMode;
            colorMode.setFps(fps);
            colorMode.setPixelFormat(openni::PIXEL_FORMAT_RGB888);
            colorMode.setResolution(width, height);

            rc = depthStream.create(device, openni::SENSOR_DEPTH);
            if (rc == openni::STATUS_OK)
            {
                depthStream.setVideoMode(depthMode);
                rc = depthStream.start();
                if (rc != openni::STATUS_OK)
                {
                    errorText.append(openni::OpenNI::getExtendedError());
                    depthStream.destroy();
                    initSuccessful = false;
                }
            }
            else
            {
                errorText.append(openni::OpenNI::getExtendedError());
                initSuccessful = false;
            }

            rc = rgbStream.create(device, openni::SENSOR_COLOR);
            if (rc == openni::STATUS_OK)
            {
                rgbStream.setVideoMode(colorMode);
                rc = rgbStream.start();
                if (rc != openni::STATUS_OK)
                {
                    errorText.append(openni::OpenNI::getExtendedError());
                    rgbStream.destroy();
                    initSuccessful = false;
                }
            }
            else
            {
                errorText.append(openni::OpenNI::getExtendedError());
                initSuccessful = false;
            }

            if (!depthStream.isValid() || !rgbStream.isValid())
            {
                errorText.append(openni::OpenNI::getExtendedError());
                openni::OpenNI::shutdown();
                initSuccessful = false;
            }

            if(initSuccessful)
            {
                //For printing out
                formatMap[openni::PIXEL_FORMAT_DEPTH_1_MM] = "1mm";
                formatMap[openni::PIXEL_FORMAT_DEPTH_100_UM] = "100um";
                formatMap[openni::PIXEL_FORMAT_SHIFT_9_2] = "Shift 9 2";
                formatMap[openni::PIXEL_FORMAT_SHIFT_9_3] = "Shift 9 3";

                formatMap[openni::PIXEL_FORMAT_RGB888] = "RGB888";
                formatMap[openni::PIXEL_FORMAT_YUV422] = "YUV422";
                formatMap[openni::PIXEL_FORMAT_GRAY8] = "GRAY8";
                formatMap[openni::PIXEL_FORMAT_GRAY16] = "GRAY16";
                formatMap[openni::PIXEL_FORMAT_JPEG] = "JPEG";

                assert(findMode(width, height, fps) && "Sorry, mode not supported!");

                latestDepthIndex.assignValue(-1);
                latestRgbIndex.assignValue(-1);

                for(int i = 0; i < numBuffers; i++)
                {
                    uint8_t * newImage = (uint8_t *)calloc(width * height * 3, sizeof(uint8_t));
                    rgbBuffers[i] = std::pair<uint8_t *, int64_t>(newImage, 0);
                }

                for(int i = 0; i < numBuffers; i++)
                {
                    uint8_t * newDepth = (uint8_t *)calloc(width * height * 2, sizeof(uint8_t));
                    uint8_t * newImage = (uint8_t *)calloc(width * height * 3, sizeof(uint8_t));
                    frameBuffers[i] = std::pair<std::pair<uint8_t *, uint8_t *>, int64_t>(std::pair<uint8_t *, uint8_t *>(newDepth, newImage), 0);
                }

                rgbCallback = new RGBCallback(lastRgbTime,
                                              latestRgbIndex,
                                              rgbBuffers);

                depthCallback = new DepthCallback(lastDepthTime,
                                                  latestDepthIndex,
                                                  latestRgbIndex,
                                                  rgbBuffers,
                                                  frameBuffers);

                depthStream.setMirroringEnabled(false);
                rgbStream.setMirroringEnabled(false);

                device.setDepthColorSyncEnabled(true);
                device.setImageRegistrationMode(openni::IMAGE_REGISTRATION_DEPTH_TO_COLOR);

                setAutoExposure(true);
                setAutoWhiteBalance(true);

                rgbStream.addNewFrameListener(rgbCallback);
                depthStream.addNewFrameListener(depthCallback);
            }
        }
    }
}
Example #16
0
int Audio::loadOggStream(Path path){

	int result;
    
	AudioSource* source=new AudioSource;

	source->type=AUDIO_OGG;
	source->filename=path;
	source->stream=true;

	ALenum error=alGetError();

	if(!(source->oggFile = fopen(path.getAbsolute().c_str(), "rb"))){
		console().write("Could not open Ogg file.");
		return -1;
	}

    if((result = ov_open(source->oggFile, &source->oggStream, NULL, 0)) < 0)
    {
        fclose(source->oggFile);
        
		console().write("Could not open Ogg stream. " + errorString(result));
		return -1;
    }

    source->vorbisInfo = ov_info(&source->oggStream, -1);
    source->vorbisComment = ov_comment(&source->oggStream, -1);

	source->freq = source->vorbisInfo->rate;

	if(source->vorbisInfo->channels == 1){
        source->format = AL_FORMAT_MONO16;
		source->stereo=false;
	}else{
        source->format = AL_FORMAT_STEREO16;
		source->stereo=true;
	}

	source->lengthSeconds=ov_time_total(&source->oggStream,-1);

	error=alGetError();
        
    alGenBuffers(2, source->buffers);
    alGenSources(1, &source->source);

	error=alGetError();
	
	if(error==AL_OUT_OF_MEMORY || error==AL_INVALID_VALUE){
		//there's not more resources for sources

		source->alSourceSet=false;
	}else if(error!=AL_NO_ERROR){
		return -1;
	}else{
		source->alSourceSet=true;
		alSources.pushBack(source->source);
		source->sourceIndex=sources.size()-1;
		alSourcePriority.pushBack(0);

		while(alSourceUsedBy.size()<=sources.size()){	//note, we haven't actually added this source to the sources list yet, thus the weird index
			alSourceUsedBy.pushBack();
		}
		alSourceUsedBy[alSources.size()-1]=sources.size();

		source->alSourceIndex=alSources.size()-1;
	}

	error=alGetError();

	if(error == AL_NO_ERROR){
		sources.pushBack(source);
		source->sourceIndex=sources.size()-1;
		return sources.size()-1;
	}else{
		logs().audio.write("[AudioObject] Error 2 loading file:"+source->filename.getRelative());
		console().write(String("audio wav error: error '")+String(alGetString(error))+"' loading file '"+source->filename.getRelative()+"'");
		return -1;
	}
}
Example #17
0
CL::CL() {
	cl_int err;

	std::vector<cl::Platform> platforms;
	if(cl::Platform::get(&platforms) == CL_INVALID_VALUE) {
		fprintf(stderr, "[OpenCL] No platforms available\n");
		util_abort();
	}

	platform_ = platforms[0]; //Just select the first platform

	std::string name, version, extensions;

	platform_.getInfo(CL_PLATFORM_NAME, &name);
	platform_.getInfo(CL_PLATFORM_VERSION, &version);
	platform_.getInfo(CL_PLATFORM_EXTENSIONS, &extensions);

	fprintf(verbose, "[OpenCL] Platform: %s %s\n"
	        "  Extensions: %s\n", name.c_str(), version.c_str() ,extensions.c_str());

#if defined (__APPLE__) || defined(MACOSX)
	CGLContextObj kCGLContext = CGLGetCurrentContext();
	CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
	cl_context_properties properties[] =
	{
		CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,
		0
	};
#elif defined WIN32
	HGLRC current_context = wglGetCurrentContext();
	HDC current_dc = wglGetCurrentDC();
	if(current_dc == NULL || current_context == NULL) {
		fprintf(stderr,"[OpenCL] No OpenGL context active\n");
		util_abort();
	}

	cl_context_properties properties[] = {
		CL_CONTEXT_PLATFORM, (cl_context_properties)platform_(),
		CL_WGL_HDC_KHR, (intptr_t) current_dc,
		CL_GL_CONTEXT_KHR, (intptr_t) current_context,
		0
	};

#else
	if(glXGetCurrentContext() == NULL) {
		fprintf(stderr, "[OpenCL] glXGetCurrentContex() return NULL. Make sure to create OpenGL context before create the CL-context\n");
		util_abort();
	}
	cl_context_properties properties[] =
	{
		CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
		CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
		CL_CONTEXT_PLATFORM, (cl_context_properties)(platform_)(),
		0
	};
#endif

	
	static CL_API_ENTRY cl_int (CL_API_CALL
	*clGetGLContextInfoKHR)(const cl_context_properties *properties,
														cl_gl_context_info param_name,
														size_t param_value_size,
														void *param_value,
														size_t *param_value_size_ret)=NULL;

	clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn) clGetExtensionFunctionAddress("clGetGLContextInfoKHR");

	cl_device_id devices[32];
	size_t deviceSize = 0;
	err = clGetGLContextInfoKHR(properties, 
									CL_DEVICES_FOR_GL_CONTEXT_KHR,
									32 * sizeof(cl_device_id), 
									devices, 
									&deviceSize);

	if(deviceSize == 0) {
		fprintf(stderr, "[OpenCL] Interop not possible\n");
		util_abort();
	}

	
	
	cl_bool image_support, available;
	size_t max_width, max_height;
	cl_uint num_cores, frequency;
	cl_device_type _type;
	std::string type;

	fprintf(verbose, "[OpenCL] Available devices: \n");

	for(int i=0; i< (deviceSize / sizeof(cl_device_id)); ++i) {
		cl::Device device(devices[i]);
		device.getInfo(CL_DEVICE_VENDOR, &name);
		device.getInfo(CL_DEVICE_VERSION, &version);
		device.getInfo(CL_DEVICE_EXTENSIONS, &extensions);
		device.getInfo(CL_DEVICE_AVAILABLE, &available);
		device.getInfo(CL_DEVICE_IMAGE_SUPPORT, &image_support);
		device.getInfo(CL_DEVICE_IMAGE2D_MAX_WIDTH, &max_width);
		device.getInfo(CL_DEVICE_IMAGE2D_MAX_HEIGHT, &max_height);
		device.getInfo( CL_DEVICE_MAX_COMPUTE_UNITS , &num_cores);
		device.getInfo(CL_DEVICE_MAX_CLOCK_FREQUENCY, &frequency);
		device.getInfo(CL_DEVICE_TYPE, &_type);

		switch(_type) {
			case CL_DEVICE_TYPE_GPU:
				type = "GPU";
				break;
			case CL_DEVICE_TYPE_CPU:
				type = "CPU";
				break;
			case CL_DEVICE_TYPE_ACCELERATOR:
				type =  "Accelerator";
				break;
		}

		fprintf(verbose, "[OpenCL] Device (%p): %s %s (%s)\n"
				"		Cores: %u, Frequency: %u MHz, Available: %s,"
				"		Image support: %s, max size: %lux%lu\n"
				"		Extensions: %s\n --- \n", (device)(),  name.c_str(), version.c_str(), type.c_str(), num_cores, frequency,available?"YES":"NO",image_support?"YES":"NO", max_width, max_height, extensions.c_str());
		devices_.push_back(device);
	}
	
	fprintf(verbose, "\n-------------------\n");

	cl_device_id device_id;


	context_ = cl::Context(devices_, properties, &CL::cl_error_callback, nullptr, &err);


	if(err != CL_SUCCESS) {
		fprintf(stderr, "[OpenCL] Failed to create context: %s\n", errorString(err));
		util_abort();
	}



	err = clGetGLContextInfoKHR(properties, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, sizeof(device_id), &device_id, NULL);
	if(err != CL_SUCCESS) {
		fprintf(stderr, "[OpenCL] Failed to get current device for context: %s\n", errorString(err));
		util_abort();
	}

	context_device_ = cl::Device(device_id);

	
	context_device_.getInfo(CL_DEVICE_VENDOR, &name);
	context_device_.getInfo(CL_DEVICE_VERSION, &version);
		fprintf(verbose, "[OpenCL] Context Device (%p): %s %s\n",(context_device_)(),  name.c_str(), version.c_str());

	queue_ = cl::CommandQueue(context_, context_device_, 0, &err);

	if(err != CL_SUCCESS) {
		fprintf(stderr, "[OpenCL] Failed to create a command queue: %s\n", errorString(err));
		util_abort();
	}
}
Example #18
0
bool PropfindJob::finished()
{
    qCInfo(lcPropfindJob) << "PROPFIND of" << reply()->request().url() << "FINISHED WITH STATUS"
                          << reply()->error()
                          << (reply()->error() == QNetworkReply::NoError ? QLatin1String("") : errorString());

    int http_result_code = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

    if (http_result_code == 207) {
        // Parse DAV response
        QXmlStreamReader reader(reply());
        reader.addExtraNamespaceDeclaration(QXmlStreamNamespaceDeclaration("d", "DAV:"));

        QVariantMap items;
        // introduced to nesting is ignored
        QStack<QString> curElement;

        while (!reader.atEnd()) {
            QXmlStreamReader::TokenType type = reader.readNext();
            if (type == QXmlStreamReader::StartElement) {
                if (!curElement.isEmpty() && curElement.top() == QLatin1String("prop")) {
                    items.insert(reader.name().toString(), reader.readElementText(QXmlStreamReader::SkipChildElements));
                } else {
                    curElement.push(reader.name().toString());
                }
            }
            if (type == QXmlStreamReader::EndElement) {
                if (curElement.top() == reader.name()) {
                    curElement.pop();
                }
            }
        }
        if (reader.hasError()) {
            qCWarning(lcPropfindJob) << "XML parser error: " << reader.errorString();
            emit finishedWithError(reply());
        } else {
            emit result(items);
        }
    } else {
        qCWarning(lcPropfindJob) << "*not* successful, http result code is" << http_result_code
                                 << (http_result_code == 302 ? reply()->header(QNetworkRequest::LocationHeader).toString() : QLatin1String(""));
        emit finishedWithError(reply());
    }
    return true;
}
void MainWindow::on_connectAction_triggered(bool connect)
{
    if(connect)
    {
        if(_serialPort->open(QIODevice::ReadWrite))
        {
            // TODO hardcoded settings
            if(!_serialPort->setRate(SerialPort::Rate115200) ||
                !_serialPort->setDataBits(SerialPort::Data8) ||
                !_serialPort->setParity(SerialPort::NoParity) ||
                !_serialPort->setFlowControl(SerialPort::NoFlowControl) ||
                !_serialPort->setStopBits(SerialPort::TwoStop))
            {
                _serialPort->close();
                QMessageBox::critical(this, "Logger", "Can't configure serial port, reason: " + errorString());
            }
        }
        else
        {
            QMessageBox::critical(this, "Logger", "Serial port connection failed, reason: " + errorString(), QMessageBox::Ok);
        }
    }
    else
    {
        _serialPort->close();
    }

    updateStatus();
}
Example #20
0
bool ProppatchJob::finished()
{
    qCInfo(lcProppatchJob) << "PROPPATCH of" << reply()->request().url() << "FINISHED WITH STATUS"
                           << reply()->error()
                           << (reply()->error() == QNetworkReply::NoError ? QLatin1String("") : errorString());

    int http_result_code = reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

    if (http_result_code == 207) {
        emit success();
    } else {
        qCWarning(lcProppatchJob) << "*not* successful, http result code is" << http_result_code
                                  << (http_result_code == 302 ? reply()->header(QNetworkRequest::LocationHeader).toString() : QLatin1String(""));
        emit finishedWithError();
    }
    return true;
}
Example #21
0
Map::Map(const QString &filename) :
    d(new MapPrivate)
{
    QFile file(filename);
    if (!file.open(QIODevice::ReadOnly))
    {
        setError(1, QString("Could not open %1 for reading: %2")
                       .arg(filename)
                       .arg(file.errorString())
        );
        return;
    }

    QByteArray rawJson = file.readAll();
    QJsonParseError error;
    QJsonDocument doc = QJsonDocument::fromJson(rawJson, &error);
    if (error.error != QJsonParseError::NoError) {
        setError(1, QString("Failed to load imagemap %1, error %2 on offset %3")
                    .arg(filename)
                    .arg(error.errorString())
                    .arg(error.offset));
        return;
    }

    QVariantMap result = doc.toVariant().toMap();
    if (result.isEmpty())
    {
        setError(1, QString("Empty Map %1").arg(filename));
        return;
    }

    QString basepath = QFileInfo(filename).absolutePath();

    QVariantMap imagemaps = result["images"].toMap();
    for (QVariantMap::iterator files = imagemaps.begin();
         files != imagemaps.end(); ++files)
    {
        QString filename = basepath + "/" + files.key() ;
        QVariantMap fileOpts = files.value().toMap();

        // Load the image container.
        Container* container;
        if (filename.endsWith(".svg"))
        {
            container = ContainerSVG::create(this, filename);
        }
        else
        {
            container = ContainerImage::create(this, filename);
        }

        if (errorCode() != 0)
        {
            setError(1, QString("Failed to load image %1: %2")
                            .arg(filename)
                            .arg(errorString()));
            return;
        }

        // Create the list of images.
        if (fileOpts.contains("full"))
        {
            QVariantMap value = fileOpts["full"].toMap();
            if (value.isEmpty())
            {
                wzLog(LOG_IM) << "Image" << filename << "is empty!";
            }
            else
            {
                Image myImage;

                // Add the first found image.
                myImage.type = FixedType;
                myImage.xPosition = 0;
                myImage.yPosition = 0;
                myImage.size = QSize(value.begin().value().toList()[0].toInt(),
                                     value.begin().value().toList()[1].toInt());
                myImage.container = container;

                d->m_images.insert(value.begin().key(), myImage);
            }
        }

        if (fileOpts.contains("fixed"))
        {
            QVariantMap value = fileOpts["fixed"].toMap();
            for (QVariantMap::iterator images = value.begin();
                 images != value.end(); ++images)
            {
                QVariantList imgdefList = images.value().toList();

                Image myImage;
                myImage.type = FixedType;
                myImage.xPosition = imgdefList[0].toInt();
                myImage.yPosition = imgdefList[1].toInt();
                myImage.size = QSize(imgdefList[2].toInt(),
                                     imgdefList[3].toInt());
                myImage.container = container;

                d->m_images.insert(images.key(), myImage);
            }
        }

        if (filename.endsWith(".svg") && fileOpts.contains("named"))
        {
            QVariantMap value = fileOpts["named"].toMap();
            for (QVariantMap::iterator images = value.begin();
                 images != value.end(); ++images)
            {
                Image myImage;
                myImage.type = NamedType;
                myImage.name = images.value().toString();
                myImage.container = container;

                d->m_images.insert(images.key(), myImage);
            }
        }

        if (fileOpts.contains("cache"))
        {
            container->setCache(fileOpts["cache"].toBool());
        }
    } // for files
}
Example #22
0
bool RequestEtagJob::finished()
{
    qCInfo(lcEtagJob) << "Request Etag of" << reply()->request().url() << "FINISHED WITH STATUS"
                      << reply()->error()
                      << (reply()->error() == QNetworkReply::NoError ? QLatin1String("") : errorString());

    if (reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 207) {
        // Parse DAV response
        QXmlStreamReader reader(reply());
        reader.addExtraNamespaceDeclaration(QXmlStreamNamespaceDeclaration("d", "DAV:"));
        QString etag;
        while (!reader.atEnd()) {
            QXmlStreamReader::TokenType type = reader.readNext();
            if (type == QXmlStreamReader::StartElement && reader.namespaceUri() == QLatin1String("DAV:")) {
                QString name = reader.name().toString();
                if (name == QLatin1String("getetag")) {
                    etag += reader.readElementText();
                }
            }
        }
        emit etagRetreived(etag);
    }
    return true;
}
Example #23
0
void QWSServerSocket::init(const QString &file)
{
#ifndef QT_NO_SXE
    QByteArray fn = file.toLocal8Bit();
    bool result = QUnixSocketServer::listen( fn );
    if ( !result )
    {
        QUnixSocketServer::ServerError err = serverError();
        switch ( err )
        {
            case InvalidPath:
                qWarning("QWSServerSocket:: invalid path %s", qPrintable(file));
                break;
            case ResourceError:
            case BindError:
            case ListenError:
                qWarning("QWSServerSocket:: could not listen on path %s", qPrintable(file));
                break;
            default:
                break;
        }
    }
#else
    int backlog = 16; //#####

// create socket
    int s = ::socket(PF_LOCAL, SOCK_STREAM, 0);
    if (s == -1) {
        perror("QWSServerSocket::init");
        qWarning("QWSServerSocket: unable to create socket.");
        return;
    }

    QByteArray fn = file.toLocal8Bit();
    unlink(fn.constData()); // doesn't have to succeed

    // bind socket
    struct sockaddr_un a;
    memset(&a, 0, sizeof(a));
    a.sun_family = PF_LOCAL;
    strncpy(a.sun_path, fn.constData(), sizeof(a.sun_path) - 1);
    int r = ::bind(s, (struct sockaddr*)&a, SUN_LEN(&a));
    if (r < 0) {
        perror("QWSServerSocket::init");
        qWarning("QWSServerSocket: could not bind to file %s", fn.constData());
        ::close(s);
        return;
    }

    if (chmod(fn.constData(), 0600) < 0) {
        perror("QWSServerSocket::init");
        qWarning("Could not set permissions of %s", fn.constData());
        ::close(s);
        return;
    }

    // listen
    if (::listen(s, backlog) == 0) {
        if (!setSocketDescriptor(s))
            qWarning( "QWSServerSocket could not set descriptor %d : %s", s, errorString().toLatin1().constData());
    } else {
        perror("QWSServerSocket::init");
        qWarning("QWSServerSocket: could not listen to file %s", fn.constData());
        ::close(s);
    }
#endif
}
Example #24
0
cHTTPTrackerServer::cHTTPTrackerServer(int port)
{
    if (!listen(QHostAddress::Any,port)){
        qCritical() << "http server start error: " << errorString();
    }
}
Example #25
0
void CNetSock::SockError(QAbstractSocket::SocketError err)
{
    ForceClose(errorString());
}
Example #26
0
// Initialization function for the OpenCL platform and all OpenCL resources
// required by this program.
void initOpenCL() {
    int errcode = 0;
    unsigned int i, j;
    cl_platform_id platformId;
    numDevices = 0;
    cl_device_id deviceIds[8];

    // Initialize the OpenCL platform itself
    clGetPlatformIDs(1, &platformId, NULL);
    clGetDeviceIDs(platformId, CL_DEVICE_TYPE_GPU, 8, &deviceIds[0], &numDevices);

    contexts = (cl_context **) calloc(sizeof(cl_context *), numDevices);
    commandQueues = (cl_command_queue **) calloc(sizeof(cl_command_queue*), numDevices);
    saxpyProgram = (cl_program **) calloc(sizeof(cl_program *), numDevices);

    globalWorkSize[0] = numberElems / (numDevices * numOverlap);


    input1 = (cl_mem **) calloc(sizeof(cl_mem *), numDevices);
    input2 = (cl_mem **) calloc(sizeof(cl_mem *), numDevices);
    output = (cl_mem **) calloc(sizeof(cl_mem *), numDevices);

    saxpyKernel = (cl_kernel **) calloc(sizeof(cl_kernel *), numDevices);

    // Create the resources for each GPU
    for(i = 0; i < numDevices; i++) {
        contexts[i] = (cl_context *) calloc(sizeof(cl_context), numOverlap);
        commandQueues[i] = (cl_command_queue *) calloc(sizeof(cl_command_queue), numOverlap);

        saxpyProgram[i] = (cl_program *) calloc(sizeof(cl_program), numOverlap);

        input1[i] = (cl_mem *) calloc(sizeof(cl_mem), numOverlap);
        input2[i] = (cl_mem *) calloc(sizeof(cl_mem), numOverlap);
        output[i] = (cl_mem *) calloc(sizeof(cl_mem), numOverlap);

        saxpyKernel[i] = (cl_kernel *) calloc(sizeof(cl_kernel), numDevices);

        // Create resources within each GPU
        for(j = 0; j < numOverlap; j++) {
            contexts[i][j] = clCreateContext(0, 1, &deviceIds[i], NULL, NULL, &errcode);

            // Create a command queue so that the host can issue orders to the device
            commandQueues[i][j] = clCreateCommandQueue(contexts[i][j], deviceIds[i], 0, &errcode);
            // Create buffer objects for X matrix
            input1[i][j] = clCreateBuffer(contexts[i][j], CL_MEM_READ_WRITE, sizeof(cl_float) * globalWorkSize[0], NULL, &errcode);
            if(errcode != 0) {
                std::cerr << "CreateBuffer (X): " << errorString(errcode) << std::endl;
            }
            // Create buffer objects for Y Matrix
            input2[i][j] = clCreateBuffer(contexts[i][j], CL_MEM_READ_WRITE, sizeof(cl_float) * globalWorkSize[0], NULL, &errcode);
            if(errcode != 0) {
                std::cerr << "CreateBuffer (Y): " << errorString(errcode) << std::endl;
            }
            // Create buffer objects for the output
            output[i][j] = clCreateBuffer(contexts[i][j], CL_MEM_READ_WRITE, sizeof(cl_float) * globalWorkSize[0], NULL, &errcode);
            if(errcode != 0) {
                std::cerr << "CreateBuffer (output): " << errorString(errcode) << std::endl;
            }

            // Load and build OpenCL kernels
            saxpyProgram[i][j] = programFromSource(kernelFile, contexts[i][j]);
            errcode = clBuildProgram(saxpyProgram[i][j], 0, NULL, NULL, NULL, NULL);
            if(errcode != 0) {
                char buildlog[16000];
                clGetProgramBuildInfo(saxpyProgram[i][j], deviceIds[i], CL_PROGRAM_BUILD_LOG, sizeof(buildlog), buildlog, NULL);
                std::cerr << "Error in clBuildProgram " << buildlog << std::endl;
                exit(1);
            }
            // Create the kernel object
            saxpyKernel[i][j] = clCreateKernel(saxpyProgram[i][j], "saxpy", &errcode);
            if(errcode != 0) {
                std::cerr << "Error creating kernel: " << errorString(errcode) << std::endl;
            }
        }
    }
}
 String Sound_Renderer_AL::errorString() {
   if(Sound_Renderer_AL::alGetError())
     return errorString(Sound_Renderer_AL::alGetError()());
   else
     return "OpenAL not initialized";
 }
Example #28
0
static int statDir(const char *file, struct stat *sb, uint64_t *winattr)
{
	WIN32_FIND_DATAW info_w; // window's file info
	WIN32_FIND_DATAA info_a; // window's file info

	// cache some common vars to make code more transparent
	DWORD *pdwFileAttributes;
	DWORD *pnFileSizeHigh;
	DWORD *pnFileSizeLow;
	DWORD *pdwReserved0;
	FILETIME *pftLastAccessTime;
	FILETIME *pftLastWriteTime;
	FILETIME *pftCreationTime;

	/* Oh, cool, another exception: Microsoft doesn't let us do 
	   FindFile operations on a Drive, so simply fake root attibutes. */
	if(file[1]==':' && !file[2])
	{
		time_t now=time(NULL);
		sb->st_mode=S_IFDIR;
		sb->st_mode|=S_IREAD|S_IEXEC|S_IWRITE;
		sb->st_ctime=now;
		sb->st_mtime=now;
		sb->st_atime=now;
		sb->st_rdev=0;
		return 0;
	}

	HANDLE h=INVALID_HANDLE_VALUE;

	// use unicode
	if(p_FindFirstFileW)
	{
		char *pwszBuf=sm_get_pool_memory(PM_FNAME);
		make_win32_path_UTF8_2_wchar(&pwszBuf, file);

		h=p_FindFirstFileW((LPCWSTR)pwszBuf, &info_w);
		sm_free_pool_memory(pwszBuf);

		pdwFileAttributes=&info_w.dwFileAttributes;
		pdwReserved0     =&info_w.dwReserved0;
		pnFileSizeHigh   =&info_w.nFileSizeHigh;
		pnFileSizeLow    =&info_w.nFileSizeLow;
		pftLastAccessTime=&info_w.ftLastAccessTime;
		pftLastWriteTime =&info_w.ftLastWriteTime;
		pftCreationTime  =&info_w.ftCreationTime;
		// use ASCII
	}
	else if (p_FindFirstFileA)
	{
		h=p_FindFirstFileA(file, &info_a);

		pdwFileAttributes=&info_a.dwFileAttributes;
		pdwReserved0     =&info_a.dwReserved0;
		pnFileSizeHigh   =&info_a.nFileSizeHigh;
		pnFileSizeLow    =&info_a.nFileSizeLow;
		pftLastAccessTime=&info_a.ftLastAccessTime;
		pftLastWriteTime =&info_a.ftLastWriteTime;
		pftCreationTime  =&info_a.ftCreationTime;
	}

	if(h==INVALID_HANDLE_VALUE)
	{
		const char *err = errorString();
		/* Note, in creating leading paths, it is normal that
		   the file does not exist. */
		LocalFree((void *)err);
		errno=b_errno_win32;
		return -1;
	}
	else
		FindClose(h);

	*winattr=(int64_t)*pdwFileAttributes;

	/* Graham says: all the following stuff seems rather complicated.
	   It is probably not all needed anymore, since I have added *winattr
	   above, which bacula did not do.
	   One reason for keeping it is that some of the values get converted
	   to unix-style permissions that show up in the long list
	   functionality.
	   I think I would prefer to remove it all at some point. */

	sb->st_mode = 0777;  // start with everything
	if(*pdwFileAttributes & FILE_ATTRIBUTE_READONLY)
		sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH);
	if(*pdwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
		sb->st_mode &= ~S_IRWXO; // remove everything for other
	if(*pdwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
		sb->st_mode |= S_ISVTX; // use sticky bit -> hidden
	sb->st_mode |= S_IFDIR;

	/* Store reparse/mount point info in st_rdev.  Note a
	   Win32 reparse point (junction point) is like a link
	   though it can have many properties (directory link,
	   soft link, hard link, HSM, ...
	   A mount point is a reparse point where another volume
	   is mounted, so it is like a Unix mount point (change of
	   filesystem).  */
	if(*pdwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
		sb->st_rdev=WIN32_MOUNT_POINT;
	else
		sb->st_rdev=0;

	if((*pdwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
	  && (*pdwReserved0 & IO_REPARSE_TAG_MOUNT_POINT))
	{
		sb->st_rdev=WIN32_MOUNT_POINT;
		/* Now to find out if the directory is a mount point or
		   a reparse point, we must do a song and a dance.
		   Explicitly open the file to read the reparse point, then
		   call DeviceIoControl to find out if it points to a Volume
		   or to a directory. */
		h=INVALID_HANDLE_VALUE;
		if(p_GetFileAttributesW)
		{
			char *pwszBuf=sm_get_pool_memory(PM_FNAME);
			make_win32_path_UTF8_2_wchar(&pwszBuf, file);
			if(p_CreateFileW)
			{
				h=CreateFileW((LPCWSTR)pwszBuf, GENERIC_READ,
					FILE_SHARE_READ, NULL, OPEN_EXISTING,
					FILE_FLAG_BACKUP_SEMANTICS
					| FILE_FLAG_OPEN_REPARSE_POINT,
					NULL);
			}
			sm_free_pool_memory(pwszBuf);
		}
		else if(p_GetFileAttributesA)
		{
			h=CreateFileA(file, GENERIC_READ,
				FILE_SHARE_READ, NULL, OPEN_EXISTING,
				FILE_FLAG_BACKUP_SEMANTICS
				| FILE_FLAG_OPEN_REPARSE_POINT,
				NULL);
		}
		if(h!=INVALID_HANDLE_VALUE)
		{
			char dummy[1000];
			REPARSE_DATA_BUFFER *rdb=(REPARSE_DATA_BUFFER *)dummy;
			rdb->ReparseTag=IO_REPARSE_TAG_MOUNT_POINT;
			DWORD bytes;
			bool ok;
			ok=DeviceIoControl(h, FSCTL_GET_REPARSE_POINT,
				NULL, 0, // in buffer, bytes
				(LPVOID)rdb,
				(DWORD)sizeof(dummy), // out buffer, btyes
				(LPDWORD)&bytes, (LPOVERLAPPED)0);
			if(ok)
			{
				char *utf8=sm_get_pool_memory(PM_NAME);
				wchar_2_UTF8(utf8, (wchar_t *)
				  rdb->SymbolicLinkReparseBuffer.PathBuffer);
				if(!strncasecmp(utf8, "\\??\\volume{", 11))
					sb->st_rdev=WIN32_MOUNT_POINT;
				else // Points to a directory so we ignore it. 
					sb->st_rdev=WIN32_JUNCTION_POINT;
				sm_free_pool_memory(utf8);
			}
			CloseHandle(h);
		}
	}
	sb->st_size=*pnFileSizeHigh;
	sb->st_size<<=32;
	sb->st_size|=*pnFileSizeLow;
	sb->st_blksize=4096;
	sb->st_blocks=(uint32_t)(sb->st_size+4095)/4096;

	sb->st_atime=cvt_ftime_to_utime(*pftLastAccessTime);
	sb->st_mtime=cvt_ftime_to_utime(*pftLastWriteTime);
	sb->st_ctime=cvt_ftime_to_utime(*pftCreationTime);

	return 0;
}
Example #29
0
//====================================
// removeInputDevice
//------------------------------------
int SaXManipulateDevices::removeInputDevice (int id) {
	// .../
	//! remove the input device of the given id (id) and return the
	//! previous input device id. The current input device id is set
	//! to this previous input device id. If the input device does
	//! not exist or the input device id is the core (0|1) mouse or
	//! keyboard the method will return (-1)
	// ----
	if (! inputHandlingAllowed) {
		return -1;
	}
	//====================================
	// don't allow removing the core entry   
	//------------------------------------
	if (id <= 1) {
		excInvalidArgument (id);
		qError (errorString(),EXC_INVALIDARGUMENT);
		return -1;
	}
	//====================================
	// remove input devices...
	//------------------------------------
	if (! mInput->delID (id)) {
		return -1;
	}
	//====================================
	// select previous input device
	//------------------------------------
	for (int i=1;i<=2;i++) {
		QDict<QString>* data = mInput->getTablePointer (i);
		if ((data) && (! data->isEmpty())) {
			mInput->setID (i);
			break;
		}
	}
	//====================================
	// check input device type
	//------------------------------------
	bool isMouse = true;
	QString baseItem ("InputDevice");
	QString baseID   ("Mouse");
	if (mInput->getCurrentID() % 2 == 0) {
		isMouse  = false;
		baseItem = "Keyboard";
		baseID   = "Keyboard";
	}
	//====================================
	// update server layout
	//------------------------------------
	QString result;
	QString IDstring;
	IDstring.sprintf ("%d",id);
	QString deviceList  = mLayout -> getItem (baseItem);
	QStringList optlist = QStringList::split ( ",", deviceList );
	for ( QStringList::Iterator
		in = optlist.begin(); in != optlist.end(); ++in
	) {
		QString item (*in);
		if (item == QString(baseID + "["+IDstring+"]")) {
			continue;
		}
		QRegExp identifier ("\\[(.+)\\]");
		int pos = identifier.search (item);
		if (pos >= 0) {
			int curID = identifier.cap(1).toInt();
			if ( curID > id ) {
				QString newMK;
				newMK.sprintf ("%s[%d],",baseID.ascii(),curID - 2);
				result.append ( newMK );
			} else {
				result.append (item+",");
			}
		}
	}
	result.remove (result.length()-1,result.length());
	mLayout -> setItem (baseItem,result);
	return mInput -> getCurrentID();
}
Example #30
0
void CGroupClient::errorHandler ( QAbstractSocket::SocketError socketError )
{
  CGroupCommunicator *comm = dynamic_cast<CGroupCommunicator *>( parent() );
  comm->errorInConnection(this, errorString() );
}