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
}

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);
}