uint8_t MultidropMaster::checkForResponses(uint32_t time) {
uint8_t b, i;
if (dontTimeout) {
timeoutTime = time + timeoutDuration;
}
dontTimeout = false;
// Received all responses
if (waitingOnNodes == 0) {
finishMessage();
return true;
}
// Get more responses
while (serial->available()) {
b = serial->read();
responseBuff[responseIndex] = b;
messageCRC = _crc16_update(messageCRC, b);
responseIndex++;
dontTimeout = true;
// Have we received all the data for this node?
if (responseIndex % dataLength == 0) {
waitingOnNodes--;
}
}
// Node timeout, send default response
if (time > timeoutTime) {
// It's possible the node sent a partial response, so send whatever is left
for (i = responseIndex % dataLength; i < dataLength; i++) {
sendByte(defaultResponseValues[i], true);
responseBuff[responseIndex] = defaultResponseValues[i];
responseIndex++;
}
dontTimeout = true;
waitingOnNodes--;
}
if (waitingOnNodes == 0) {
finishMessage();
return true;
}
return false;
}
void HttpClient::onRequest(Http::Client& client)
{
try
{
Pt::Http::MessageProgress progress = client.endSend();
if( ! progress.finished() )
{
client.beginSend(false);
return;
}
while( ! advanceMessage() )
{
if(client.request().buffer().size() > 8192)
{
client.beginSend(false);
return;
}
}
finishMessage();
client.beginReceive();
}
catch(const System::IOError&) // HttpError is also an IOError
{
// setError() makes finishResult() call onError() where we throw
setError();
finishResult();
}
}
void HttpClient::onCall()
{
// prepare HTTP request
_client.request().clear();
_client.request().header().set("Content-Type", "text/xml");
_client.request().setMethod("POST");
std::ostream& os = _client.request().body();
// format XML-RPC request
beginMessage(os);
while( ! advanceMessage() )
{
if(_client.request().buffer().size() > 8192)
{
_client.send(false);
}
}
finishMessage();
// send HTTP request and start receiving HTTP reply
_client.send(true);
std::istream& is = _client.receive();
// parse XML-RPC reply
Client::processResult(is);
// discard remaining data
std::streamsize all = std::numeric_limits<std::streamsize>::max();
is.ignore(all);
}
void PdBase::sendMessage(const std::string& dest, const std::string& msg, const List& list) {
PdContext& context = PdContext::instance();
if(context.bMsgInProgress) {
cerr << "Pd: Can not send message, message in progress" << endl;
return;
}
_LOCK();
libpd_start_message(list.len());
_UNLOCK();
context.bMsgInProgress = true;
// step through list
for(int i = 0; i < list.len(); ++i) {
if(list.isFloat(i))
addFloat(list.getFloat(i));
else if(list.isSymbol(i))
addSymbol(list.getSymbol(i));
}
finishMessage(dest, msg);
}
void HttpClient::onInvoke()
{
// prepare HTTP request
_client.request().clear();
_client.request().header().set("Content-Type", "text/xml");
_client.request().setMethod("POST");
std::ostream& os = _client.request().body();
// format XML-RPC request
beginMessage(os);
while( ! advanceMessage() )
{
if(_client.request().buffer().size() > 8192)
{
_client.beginSend(false);
return;
}
}
finishMessage();
_client.beginReceive();
}
PdBase& PdBase::operator<<(const FinishMessage& var) {
finishMessage(var.dest, var.msg);
return *this;
}
Error QTar::extract()
{
//ifstream ofstream to seekg()
QArchive::extract();
if(!exists()) return Archive::OpenError;
char buff[Header::RecordSize];
//QFile outFile;
//FILE* f;
size_t bytes_read;
unsigned int filesize;
#if ARCREADER_QT4
if(!open(QIODevice::ReadOnly)) {
error();
#else
if(open(IO_ReadOnly)) {
qDebug("open error");
#endif //ARCREADER_QT4
return Archive::OpenError;
}
Q_D(QArchive);
for (;;) {
#if ARCREADER_QT4
bytes_read = read(buff,Header::RecordSize);
#else
bytes_read = readBlock(buff,Header::RecordSize);
#endif //ARCREADER_QT4
//put them here
emit byteProcessed(d->processedSize+=Header::RecordSize);
d->current_fileName=QFileInfo(buff).fileName();
if (bytes_read < Header::RecordSize) {
fprintf(stderr,"Short read. expected 512, got %d\n", bytes_read);
return Archive::ReadError;
}
if (isEndBuff(buff)) {
#if USE_SLOT
emit byteProcessed(d->processedSize+=Header::RecordSize); //header;
#else
estimate();
progressHandler->Progress(d->current_fileName, d->size, d->processedSize+=Header::RecordSize, d->totalSize, d->speed, d->elapsed, d->left);
#endif
finishMessage();
return End;
}
if (!verifyChecksum(buff)) {
fprintf(stderr, "Checksum failure\n");
return ChecksumError;
}
switch (buff[156]) {
case Header::LinkFlag::kLink : printf(" Ignoring hardlink %s\n", buff); break;
case Header::LinkFlag::kSymbolicLink : printf(" Ignoring symlink %s\n", buff); break; /////////////////////////
case Header::LinkFlag::kCharacter: printf(" Ignoring character device %s\n", buff); break;
case Header::LinkFlag::kBlock: printf(" Ignoring block device %s\n", buff); break;
case Header::LinkFlag::kDirectory:
createDir(QString::fromLocal8Bit(buff), parseOct(buff + 100, 8));
filesize = 0;
break;
case Header::LinkFlag::kFIFO: printf(" Ignoring FIFO %s\n", buff); break;
default:
createFile(QString::fromLocal8Bit(buff), parseOct(buff + 100, 8));
break;
}
++d->numFiles;
filesize = parseOct(buff + 124, 12);
d->size = filesize;
#if USE_SLOT
updateMessage();
#endif
while (filesize > 0) {
checkTryPause();
#if ARCREADER_QT4
bytes_read = read(buff,Header::RecordSize);
#else
bytes_read = readBlock(buff,Header::RecordSize);
#endif //ARCREADER_QT4
if (bytes_read < Header::RecordSize) {
fprintf(stderr,"Short read. Expected 512, got %d\n",bytes_read);
return Archive::ReadError;
}
if (filesize < Header::RecordSize) bytes_read = filesize;
if (d->outFile.isOpen()) {
#if CONFIG_QT4
if(d->outFile.write(buff,bytes_read)!=bytes_read) {
fprintf(stderr, "[%s] %s @%d: Failed to write %s\n",__FILE__,__PRETTY_FUNCTION__,__LINE__,qPrintable(d->outFile.fileName()));
#else
if(d->outFile.writeBlock(buff,bytes_read)!=bytes_read) {
fprintf(stderr, "[%s] %s @%d: Failed to write %s\n",__FILE__,__PRETTY_FUNCTION__,__LINE__,qPrintable(d->outFile.name()));
#endif
d->outFile.close();
}
/*if (fwrite(buff, 1, bytes_read, f)!= bytes_read) {
fprintf(stderr, "Failed write\n");
fclose(f);
f = NULL;
}*/
}
#if USE_SLOT
forceShowMessage(1000);
emit byteProcessed(d->processedSize+=Header::RecordSize);//bytes_read);
#else
estimate();
progressHandler->Progress(d->current_fileName, d->size, d->processedSize+=Header::RecordSize, d->totalSize, d->speed, d->elapsed, d->left);
#endif
filesize -= bytes_read;
}
//emit byteProcessed(processedSize+=size);
if(d->outFile.isOpen()) d->outFile.close();
}
close();
}
Archive::Error QTar::extract(const QString& archive,const QString& dir)
{
setArchive(archive);
setOutDir(dir);
return extract();
}
void MultidropMaster::resetAllNodes() {
startMessage(CMD_RESET, BROADCAST_ADDRESS);
finishMessage();
}
MultidropMaster::adr_state_t MultidropMaster::checkForAddresses(uint32_t time) {
uint8_t b;
if (dontTimeout) {
timeoutTime = time + addrTimeoutDuration;
}
dontTimeout = false;
if (state != ADDRESSING) return ADR_DONE;
// If master's prev daisy chain is HIGH, then the network has gone full circle
if (isPrevDaisyEnabled() == 1) {
finishMessage();
return ADR_DONE;
}
// Receive next address
if (serial->available()) {
dontTimeout = true; // skip timing out next call
while (serial->available()) {
b = serial->read();
}
// Verify it's 1 larger than the last address and send confirmation
if (b == lastAddressReceived + 1) {
nodeNum++;
lastAddressReceived = b;
nodeAddressTries = 0;
sendByte(b, true);
}
// Invalid address
else {
// Max tries, end in error
nodeAddressTries++;
if (nodeAddressTries > MD_MASTER_ADDR_MAX_TRIES) {
return ADR_ERROR;
}
// Send last valid address again
else {
serial->enable_write();
sendByte(0x00);
sendByte(lastAddressReceived);
serial->enable_read();
}
}
return ADR_WAITING;
}
// Node timeout, finish
if (time > timeoutTime) {
finishMessage();
if (nodeNum > 0) {
return ADR_DONE;
} else {
return ADR_ERROR;
}
}
// Max nodes
if (lastAddressReceived == 255) {
finishMessage();
return ADR_DONE;
}
return ADR_WAITING;
}
