int Download::order() const
{
if (!package())
return 0;
return package()->downloads().indexOf(Qp::sharedFrom(this));
}
int send_pack(int sfd, char *src_mac, int ifindex, struct in_addr *src, struct in_addr *dst)
{
send_arping_t sbuf;
int ret;
struct sockaddr_ll to;
memset(&sbuf, 0, sizeof(send_arping_t));
package(sbuf.ehdr.h_dest, 0xFF, ETH_ALEN);
memcpy(sbuf.ehdr.h_source, src_mac, ETH_ALEN);
sbuf.ehdr.h_proto = htons(ETH_P_ARP);
sbuf.ahdr.ar_hrd = htons(ARPHRD_ETHER);
sbuf.ahdr.ar_pro = htons(ETH_P_IP);
sbuf.ahdr.ar_hln = ETH_ALEN;
sbuf.ahdr.ar_pln = 4;
sbuf.ahdr.ar_op = htons(ARPOP_REQUEST);
memcpy(sbuf.src_hw, src_mac, ETH_ALEN);
sbuf.src_ip = *src;
package(sbuf.dst_hw, 0xFF, ETH_ALEN);
sbuf.dst_ip = *dst;
package(sbuf.trailer, htons(0), sizeof(sbuf.trailer));
to.sll_family = AF_PACKET;
memcpy(to.sll_addr, sbuf.ehdr.h_dest, ETH_ALEN);
to.sll_halen = ETH_ALEN;
to.sll_ifindex = ifindex;
ret = sendto(sfd, &sbuf, sizeof(sbuf), 0, (struct sockaddr*)&to, sizeof(to));
if (ret != sizeof(sbuf)) {
perror("sendto:");
return -1;
}
return 0;
}
SErrorPackage PostgresErrorHandler::handle(const QSqlError &error)
{
// new row for relation "doms_persons" violates check constraint doms_persons_email_check
// insert or update on table "doms_pacients" violates foreign key constraint "doms_pacients_iddocument_fkey"
QString text = error.databaseText().toLower();
if ( text.contains("duplicate key") )
{
SErrorPackage package(error.number(), QObject::tr("Seems like pacients already exists"));
return package;
}
else if ( text.contains("syntax error") )
{
SErrorPackage package(error.number(), QObject::tr("You're trying to do an invalid action"));
return package;
}
SErrorPackage package(error.number(), QObject::tr("PostgresErrorHandler %1").arg(error.databaseText()));
// TODO: Analizar los textos!
return package;
}
docstring const get(string const & m) const
{
if (m.empty())
return from_ascii(m);
char * o = setlocale(LC_ALL, 0);
string old;
if (o)
old = o;
char * n = setlocale(LC_ALL, lang_.c_str());
if (!n)
// If we are unable to honour the request we just
// return what we got in.
return from_ascii(m);
errno = 0;
string const locale_dir = package().locale_dir().toFilesystemEncoding();
char const * c = bindtextdomain(PACKAGE, locale_dir.c_str());
int e = errno;
if (e) {
LYXERR(Debug::DEBUG, "Messages::get()" << '\n'
<< "Error code: " << errno << '\n'
<< "Lang, mess: " << lang_ << " " << m << '\n'
<< "Directory : " << package().locale_dir().absFileName() << '\n'
<< "Rtn value : " << c);
}
if (!bind_textdomain_codeset(PACKAGE, ucs4_codeset)) {
LYXERR(Debug::DEBUG, "Messages::get()" << '\n'
<< "Error code: " << errno << '\n'
<< "Codeset : " << ucs4_codeset << '\n');
}
textdomain(PACKAGE);
char const * tmp = m.c_str();
char const * msg = gettext(tmp);
docstring translated;
if (!msg) {
lyxerr << "Undefined result from gettext" << endl;
translated = from_ascii(tmp);
} else if (msg == tmp) {
//lyxerr << "Same as entered returned" << endl;
translated = from_ascii(tmp);
} else {
LYXERR(Debug::DEBUG, "We got a translation");
char_type const * ucs4 = reinterpret_cast<char_type const *>(msg);
translated = ucs4;
}
setlocale(LC_ALL, old.c_str());
return translated;
}
uint32_t boxIdFor(const std::vector<Type> &genericArguments) {
auto genericId = genericIds_.find(genericArguments);
if (genericId != genericIds_.end()) {
return genericId->second;
}
auto id = package()->app()->boxObjectVariableInformation().size();
genericIds_.emplace(genericArguments, id);
package()->app()->boxObjectVariableInformation().emplace_back();
// for (auto variable : instanceScope().map()) {
// variable.second.type().objectVariableRecords(variable.second.id(), &boxObjectVariableInformation_.back());
// }
// TODO: fix
return static_cast<uint32_t>(id);
}
void SMWServer::playerCreatesRoom(uint64_t playerID, const void* data)
{
if (!players.count(playerID))
return;
Player* player = &players[playerID];
if (player->currentRoomID || player->isPlaying)
return;
// input
NewRoomPackage pkg;
memcpy(&pkg, data, sizeof(NewRoomPackage));
// create
Room room(roomCreateID, pkg.name, pkg.password, player);
room.setGamemode(pkg.gamemodeID, pkg.gamemodeGoal);
rooms[roomCreateID] = room;
player->currentRoomID = roomCreateID;
player->isPlaying = false;
// output
NewRoomCreatedPackage package(roomCreateID);
player->sendData(&package, sizeof(NewRoomCreatedPackage));
log("New room by %s : {id: %d; name: %s; pw: %s}",
player->toString().c_str(), room.roomID, room.name, room.password);
roomCreateID++; // increase global ID
}
EXPORT_C void CSchSendTestUtils::ChangeMessageTimeL(TMsvId aMessage, TTime aTime)
{
iMsvEntry->SetEntryL(aMessage);
TMsvEntry entry = iMsvEntry->Entry();
iRTest<<entry.iDate<<aTime;
entry.iDate = aTime;
CMsvOperationWait* wait = CMsvOperationWait::NewLC();
wait->Start();
CMsvOperation* opert = iMsvEntry->ChangeL(entry, wait->iStatus);
CleanupStack::PushL(opert);
CActiveScheduler::Start(); // operation complete
entry = iMsvEntry->Entry();
iRTest<<entry.iDate;
TMsvLocalOperationProgress details;
TPckgC<TMsvLocalOperationProgress> package(details);
package.Set(opert->ProgressL());
if(wait->iStatus.Int()!=KErrNone)
User::Leave(wait->iStatus.Int());
//TInt err = package().iError;
//if(err != KErrNone);
// User::Leave(package().iError);
CleanupStack::PopAndDestroy(2);//opert, wait
}
// -----------------------------------------------------------------------------
// RDRMRightsClient::GetDomainROL
// Get domain rights object xml representation from the rdb
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC8* RDRMRightsClient::GetDomainROL( const TDesC8& aRoId )
{
DRMLOG( _L( "RDRMRightsClient::GetDomainROL" ) );
// Check the parameter.
if ( aRoId.Length() )
{
TInt size = 0;
TPckg<TInt> package( size );
// Call the server. Throw an exception in case of an error.
User::LeaveIfError(
SendReceive( DRMEngine::EGetDomainRO,
TIpcArgs( &package, &aRoId ) ) );
HBufC8* roData = HBufC8::NewMaxLC( size );
// Package 'object' into TPtr8.
TPtr8 objectPkg( const_cast< TUint8* >( roData->Ptr() ),
size,
size );
User::LeaveIfError(
SendReceive( DRMEngine::EGetPreparedData,
TIpcArgs( &objectPkg) ) );
CleanupStack::Pop( roData ); // roData
return roData;
}
User::Leave( KErrArgument );
// Never reached.
return NULL;
};
// -----------------------------------------------------------------------------
// RDRMRightsClient::GetDbEntryL
// Get a single RO from the server.
// -----------------------------------------------------------------------------
//
EXPORT_C CDRMPermission* RDRMRightsClient::GetDbEntryL( const TDesC8& aContentID,
const TDRMUniqueID& aUniqueID )
{
DRMLOG( _L( "RDRMRightsClient::GetDbEntryL" ) );
CDRMPermission* permission = NULL;
TInt size = 0;
TPckg<TInt> package( size );
TPtrC8 uid( reinterpret_cast< TUint8* >( const_cast< TDRMUniqueID* >(
&aUniqueID ) ), sizeof( TDRMUniqueID ) );
User::LeaveIfError( SendReceive( DRMEngine::EGetDbEntry,
TIpcArgs( &package, NULL, &uid, &aContentID ) ) );
HBufC8* rightsData = HBufC8::NewMaxLC( size );
TPtr8 objectPkg( const_cast< TUint8* >( rightsData->Ptr() ), size,
size );
User::LeaveIfError( SendReceive( DRMEngine::EGetPreparedData,
TIpcArgs( &objectPkg) ) );
permission = CDRMPermission::NewLC();
permission->ImportL( rightsData->Des() );
CleanupStack::Pop(); // permission
CleanupStack::PopAndDestroy(); // Rights data
DRMLOG( _L( "RDRMRightsClient::GetDbEntryL ok" ) );
return permission;
}
void PackageManager::uninstallMarkedPackages(bool simulate, bool autoremove)
{
#ifdef PACKAGEMANAGER_LOG
qDebug() << Q_FUNC_INFO << simulate << autoremove;
#endif
QList<Package*> packageList = m_installedPackagesModel->packageMarkings()->packagesMarked();
QStringList packageIDs;
if (packageList.count() == 0)
return;
foreach (Package *package, packageList) {
packageIDs << package->id();
}
PackageKit::Transaction *t = new PackageKit::Transaction(this);
m_packManContext.setUninstallPackagesTransaction(new TransactionWrapper(t, true, this));
connect(t, SIGNAL(package(QSharedPointer<PackageKit::Package>)),
this, SLOT(onPackage(QSharedPointer<PackageKit::Package>)));
connect(t, SIGNAL(finished(PackageKit::Transaction::Exit,uint)),
this, SLOT(onFinished(PackageKit::Transaction::Exit,uint)));
if (simulate) {
m_packagesToBeInstalled.clear();
m_packagesToBeUpdated.clear();
m_packagesToBeRemoved.clear();
// t->simulateRemovePackages(packagePtrList, autoremove);
} else {
t->removePackages(packageIDs, false, autoremove);
}
}
//protected
string IBroker::askIoTIp()
{
string iotIp = "";
IoTPackage package(this->protocolVersion, "0", "0", NULL);
TcpClient client(this->ManagerIp, this->ManagerServerPort, 1000);
std::vector<char>recvBuffer;
recvBuffer.reserve(1000);
client.Connect();
if (client.IsConnected)
{
client.SendData(&package.DataVectorForSending);
while (1)
{
client.RecviveData(&recvBuffer);
if (recvBuffer.size() > 0)
{
this->parseReceivedBuffer(&iotIp, &recvBuffer);
if (iotIp.size() > 0 && this->managerIoTIp.size() > 0)
break;
}
}
}
client.Disconnect();
return iotIp;
}
void UmlClass::import(QTextOStream & f, const QCString & indent) {
QCString s;
if (!isJavaExternal()) {
UmlArtifact * cp = associatedArtifact();
UmlPackage * pack = (UmlPackage *)
((cp != 0) ? (UmlItem *) cp : (UmlItem *) this)->package();
if ((s = pack->javaPackage()).isEmpty())
return;
QCString s2 = name();
UmlItem * p = this;
while ((p = p->parent())->kind() == aClass)
s2 = p->name() + dot + s2;
s += dot + s2;
}
else if ((s = package()->javaPackage()).isEmpty())
return;
else
s += dot + name();
if (! UmlArtifact::generated_one()->is_imported(s)) {
f << indent << "import " << s << ";\n";
UmlArtifact::generated_one()->imported(s);
}
}
//
// RTrkTcbCliSession::CloseFile()
//
// Closes data into the already opened file.
// @return KErrNone - if succesful
// Negative - if failed.
//
TInt RTrkTcbCliSession::CloseFile(const TTime& aTime)
{
TPckg<TTime> package(aTime);
TIpcArgs args(&package);
return SendReceive(ETrkTcbCmdCodeCloseFile, args);
}
// -----------------------------------------------------------------------------
// RRoapStorageClient::DeleteExpiredRIsL
// -----------------------------------------------------------------------------
//
EXPORT_C void Roap::RRoapStorageClient::DeleteExpiredRIsL( const TTime& aTime )
{
TPckg<TTime> package( aTime );
User::LeaveIfError( SendReceive( Roap::EDeleteExpiredRIs, TIpcArgs(
&package ) ) );
}
void
ScreenManager::update(float delta, const std::vector<Input::Event>& events)
{
ScreenManagerUpdatePackage package(this, get_current_screen(), delta, events);
ScreenManagerUpdatePackage* pp = &package;
ceu_out_go(&CEUapp, CEU_IN_SCREEN_MANAGER_UPDATE, &pp);
}
void OpenIGTLinkStreamer::receivedProbedefinition(QString not_used, ProbeDefinitionPtr probedef)
{
PackagePtr package(new Package());
package->mProbe = probedef;
if(mSender)
mSender->send(package);
}
// -----------------------------------------------------------------------------
// RoapStorageClient::SignL
// -----------------------------------------------------------------------------
//
EXPORT_C TInt Roap::RRoapStorageClient::RsaSignL(
const TDesC8& aHash,
HBufC8*& aSignature )
{
TInt size = 0;
TInt error = KErrNone;
TPckg<TInt> package( size );
if ( aHash.Length() )
{
error = SendReceive( Roap::ERsaSign, TIpcArgs( &package, &aHash ) );
User::LeaveIfError( error );
HBufC8* signature( HBufC8::NewMaxLC( size ) );
TPtr8
objectPkg( const_cast<TUint8*> ( signature->Ptr() ), size, size );
User::LeaveIfError( SendReceive( Roap::EGetData,
TIpcArgs( &objectPkg ) ) );
CleanupStack::Pop( signature );
aSignature = signature;
return KErrNone;
}
User::Leave( KErrArgument );
return KErrArgument;
}
void UmlArtifact::roundtrip_java()
{
if (! managed) {
managed = TRUE;
if (stereotype() != "source")
return;
const WrapperStr srcdef = javaSource();
if (srcdef.isEmpty())
return;
const WrapperStr & name = UmlArtifact::name();
UmlPackage * pack = package();
WrapperStr src_path = pack->java_path(name);
{
WrapperStr s = " <i> " + src_path + "</i>";
UmlCom::message(name);
if (verbose())
UmlCom::trace(WrapperStr("<hr><font face=helvetica>roundtrip body from")
+ s + "</font><br>");
else
set_trace_header(WrapperStr("<font face=helvetica>roundtrip body from")
+ s + "</font><br>");
}
UmlOperation::roundtrip(src_path, javaLanguage);
}
}
void OpenIGTLinkStreamer::receivedImage(ImagePtr image)
{
PackagePtr package(new Package());
package->mImage = image;
if(mSender)
mSender->send(package);
}
void
App::_Open(const BEntry& entry)
{
BPath path;
if (!entry.Exists() || entry.GetPath(&path) != B_OK) {
fprintf(stderr, "Package file not found: %s\n", path.Path());
return;
}
// Try to parse package file via Package Kit
BPackageKit::BPackageInfo info;
status_t status = info.ReadFromPackageFile(path.Path());
if (status != B_OK) {
fprintf(stderr, "Failed to parse package file: %s\n",
strerror(status));
return;
}
// Transfer information into PackageInfo
PackageInfoRef package(new(std::nothrow) PackageInfo(info), true);
if (package.Get() == NULL) {
fprintf(stderr, "Could not allocate PackageInfo\n");
return;
}
package->SetLocalFilePath(path.Path());
BMessage settings;
_LoadSettings(settings);
MainWindow* window = new MainWindow(settings, package);
_ShowWindow(window);
}
void PlasmoidWrapper::setApplet(QObject *extender)
{
Plasma::Extender *appletExtender = static_cast<Plasma::Extender *>(extender);
if(appletExtender){
Plasma::Applet *applet = appletExtender->applet();
if(applet){
Plasma::PackageStructure::Ptr structure = Plasma::Applet::packageStructure();
const QString workflowPath = KGlobal::dirs()->locate("data", structure->defaultPackageRoot() + "/workflow/");
Plasma::Package package(workflowPath, structure);
m_version = package.metadata().version();
emit versionChanged(m_version);
m_popupApplet = static_cast<Plasma::PopupApplet *>(applet);
if(m_popupApplet->containment()){
m_isInPanel = (m_popupApplet->containment()->containmentType() == Plasma::Containment::PanelContainment);
emit isInPanelChanged(m_isInPanel);
connect(m_popupApplet,SIGNAL(geometryChanged()),this,SLOT(geometryChangedSlot()));
connect(KWindowSystem::self(),SIGNAL(activeWindowChanged(WId)),this,SLOT(activeWindowChangedSlot(WId)));
}
}
delete extender;
}
}
QString PlasmoidHandler::description(const QString &entry) const
{
const QString key = m_fileDefinitions.key(entry);
if (key.isEmpty()) {
for (const auto dir : package().directories()) {
if (qstrcmp(entry.toLocal8Bit().data(), dir) == 0) {
return package().name(entry.toLocal8Bit().data());
}
}
} else {
return package().name(key.toLocal8Bit().data());
}
return QString();
}
//
// RTrkSrvCliSession::GetDebugConnStatus()
//
TInt RTrkSrvCliSession::GetDebugConnStatus(TTrkConnStatus& aConnStatus, TDes& aConnMsg)
{
TPckg<TTrkConnStatus> package(aConnStatus);
TIpcArgs args(&package, aConnMsg.Length(), &aConnMsg);
return SendReceive(ETrkSrvCmdGetDebugConnStatus, args);
}
void PeerObject::readPackage()
{
// static int readCount = 0;
// m_dbgLog.write("PeerObject::readData()");
// m_dbgLog.write(QString("(%1)\n").arg(++readCount).toLatin1());
// m_dbgLog.flush();
static quint64 totalRead = 0;
QByteArray package(m_socket->read().toByteArray());
if(package.isEmpty()) {
qDebug("Peer: PeerObject::readPackage() - zero size data");
m_peerSocket->write(QStringLiteral("fReceived zero size").toLatin1());
// m_peerSocket->flush();
if(m_close)
close(1);
return;
}
QWriteLocker writeLocker(&m_dataPkgLock);
m_dataPkg.append(package);
static int totalReadPkgCount = 0;
totalReadPkgCount++;
Logger::log("Handled packages", totalReadPkgCount);
callSlotQueued(this, "checkReadData");
}
//
// RTrkTcbCliSession::PositionFile()
//
// Changes the current postion in the already opened file
// @return KErrNone - if succesful
// Negative - if failed.
//
TInt RTrkTcbCliSession::PositionFile(TSeek aSeek, TInt& aOffset)
{
TPckg<TSeek> package(aSeek);
TIpcArgs args(&package, aOffset);
return SendReceive(ETrkTcbCmdCodePositionFile, args);
}
void SMWServer::playerCreatesRoom(uint64_t playerID, const void* data, size_t dataLength)
{
if (!players.count(playerID))
return;
Player* player = &players[playerID];
if (player->currentRoomID || player->isPlaying)
return;
if (dataLength != sizeof(NetPkgs::NewRoom)) {
printf("[error] Corrupt package arrived from %lu\n", playerID);
return;
}
// input
NetPkgs::NewRoom pkg;
memcpy(&pkg, data, dataLength);
// create
Room room(roomCreateID, pkg.name, pkg.password, player);
room.setGamemode(pkg.gamemodeID, pkg.gamemodeGoal);
rooms[roomCreateID] = room;
player->currentRoomID = roomCreateID;
player->isPlaying = false;
// output
NetPkgs::NewRoomCreated package(roomCreateID);
player->sendData(&package, sizeof(NetPkgs::NewRoomCreated));
log("New room by %s : {id: %d; name: %s; pw: %s}",
player->toString().c_str(), room.roomID, room.name, room.password);
roomCreateID++; // increase global ID
}
void Room::sendChatMessage(Player* sender, const char* message)
{
if (!message)
return;
if (strlen(message) <= 0)
return;
// TODO: verify
uint8_t senderNum = 255;
for (uint8_t p = 0; p < 4 && senderNum == 255; p++) {
if (players[p] == sender) {
senderNum = p;
}
}
assert(senderNum != 255);
NetPkgs::RoomChatMsg package(senderNum, message);
// Send every player information about the other players.
for (uint8_t p = 0; p < 4; p++) {
if (players[p]) {
players[p]->sendData(&package, sizeof(NetPkgs::RoomChatMsg));
}
}
}
//
// RTrkTcbCliSession::OpenFile()
//
// Opens the specified file in the specified mode.
// @return KErrNone - if succesful
// Negative - if failed.
//
TInt RTrkTcbCliSession::OpenFile(const TDesC& aFilePath, TUint aMode, TTime& aModifiedTime)
{
TPckg<TTime> package(aModifiedTime);
TInt length = aFilePath.Length();
TIpcArgs args(length, &aFilePath, aMode, &package);
return SendReceive(ETrkTcbCmdCodeOpenFile, args);
}
void GUIScreen::resize(const Size& size_) {
Screen::resize(size_);
gui_manager->set_rect(Rect(Vector2i(0, 0), size));
ScreenResizePackage package(this, size_);
ScreenResizePackage* pp = &package;
ceu_out_go(&CEUapp, CEU_IN_SCREEN_RESIZE, &pp);
}
/// \fn NetConnection::sendAlive(NetAddress& client, float tick)
/// \brief Sends an alive system message, when no message has been send for some time.
void NetConnection::sendAlive(NetAddress& client, float tick)
{
if ( IS_SET(mFlags, eKeepAlive) && (tick - client.lastTimeSend >= ALIVE_MSG_INTERVAL) )
{
NetPackage package(NetPackage::eAlive, NetPackage::eUnreliable, 0);
send(client, package);
}
}
