static void Wr_PutC_m (
Wr_cl *self,
int8_t ch /* IN */ )
{
Pipe_st *st = self->st;
bool_t ok;
wr_enter(st);
ok=wr_put(st, &ch, 1);
wr_leave(st);
if (!ok) {
RAISE_Wr$Failure(0); /* Reader closed */
}
}
static void Wr_PutChars_m (
Wr_cl *self,
Wr_Buffer s /* IN */,
uint64_t nb /* IN */ )
{
Pipe_st *st = self->st;
bool_t ok;
wr_enter(st);
ok=wr_put(st, s, nb);
wr_leave(st);
if (!ok) {
RAISE_Wr$Failure(0);
}
}
Future<Future<Nothing>> StandaloneMasterContender::contend()
{
if (!initialized) {
return Failure("Initialize the contender first");
}
if (promise != nullptr) {
LOG(INFO) << "Withdrawing the previous membership before recontending";
promise->set(Nothing());
delete promise;
}
// Directly return a future that is always pending because it
// represents a membership/leadership that is not going to be lost
// until we 'withdraw'.
promise = new Promise<Nothing>();
return promise->future();
}
void ViewTest2::TestOverlay()
{
OLECHAR rgchGuid[] = L"F121F260";
IVwOverlayPtr qxvoTest1, qxvoTest2;
qxvoTest1.CreateInstance(CLSID_VwOverlay);
qxvoTest2.CreateInstance(CLSID_VwOverlay);
CheckHr(qxvoTest1->SetTagInfo(rgchGuid, 5, kosmAll, SmartBstr(L"DDDDD"), SmartBstr(L"WWWWW"),
0x00003300, 0x00000000, 0x00330033, 4, true));
m_psts->Output(" FUNCTION: put_Overlay(qxvoTest1)\n");
CheckHr(m_qrootb->put_Overlay(qxvoTest1));
m_psts->Output(" FUNCTION: get_Overlay(&qxvoTest2)\n");
CheckHr(m_qrootb->get_Overlay(&qxvoTest2));
if (qxvoTest1 != qxvoTest2)
Failure("Overlay returned wrong result");
}
static void Rd_UnGetC_m (
Rd_cl *self )
{
Pipe_st *st = self->st;
bool_t ok;
rd_enter(st);
if (st->ungetc || st->lastc==-1) {
ok=False; /* Already done an UnGetC, or no last character */
} else {
st->ungetc=True;
ok=True;
}
rd_leave(st);
if (!ok) RAISE_Rd$Failure(3); /* Can't unget */
}
void CTlsSocket::ContinueShutdown()
{
m_pOwner->LogMessage(Debug_Verbose, _T("CTlsSocket::ContinueShutdown()"));
int res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
if (!res)
{
m_tlsState = closed;
CSocketEvent *evt = new CSocketEvent(m_pEvtHandler, this, CSocketEvent::close);
CSocketEventDispatcher::Get().SendEvent(evt);
return;
}
if (res != GNUTLS_E_INTERRUPTED && res != GNUTLS_E_AGAIN)
Failure(res, ECONNABORTED);
}
Verdict scoreOnTestCase(string testCaseName) {
string testCaseOutputFilename = generator->getTestCasesDir() + "/" + testCaseName + ".out";
string diffCommand = "diff --unchanged-line-format=' %.2dn %L' --old-line-format='(expected) [line %.2dn] %L' --new-line-format='(received) [line %.2dn] %L' " + testCaseOutputFilename + " _submission.out | head -n 10";
ExecutionResult result = os->execute(testCaseName + "-submission-scoring", diffCommand, "", "_diff.out", "");
string briefDiffCommand = "diff --brief _submission.out " + testCaseOutputFilename;
ExecutionResult briefResult = os->execute(testCaseName + "-submission-scoring-brief", briefDiffCommand, "", "", "");
if (briefResult.exitStatus == 0) {
return Verdict::accepted();
} else {
string diff = string(istreambuf_iterator<char>(*result.outputStream), istreambuf_iterator<char>());
return Verdict::wrongAnswer({
Failure("Diff:\n" + diff, 0)
});
}
}
void CTlsSocket::ContinueShutdown()
{
m_pOwner->LogMessage(MessageType::Debug_Verbose, _T("CTlsSocket::ContinueShutdown()"));
int res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
while ((res == GNUTLS_E_INTERRUPTED || res == GNUTLS_E_AGAIN) && m_canWriteToSocket)
res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
if (!res) {
m_tlsState = TlsState::closed;
m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, 0);
return;
}
if (res != GNUTLS_E_INTERRUPTED && res != GNUTLS_E_AGAIN)
Failure(res, true);
}
bool
CAudioScrobbler::SendNowPlaying(mpd_Song* song)
{
bool retval = false;
if(!song || !song->artist || !song->title) return retval;
char* artist = curl_easy_escape(_handle, song->artist, 0);
char* title = curl_easy_escape(_handle, song->title, 0);
char* album = 0;
if(song->album)
album = curl_easy_escape(_handle, song->album, 0);
std::ostringstream query, sig;
query << "method=track.updateNowPlaying&track=" << title << "&artist=" << artist << "&duration=" << song->time << "&api_key=" << APIKEY << "&sk=" << _sessionid;
if(album) {
query << "&album=" << album;
sig << "album" << song->album;
}
curl_free(artist);
curl_free(title);
curl_free(album);
sig << "api_key" << APIKEY << "artist" << song->artist << "duration" << song->time << "methodtrack.updateNowPlaying" << "sk" << _sessionid << "track" << song->title << SECRET;
std::string sighash(md5sum((char*)"%s", sig.str().c_str()));
query << "&api_sig=" << sighash;
OpenURL(ROOTURL, query.str().c_str());
if(_response.find("<lfm status=\"ok\">") != std::string::npos) {
iprintf("%s", "Updated \"Now Playing\" status successfully.");
retval = true;
}
else if(_response.find("<lfm status=\"failed\">") != std::string::npos) {
eprintf("%s%s", "Last.fm returned an error while updating the currently playing track:\n", _response.c_str());
if(CheckFailure(_response))
Failure();
}
CLEANUP();
return retval;
}
unsigned TrapAccess( trap_elen num_in_mx, in_mx_entry_p mx_in, trap_elen num_out_mx, mx_entry_p mx_out )
{
trap_retval result;
if( ReqFunc == NULL )
return( (unsigned)-1 );
result = ReqFuncProxy( num_in_mx, mx_in, num_out_mx, mx_out );
if( result == REQUEST_FAILED ) {
Failure();
}
Access();
#if defined( __WINDOWS__ ) && !defined( SERVER )
TrapHardModeCheck();
#endif
if( result == REQUEST_FAILED )
return( (unsigned)-1 );
return( result );
}
NetworkManager::VpnPlugin::VpnPlugin(const QString &path, QObject *parent)
: QObject(parent), d_ptr(new VpnPluginPrivate(path))
{
Q_D(VpnPlugin);
d->state = (NetworkManager::VpnConnection::State)d->iface.state();
QObject::connect(&d->iface, SIGNAL(Config(QVariantMap)),
this, SLOT(setConfig(QVariantMap)));
QObject::connect(&d->iface, SIGNAL(Failure(uint)),
this, SLOT(setFailure(QString)));
QObject::connect(&d->iface, SIGNAL(Ip4Config(QVariantMap)),
this, SLOT(setIp4Config(QVariantMap)));
QObject::connect(&d->iface, SIGNAL(Ip6Config(QVariantMap)),
this, SLOT(setIp6Config(QVariantMap)));
//QObject::connect(&d->iface, SIGNAL(LoginBanner(QString)),
// this, SLOT(onLoginBanner(QString)));
QObject::connect(&d->iface, SIGNAL(StateChanged(uint)),
this, SLOT(onStateChanged(uint)));
}
void CTlsSocket::ContinueShutdown()
{
m_pOwner->LogMessage(Debug_Verbose, _T("CTlsSocket::ContinueShutdown()"));
int res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
if (!res)
{
m_tlsState = closed;
wxSocketEvent evt(GetId());
evt.m_event = wxSOCKET_LOST;
wxPostEvent(m_pEvtHandler, evt);
return;
}
if (res != GNUTLS_E_INTERRUPTED && res != GNUTLS_E_AGAIN)
Failure(res);
}
AvahiService::AvahiService(const QString &n, const QString &type, const QString &domain)
: name(n)
, port(0)
{
static bool registeredTypes=false;
if (!registeredTypes) {
qDBusRegisterMetaType<QList<QByteArray> >();
registeredTypes=true;
}
org::freedesktop::Avahi::Server server("org.freedesktop.Avahi", "/", QDBusConnection::systemBus());
QDBusReply<QDBusObjectPath> reply=server.ServiceResolverNew(-1, -1, name, type, Avahi::domainToDNS(domain), -1, 8 /*AVAHI_LOOKUP_NO_ADDRESS|AVAHI_LOOKUP_NO_TXT*/);
if (reply.isValid()) {
resolver=new OrgFreedesktopAvahiServiceResolverInterface("org.freedesktop.Avahi", reply.value().path(), QDBusConnection::systemBus());
connect(resolver, SIGNAL(Found(int,int,const QString &,const QString &,const QString &,const QString &, int, const QString &,ushort,const QList<QByteArray>&, uint)),
this, SLOT(resolved(int,int,const QString &,const QString &,const QString &,const QString &, int, const QString &,ushort, const QList<QByteArray>&, uint)));
connect(resolver, SIGNAL(Failure(QString)), this, SLOT(error(QString)));
}
Future<Owned<T>> Shared<T>::own()
{
// If two threads simultaneously access this object and at least one
// of them is a write, the behavior is undefined. This is similar to
// boost::shared_ptr. For more details, please refer to the boost
// shared_ptr document (section "Thread Safety").
if (data.get() == NULL) {
return Owned<T>(NULL);
}
bool false_value = false;
if (!data->owned.compare_exchange_strong(false_value, true)) {
return Failure("Ownership has already been transferred");
}
Future<Owned<T>> future = data->promise.future();
data.reset();
return future;
}
void CTlsSocket::ContinueShutdown()
{
m_pOwner->LogMessage(MessageType::Debug_Verbose, _T("CTlsSocket::ContinueShutdown()"));
int res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
while ((res == GNUTLS_E_INTERRUPTED || res == GNUTLS_E_AGAIN) && m_canWriteToSocket)
res = gnutls_bye(m_session, GNUTLS_SHUT_WR);
if (!res) {
m_tlsState = TlsState::closed;
CSocketEvent *evt = new CSocketEvent(m_pEvtHandler, this, CSocketEvent::close);
CSocketEventSource::dispatcher_.SendEvent(evt);
return;
}
if (res != GNUTLS_E_INTERRUPTED && res != GNUTLS_E_AGAIN)
Failure(res, true);
}
// Return the number of items in the sequence.
int MHParseNode::GetArgCount()
{
if (m_nNodeType == PNTagged)
{
MHPTagged *pTag = (MHPTagged *)this;
return pTag->m_Args.Size();
}
else if (m_nNodeType == PNSeq)
{
MHParseSequence *pSeq = (MHParseSequence *)this;
return pSeq->Size();
}
else
{
Failure("Expected tagged value");
}
return 0; // To keep the compiler happy
}
int CTlsSocket::ContinueHandshake()
{
m_pOwner->LogMessage(Debug_Verbose, _T("CTlsSocket::ContinueHandshake()"));
wxASSERT(m_session);
wxASSERT(m_tlsState == handshake);
int res = gnutls_handshake(m_session);
if (!res)
{
m_pOwner->LogMessage(Debug_Info, _T("Handshake successful"));
if (ResumedSession())
m_pOwner->LogMessage(Debug_Info, _T("Session resumed"));
const wxString& cipherName = GetCipherName();
const wxString& macName = GetMacName();
m_pOwner->LogMessage(Debug_Info, _T("Cipher: %s, MAC: %s"), cipherName.c_str(), macName.c_str());
res = VerifyCertificate();
if (res != FZ_REPLY_OK)
return res;
if (m_shutdown_requested)
{
int error = Shutdown();
if (!error || error != EAGAIN)
{
CSocketEvent *evt = new CSocketEvent(m_pEvtHandler, this, CSocketEvent::close);
CSocketEventDispatcher::Get().SendEvent(evt);
}
}
return FZ_REPLY_OK;
}
else if (res == GNUTLS_E_AGAIN || res == GNUTLS_E_INTERRUPTED)
return FZ_REPLY_WOULDBLOCK;
Failure(res, ECONNABORTED);
return FZ_REPLY_ERROR;
}
static char *execute(char *command, int wait) /* {{{1 */
{
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
ZeroMemory(&pi, sizeof(pi));
si.cb = sizeof(si);
if (CreateProcess(0, command, 0, 0, 0, CREATE_NO_WINDOW, 0, 0, &si, &pi)) {
if (wait) {
WaitForSingleObject(pi.hProcess, INFINITE);
/* long exit_code; */
/* TODO: GetExitCodeProcess( pi.hProcess, &exit_code); */
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
return Success(NULL);
} else {
return Failure(GetError());
}
}
void CTlsSocket::CheckResumeFailedWrite()
{
if (m_lastWriteFailed)
{
int res = gnutls_record_send(m_session, 0, 0);
if (res == GNUTLS_E_INTERRUPTED || res == GNUTLS_E_AGAIN)
return;
if (res < 0)
{
Failure(res);
return;
}
m_writeSkip += res;
m_lastWriteFailed = false;
m_canTriggerWrite = true;
wxASSERT(GNUTLS_E_INVALID_REQUEST == gnutls_record_send(m_session, 0, 0));
}
}
Future<Response> decode(const string& buffer)
{
ResponseDecoder decoder;
deque<Response*> responses = decoder.decode(buffer.c_str(), buffer.length());
if (decoder.failed() || responses.empty()) {
for (size_t i = 0; i < responses.size(); ++i) {
delete responses[i];
}
return Failure("Failed to decode HTTP response:\n" + buffer + "\n");
} else if (responses.size() > 1) {
PLOG(ERROR) << "Received more than 1 HTTP Response";
}
Response response = *responses[0];
for (size_t i = 0; i < responses.size(); ++i) {
delete responses[i];
}
return response;
}
Future<size_t> write(int_fd fd, const void* data, size_t size)
{
process::initialize();
// TODO(benh): Let the system calls do what ever they're supposed to
// rather than return 0 here?
if (size == 0) {
return 0;
}
// Just do a synchronous call.
if (!fd.is_overlapped()) {
ssize_t result = os::write(fd, data, size);
if (result == -1) {
return Failure(WindowsError().message);
}
return static_cast<size_t>(result);
}
return windows::write(fd, data, size);
}
Future<std::set<string> > LevelDBStorageProcess::names()
{
if (error.isSome()) {
return Failure(error.get());
}
std::set<string> results;
leveldb::Iterator* iterator = db->NewIterator(leveldb::ReadOptions());
iterator->SeekToFirst();
while (iterator->Valid()) {
results.insert(iterator->key().ToString());
iterator->Next();
}
delete iterator;
return results;
}
Future<size_t> socket_send_data(int s, const char* data, size_t size)
{
CHECK(size > 0);
while (true) {
ssize_t length = send(s, data, size, MSG_NOSIGNAL);
#ifdef __WINDOWS__
int error = WSAGetLastError();
#else
int error = errno;
#endif // __WINDOWS__
if (length < 0 && net::is_restartable_error(error)) {
// Interrupted, try again now.
continue;
} else if (length < 0 && net::is_retryable_error(error)) {
// Might block, try again later.
return io::poll(s, io::WRITE)
.then(lambda::bind(&internal::socket_send_data, s, data, size));
} else if (length <= 0) {
// Socket error or closed.
if (length < 0) {
const string error = os::strerror(errno);
VLOG(1) << "Socket error while sending: " << error;
} else {
VLOG(1) << "Socket closed while sending";
}
if (length == 0) {
return length;
} else {
return Failure(ErrnoError("Socket send failed"));
}
} else {
CHECK(length > 0);
return length;
}
}
}
Future<size_t> socket_send_file(
Socket socket,
int fd,
off_t offset,
size_t size)
{
CHECK(size > 0);
while (true) {
Try<ssize_t, SocketError> length =
os::sendfile(socket.get(), fd, offset, size);
if (length.isSome()) {
CHECK(length.get() >= 0);
if (length.get() == 0) {
// Socket closed.
VLOG(1) << "Socket closed while sending";
}
return length.get();
}
if (net::is_restartable_error(length.error().code)) {
// Interrupted, try again now.
continue;
} else if (net::is_retryable_error(length.error().code)) {
// Might block, try again later.
return io::poll(socket.get(), io::WRITE)
.then(lambda::bind(
&internal::socket_send_file,
socket,
fd,
offset,
size));
} else {
// Socket error or closed.
VLOG(1) << length.error().message;
return Failure(length.error());
};
}
}
void Orchard::RateFruit(int id, int ripeness) {
if (id < 0 || ripeness <= 0) {
throw InvalidInput();
}
//we need to add to both DS's
try {
Fruit* fruit = GetFruit(id);
Plant* plant = GetPlant(fruit->getLocation().msi,
fruit->getLocation().lsi);
Fruit* copy = new Fruit(*fruit);
copy->setRipeRate(ripeness);
plant->RemoveFruit(id);
plant->AddFruit(copy);
Fruits.Remove(id);
Fruits.Insert(id, copy);
} catch (KeyDoesNotExist& e) {
throw Failure();
}
}
void CTlsSocket::TrustCurrentCert(bool trusted)
{
if (m_tlsState != verifycert)
{
m_pOwner->LogMessage(Debug_Warning, _T("TrustCurrentCert called at wrong time."));
return;
}
if (trusted)
{
m_tlsState = conn;
wxSocketEvent evt(GetId());
evt.m_event = wxSOCKET_CONNECTION;
wxPostEvent(m_pEvtHandler, evt);
TriggerEvents();
return;
}
m_pOwner->LogMessage(::Error, _("Remote certificate not trusted."));
Failure(0);
}
dword Archive::setEOF( Handle * pHandle )
{
if (! m_Open || !pHandle || m_Access == READ )
return 0;
lock();
// set the file size
pHandle->size = pHandle->position;
dword sector = pHandle->sector;
if ( m_SectorMap[ sector ] != SECTOR_LAST )
{
dword freeSector = m_SectorMap[ sector ];
// mark the current as the last sector
m_SectorMap[ sector ] = SECTOR_LAST;
// deallocate sectors beyond the current
while( freeSector != SECTOR_LAST )
{
dword nextSector = m_SectorMap[ freeSector ];
m_SectorMap[ freeSector ] = SECTOR_FREE;
freeSector = nextSector;
}
//m_SectorMap[ freeSector ] = SECTOR_FREE;
// since were updating the table, go ahead and update m_Files
int fileIndex = file( pHandle->key );
if ( fileIndex < 0 )
throw Failure();
m_Files[ fileIndex ].size = pHandle->size;
// update the table
writeTable();
}
unlock();
return pHandle->size;
}
void Pokedex::GetAllPokemonsByLevel(int trainerID, int ** pokemons,
int *numOfPokemon) {
if (trainerID == 0||!pokemons ||!numOfPokemon) {
throw InvalidInput();
}
if (trainerID < 0) {
*numOfPokemon = mainLevelTree.getSize();
int* pokemonArray = (int*) malloc(sizeof(int) * *numOfPokemon);
if (pokemonArray == NULL) {
throw AllocationError();
}
Pokemon* levelArray = mainLevelTree.inOrder();
for (int i = 0; i < *numOfPokemon; i++) {
pokemonArray[i] = levelArray[i].getID();
}
delete[] levelArray;
*pokemons = pokemonArray;
return;
}
Iterator<Trainer> trainer = trainers.find(TrainerCompare(trainerID));
if (trainer == trainers.end()) {
throw Failure();
}
//avlTree<Pokemon, pokemonCompareByLevel> trainerLevelTree = (*trainer).getLevelTree();
//*numOfPokemon = trainerLevelTree.getSize();
*numOfPokemon = (*trainer).getLevelTree().getSize();
int* pokemonArray = (int*) malloc(sizeof(int) * *numOfPokemon);
if (pokemonArray == NULL) {
throw AllocationError();
}
Pokemon* levelArray = (*trainer).getLevelTree().inOrder();
for (int i = 0; i < *numOfPokemon; i++) {
pokemonArray[i] = levelArray[i].getID();
}
*pokemons = pokemonArray;
delete[] levelArray;
return;
}
MojErr SmtpAccountEnableCommand::GetMailAccountResponse(MojObject& response, MojErr err)
{
try {
ResponseToException(response, err);
MojObject account;
DatabaseAdapter::GetOneResult(response, account);
err = account.getRequired(DatabaseAdapter::REV, m_accountRev);
ErrorToException(err);
err = account.getRequired(EmailAccountAdapter::OUTBOX_FOLDERID, m_outboxFolderId);
ErrorToException(err);
CreateSmtpConfigWatch();
} catch(const std::exception& e) {
Failure(e);
}
return MojErrNone;
}
static void Wr_PutStr_m (
Wr_cl *self,
string_t s /* IN */ )
{
Pipe_st *st = self->st;
bool_t ok=True;
uint64_t len;
wr_enter(st);
len=strlen(s);
if (len>0) {
ok=wr_put(st, s, len);
}
wr_leave(st);
if (!ok) {
RAISE_Wr$Failure(0); /* Reader closed */
}
}
