bool
cgicc::FormFile::operator== (const FormFile& file) const
{
return (stringsAreEqual(fName, file.fName) &&
stringsAreEqual(fFilename, file.fFilename) &&
stringsAreEqual(fDataType, file.fDataType));
}
void CCocoaPowerSyscall::OSPowerSourceCallBack(void *refcon)
{
#if !defined(TARGET_DARWIN_IOS)
// Called whenever any power source is added, removed, or changes.
// When on battery, we get called periodically as battery level changes.
CCocoaAutoPool autopool;
CCocoaPowerSyscall *ctx = (CCocoaPowerSyscall*)refcon;
CFTypeRef power_sources_info = IOPSCopyPowerSourcesInfo();
CFArrayRef power_sources_list = IOPSCopyPowerSourcesList(power_sources_info);
for (int i = 0; i < CFArrayGetCount(power_sources_list); i++)
{
CFTypeRef power_source;
CFDictionaryRef description;
power_source = CFArrayGetValueAtIndex(power_sources_list, i);
description = IOPSGetPowerSourceDescription(power_sources_info, power_source);
// skip power sources that are not present (i.e. an absent second battery in a 2-battery machine)
if ((CFBooleanRef)CFDictionaryGetValue(description, CFSTR(kIOPSIsPresentKey)) == kCFBooleanFalse)
continue;
if (stringsAreEqual((CFStringRef)CFDictionaryGetValue(description, CFSTR (kIOPSTransportTypeKey)), CFSTR (kIOPSInternalType)))
{
CFStringRef currentState = (CFStringRef)CFDictionaryGetValue(description, CFSTR (kIOPSPowerSourceStateKey));
if (stringsAreEqual (currentState, CFSTR (kIOPSACPowerValue)))
{
ctx->m_OnBattery = false;
ctx->m_BatteryPercent = 100;
ctx->m_SentBatteryMessage = false;
}
else if (stringsAreEqual (currentState, CFSTR (kIOPSBatteryPowerValue)))
{
CFNumberRef cf_number_ref;
int32_t curCapacity, maxCapacity;
cf_number_ref = (CFNumberRef)CFDictionaryGetValue(description, CFSTR(kIOPSCurrentCapacityKey));
CFNumberGetValue(cf_number_ref, kCFNumberSInt32Type, &curCapacity);
cf_number_ref = (CFNumberRef)CFDictionaryGetValue(description, CFSTR(kIOPSMaxCapacityKey));
CFNumberGetValue(cf_number_ref, kCFNumberSInt32Type, &maxCapacity);
ctx->m_OnBattery = true;
ctx->m_BatteryPercent = (int)((double)curCapacity/(double)maxCapacity * 100);
}
}
}
CFRelease(power_sources_list);
CFRelease(power_sources_info);
#endif
}
cgicc::CgiEnvironment::CgiEnvironment(CgiInput *input)
{
// Create a local CgiInput object for us to use
// In the vast majority of cases, this will be used
// For FastCGI applications it won't but the performance hit of
// an empty inline constructor is negligible
CgiInput local_input;
if(0 == input)
readEnvironmentVariables(&local_input);
else
readEnvironmentVariables(input);
// On Win32, use binary read to avoid CRLF conversion
#ifdef WIN32
# ifdef __BORLANDC__
setmode(_fileno(stdin), O_BINARY);
# else
_setmode(_fileno(stdin), _O_BINARY);
# endif
#endif
if(stringsAreEqual(fRequestMethod, "post") || stringsAreEqual(fRequestMethod, "put")) {
// Don't use auto_ptr, but vector instead
// Bug reported by [email protected]
std::vector<char> data(fContentLength);
if(getenv("CGICC_MAX_CONTENTLENGTH")&&getContentLength()>(long unsigned int)atoi(getenv("CGICC_MAX_CONTENTLENGTH")))
{
exit(1);
}
else
// If input is 0, use the default implementation of CgiInput
if ( getContentLength() )
{
// If input is 0, use the default implementation of CgiInput
if ( input == 0 )
{
if ( local_input.read( &data[0], getContentLength() ) != getContentLength() )
throw std::runtime_error("I/O error");
}
else
if ( input->read( &data[0], getContentLength() ) != getContentLength() )
throw std::runtime_error("I/O error");
fPostData = std::string( &data[0], getContentLength() );
}
}
fCookies.reserve(10);
parseCookies();
}
void
cgicc::CgiEnvironment::restore(const std::string& filename)
{
std::ifstream file( filename.c_str(), std::ios::binary | std::ios::in );
if( ! file )
throw std::runtime_error("I/O error");
file.flags(file.flags() & std::ios::skipws);
fContentLength = readLong(file);
fServerPort = readLong(file);
fUsingHTTPS = (bool) readLong(file);
fServerSoftware = readString(file);
fServerName = readString(file);
fGatewayInterface = readString(file);
fServerProtocol = readString(file);
fRequestMethod = readString(file);
fPathInfo = readString(file);
fPathTranslated = readString(file);
fScriptName = readString(file);
fQueryString = readString(file);
fRemoteHost = readString(file);
fRemoteAddr = readString(file);
fAuthType = readString(file);
fRemoteUser = readString(file);
fRemoteIdent = readString(file);
fContentType = readString(file);
fAccept = readString(file);
fUserAgent = readString(file);
fRedirectRequest = readString(file);
fRedirectURL = readString(file);
fRedirectStatus = readString(file);
fReferrer = readString(file);
fCookie = readString(file);
if(stringsAreEqual(fRequestMethod, "post") || stringsAreEqual(fRequestMethod, "put"))
fPostData = readString(file);
file.close();
fCookies.clear();
fCookies.reserve(10);
parseCookies();
}
void
cgicc::CgiEnvironment::save(const std::string& filename) const
{
std::ofstream file( filename.c_str(), std::ios::binary |std::ios::out );
if( ! file )
throw std::runtime_error("I/O error");
writeLong(file, fContentLength);
writeLong(file, fServerPort);
writeLong(file, (unsigned long) usingHTTPS());
writeString(file, fServerSoftware);
writeString(file, fServerName);
writeString(file, fGatewayInterface);
writeString(file, fServerProtocol);
writeString(file, fRequestMethod);
writeString(file, fPathInfo);
writeString(file, fPathTranslated);
writeString(file, fScriptName);
writeString(file, fQueryString);
writeString(file, fRemoteHost);
writeString(file, fRemoteAddr);
writeString(file, fAuthType);
writeString(file, fRemoteUser);
writeString(file, fRemoteIdent);
writeString(file, fContentType);
writeString(file, fAccept);
writeString(file, fUserAgent);
writeString(file, fRedirectRequest);
writeString(file, fRedirectURL);
writeString(file, fRedirectStatus);
writeString(file, fReferrer);
writeString(file, fCookie);
if(stringsAreEqual(fRequestMethod, "post") || stringsAreEqual(fRequestMethod, "put"))
writeString(file, fPostData);
if(file.bad() || file.fail())
throw std::runtime_error("I/O error");
file.close();
}
// Read in all the environment variables
void
cgicc::CgiEnvironment::readEnvironmentVariables(CgiInput *input)
{
fServerSoftware = input->getenv("SERVER_SOFTWARE");
fServerName = input->getenv("SERVER_NAME");
fGatewayInterface = input->getenv("GATEWAY_INTERFACE");
fServerProtocol = input->getenv("SERVER_PROTOCOL");
std::string port = input->getenv("SERVER_PORT");
fServerPort = std::atol(port.c_str());
fRequestMethod = input->getenv("REQUEST_METHOD");
fPathInfo = input->getenv("PATH_INFO");
fPathTranslated = input->getenv("PATH_TRANSLATED");
fScriptName = input->getenv("SCRIPT_NAME");
fQueryString = input->getenv("QUERY_STRING");
fRemoteHost = input->getenv("REMOTE_HOST");
fRemoteAddr = input->getenv("REMOTE_ADDR");
fAuthType = input->getenv("AUTH_TYPE");
fRemoteUser = input->getenv("REMOTE_USER");
fRemoteIdent = input->getenv("REMOTE_IDENT");
fContentType = input->getenv("CONTENT_TYPE");
std::string length = input->getenv("CONTENT_LENGTH");
fContentLength = std::atol(length.c_str());
fAccept = input->getenv("HTTP_ACCEPT");
fUserAgent = input->getenv("HTTP_USER_AGENT");
fRedirectRequest = input->getenv("REDIRECT_REQUEST");
fRedirectURL = input->getenv("REDIRECT_URL");
fRedirectStatus = input->getenv("REDIRECT_STATUS");
fReferrer = input->getenv("HTTP_REFERER");
fCookie = input->getenv("HTTP_COOKIE");
fAcceptLanguageString = input->getenv("HTTP_ACCEPT_LANGUAGE");
// Win32 bug fix by Peter Goedtkindt
std::string https = input->getenv("HTTPS");
if(stringsAreEqual(https, "on"))
fUsingHTTPS = true;
else
fUsingHTTPS = false;
}
static void powerSourceChanged(void *context)
{
#pragma unused(context)
CFTypeRef powerBlob = IOPSCopyPowerSourcesInfo();
CFArrayRef powerSourcesList = IOPSCopyPowerSourcesList(powerBlob);
CFIndex count = CFArrayGetCount(powerSourcesList);
for (CFIndex i = 0; i < count; ++i) {
CFTypeRef powerSource;
CFDictionaryRef description;
HGPowerSource hgPowerSource;
CFBooleanRef charging = kCFBooleanFalse;
CFIndex batteryTime = -1;
CFIndex percentageCapacity = -1;
powerSource = CFArrayGetValueAtIndex(powerSourcesList, i);
description = IOPSGetPowerSourceDescription(powerBlob, powerSource);
//Don't display anything for power sources that aren't present (i.e. an absent second battery in a 2-battery machine)
if (CFDictionaryGetValue(description, CFSTR(kIOPSIsPresentKey)) == kCFBooleanFalse)
continue;
//We only know how to handle internal (battery, a/c power) transport types. The other values indicate UPS usage.
if (stringsAreEqual(CFDictionaryGetValue(description, CFSTR(kIOPSTransportTypeKey)),
CFSTR(kIOPSInternalType))) {
CFStringRef currentState = CFDictionaryGetValue(description, CFSTR(kIOPSPowerSourceStateKey));
if (stringsAreEqual(currentState, CFSTR(kIOPSACPowerValue)))
hgPowerSource = HGACPower;
else if (stringsAreEqual(currentState, CFSTR(kIOPSBatteryPowerValue)))
hgPowerSource = HGBatteryPower;
else
hgPowerSource = HGUnknownPower;
//Battery power
if (CFDictionaryGetValue(description, CFSTR(kIOPSIsChargingKey)) == kCFBooleanTrue) {
//Charging
charging = kCFBooleanTrue;
CFNumberRef timeToChargeNum = CFDictionaryGetValue(description, CFSTR(kIOPSTimeToFullChargeKey));
CFIndex timeToCharge;
if (CFNumberGetValue(timeToChargeNum, kCFNumberCFIndexType, &timeToCharge))
batteryTime = timeToCharge;
} else {
//Not charging
charging = kCFBooleanFalse;
CFNumberRef timeToEmptyNum = CFDictionaryGetValue(description, CFSTR(kIOPSTimeToEmptyKey));
CFIndex timeToEmpty;
if (CFNumberGetValue(timeToEmptyNum, kCFNumberCFIndexType, &timeToEmpty))
batteryTime = timeToEmpty;
}
/* Capacity */
CFNumberRef currentCapacityNum = CFDictionaryGetValue(description, CFSTR(kIOPSCurrentCapacityKey));
CFNumberRef maxCapacityNum = CFDictionaryGetValue(description, CFSTR(kIOPSMaxCapacityKey));
CFIndex currentCapacity, maxCapacity;
if (CFNumberGetValue(currentCapacityNum, kCFNumberCFIndexType, ¤tCapacity) &&
CFNumberGetValue(maxCapacityNum, kCFNumberCFIndexType, &maxCapacity))
percentageCapacity = roundf((currentCapacity / (float)maxCapacity) * 100.0f);
} else {
//UPS power
hgPowerSource = HGUPSPower;
}
//Avoid sending notifications on the same power source multiple times, unless the charging state or presence/absence of a time estimate has changed.
if (lastPowerSource != hgPowerSource || lastChargingState != charging || (lastBatteryTime == -1) != (batteryTime == -1)) {
lastPowerSource = hgPowerSource;
lastChargingState = charging;
lastBatteryTime = batteryTime;
AppController_powerSwitched(hgPowerSource, charging, batteryTime, percentageCapacity);
}
}
CFRelease(powerSourcesList);
CFRelease(powerBlob);
}
inline bool operator() (const FormFile& entry) const
{ return stringsAreEqual(fName, entry.getName()); }
inline bool operator() (const FormEntry& entry) const
{ return stringsAreEqual(fValue, entry.getValue()); }
void
cgicc::Cgicc::parseFormInput(const std::string& data, const std::string &content_type)
{
std::string standard_type = "application/x-www-form-urlencoded";
std::string multipart_type = "multipart/form-data";
// Don't waste time on empty input
if(true == data.empty())
return;
// Standard content type = application/x-www-form-urlencoded
// It may not be explicitly specified
if(true == content_type.empty()
|| stringsAreEqual(content_type, standard_type,standard_type.length())) {
std::string name, value;
std::string::size_type pos;
std::string::size_type oldPos = 0;
// Parse the data in one fell swoop for efficiency
while(true) {
// Find the '=' separating the name from its value, also have to check for '&' as its a common misplaced delimiter but is a delimiter none the less
pos = data.find_first_of( "&=", oldPos);
// If no '=', we're finished
if(std::string::npos == pos)
break;
// Decode the name
// pos == '&', that means whatever is in name is the only name/value
if( data.at( pos ) == '&' )
{
const char * pszData = data.c_str() + oldPos;
while( *pszData == '&' ) // eat up extraneous '&'
{
++pszData; ++oldPos;
}
if( oldPos >= pos )
{ // its all &'s
oldPos = ++pos;
continue;
}
// this becomes an name with an empty value
name = form_urldecode(data.substr(oldPos, pos - oldPos));
fFormData.push_back(FormEntry(name, "" ) );
oldPos = ++pos;
continue;
}
name = form_urldecode(data.substr(oldPos, pos - oldPos));
oldPos = ++pos;
// Find the '&' or ';' separating subsequent name/value pairs
pos = data.find_first_of(";&", oldPos);
// Even if an '&' wasn't found the rest of the string is a value
value = form_urldecode(data.substr(oldPos, pos - oldPos));
// Store the pair
fFormData.push_back(FormEntry(name, value));
if(std::string::npos == pos)
break;
// Update parse position
oldPos = ++pos;
}
}
// File upload type = multipart/form-data
else if(stringsAreEqual(multipart_type, content_type,
multipart_type.length())){
// Find out what the separator is
std::string bType = "boundary=";
std::string::size_type pos = content_type.find(bType);
// Remove next sentence
std::string commatek=";";
// generate the separators
std::string sep1 = content_type.substr(pos + bType.length());
if (sep1.find(";")!=std::string::npos)
sep1=sep1.substr(0,sep1.find(";"));
sep1.append("\r\n");
sep1.insert(0, "--");
std::string sep2 = content_type.substr(pos + bType.length());
if (sep2.find(";")!=std::string::npos)
sep2=sep2.substr(0,sep2.find(";"));
sep2.append("--\r\n");
sep2.insert(0, "--");
// Find the data between the separators
std::string::size_type start = data.find(sep1);
std::string::size_type sepLen = sep1.length();
std::string::size_type oldPos = start + sepLen;
while(true) {
pos = data.find(sep1, oldPos);
// If sep1 wasn't found, the rest of the data is an item
if(std::string::npos == pos)
break;
// parse the data
parseMIME(data.substr(oldPos, pos - oldPos));
// update position
oldPos = pos + sepLen;
}
// The data is terminated by sep2
pos = data.find(sep2, oldPos);
// parse the data, if found
if(std::string::npos != pos) {
parseMIME(data.substr(oldPos, pos - oldPos));
}
}
}
bool
cgicc::Cgicc::queryCheckbox(const std::string& elementName) const
{
const_form_iterator iter = getElement(elementName);
return (iter != fFormData.end() && stringsAreEqual(iter->getValue(), "on"));
}
