void HttpRequestHandler::processRequest()
{
HttpRequest httpRequest(m_dataInput);
httpRequest.readHeader();
StringStorage request;
request.fromAnsiString(httpRequest.getRequest());
if (!httpRequest.parseHeader()) {
Log::warning(_T("invalid http request from %s"), m_peerHost.getString());
return ;
}
request.replaceChar(_T('\n'), _T(' '));
request.replaceChar(_T('\t'), _T(' '));
Log::message(_T("\"%s\" from %s"), request.getString(), m_peerHost.getString());
HttpReply reply(m_dataOutput);
bool pageFound = false;
if (strcmp(httpRequest.getFilename(), "/") == 0) {
CharString paramsString("\n");
bool isAppletArgsValid = true;
bool paramsInUrlIsEnabled = Configurator::getInstance()->getServerConfig()->isAppletParamInUrlEnabled();
if (httpRequest.hasArguments() && paramsInUrlIsEnabled) {
ArgList *args = httpRequest.getArguments();
for (size_t i = 0; i < args->getCount(); i++) {
const char *key = args->getKey(i);
AppletParameter parameter(key, args->getValue(key));
if (!parameter.isValid()) {
isAppletArgsValid = false;
break;
}
paramsString.format("%s%s", paramsString.getString(),
parameter.getFormattedString());
}
}
reply.send200();
if (!isAppletArgsValid) {
m_dataOutput->writeFully(HTTP_MSG_BADPARAMS, strlen(HTTP_MSG_BADPARAMS));
} else {
CharString page;
StringStorage computerName(_T("TightVNC Server"));
Environment::getComputerName(&computerName);
size_t computerNameANSILength = computerName.getLength() + 1;
char *computerNameANSI = new char[computerNameANSILength];
computerName.toAnsiString(computerNameANSI, computerNameANSILength);
page.format(HTTP_INDEX_PAGE_FORMAT,
computerNameANSI,
Configurator::getInstance()->getServerConfig()->getRfbPort(),
paramsString.getString());
delete[] computerNameANSI;
m_dataOutput->writeFully(page.getString(), page.getLength());
}
pageFound = true;
} else if ((strcmp(httpRequest.getFilename(), "/VncViewer.jar") == 0)) {
reply.send200();
m_dataOutput->writeFully(VNC_VIEWER_JAR_BODY, sizeof(VNC_VIEWER_JAR_BODY));
pageFound = true;
}
if (!pageFound) {
reply.send404();
}
}
void
SipccSdpAttributeList::LoadFmtp(sdp_t* sdp, uint16_t level)
{
auto fmtps = MakeUnique<SdpFmtpAttributeList>();
for (uint16_t i = 1; i < UINT16_MAX; ++i) {
sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_FMTP, i);
if (!attr) {
break;
}
sdp_fmtp_t* fmtp = &(attr->attr.fmtp);
// Get the payload type
std::stringstream osPayloadType;
// payload_num is the number in the fmtp attribute, verbatim
osPayloadType << fmtp->payload_num;
// Get the serialized form of the parameters
flex_string fs;
flex_string_init(&fs);
// Very lame, but we need direct access so we can get the serialized form
sdp_result_e sdpres = sdp_build_attr_fmtp_params(sdp, fmtp, &fs);
if (sdpres != SDP_SUCCESS) {
flex_string_free(&fs);
continue;
}
std::string paramsString(fs.buffer);
flex_string_free(&fs);
// Get parsed form of parameters, if supported
UniquePtr<SdpFmtpAttributeList::Parameters> parameters;
rtp_ptype codec = sdp_get_known_payload_type(sdp, level, fmtp->payload_num);
switch (codec) {
case RTP_H264_P0:
case RTP_H264_P1: {
SdpFmtpAttributeList::H264Parameters* h264Parameters(
new SdpFmtpAttributeList::H264Parameters);
sstrncpy(h264Parameters->sprop_parameter_sets, fmtp->parameter_sets,
sizeof(h264Parameters->sprop_parameter_sets));
h264Parameters->level_asymmetry_allowed =
!!(fmtp->level_asymmetry_allowed);
h264Parameters->packetization_mode = fmtp->packetization_mode;
// Copied from VcmSIPCCBinding
#ifdef _WIN32
sscanf_s(fmtp->profile_level_id, "%x",
&h264Parameters->profile_level_id, sizeof(unsigned*));
#else
sscanf(fmtp->profile_level_id, "%xu",
&h264Parameters->profile_level_id);
#endif
h264Parameters->max_mbps = fmtp->max_mbps;
h264Parameters->max_fs = fmtp->max_fs;
h264Parameters->max_cpb = fmtp->max_cpb;
h264Parameters->max_dpb = fmtp->max_dpb;
h264Parameters->max_br = fmtp->max_br;
parameters.reset(h264Parameters);
} break;
case RTP_VP9: {
SdpFmtpAttributeList::VP8Parameters* vp9Parameters(
new SdpFmtpAttributeList::VP8Parameters(
SdpRtpmapAttributeList::kVP9));
vp9Parameters->max_fs = fmtp->max_fs;
vp9Parameters->max_fr = fmtp->max_fr;
parameters.reset(vp9Parameters);
} break;
case RTP_VP8: {
SdpFmtpAttributeList::VP8Parameters* vp8Parameters(
new SdpFmtpAttributeList::VP8Parameters(
SdpRtpmapAttributeList::kVP8));
vp8Parameters->max_fs = fmtp->max_fs;
vp8Parameters->max_fr = fmtp->max_fr;
parameters.reset(vp8Parameters);
} break;
default: {
}
}
fmtps->PushEntry(osPayloadType.str(), paramsString, Move(parameters));
}
if (!fmtps->mFmtps.empty()) {
SetAttribute(fmtps.release());
}
}
QString OAuthPrivate::buildAuthHeader(const QString & method, const QString & url, const Params & data, const QString & verifier)
{
QMap<QString, QString> params;
params.insert("oauth_consumer_key", consumerKey.toAscii());
params.insert("oauth_nonce", Helper::identifier(42));
params.insert("oauth_signature_method", "HMAC-SHA1");
params.insert("oauth_timestamp", QString("%1").arg(Helper::timestamp()));
params.insert("oauth_version", "1.0");
if(!verifier.isEmpty())
params.insert("oauth_verifier", verifier);
if(!oauthToken.isEmpty())
params.insert("oauth_token", oauthToken.toAscii());
params.unite(data);
QString authStr;
Params::const_iterator i = params.constBegin();
params.insert("oauth_signature", signature(signingKey(consumerSecret, oauthTokenSecret), baseString(method, url, paramsString(params))));
while (i != params.constEnd()){
authStr += QUrl::toPercentEncoding(i.key()) + "=\"" + QUrl::toPercentEncoding(i.value()) + "\", ";
++i;
}
return authStr.mid(0, authStr.length() - 2);
}
