std::string CXfireServerInfo::Pulse ( void )
{ // Queries the server on it's query port (ASE protocol)
// and returns whether it is done scanning
if ( bScanned || bSkipped ) return "Done";
char szBuffer[SERVER_LIST_QUERY_BUFFER] = {0};
if ( m_ulQueryStart == 0 ) {
Query ();
return "SentQuery";
} else {
// Poll the socket
sockaddr_in clntAddr;
int addrLen = sizeof ( clntAddr );
int len = recvfrom ( m_Socket, szBuffer, SERVER_LIST_QUERY_BUFFER, MSG_PARTIAL, (sockaddr *) &clntAddr, &addrLen );
int error = WSAGetLastError();
if ( len >= 0 ) {
// Parse data
ParseQuery ( szBuffer, len );
return "ParsedQuery";
}
if ( CClientTime::GetTime () - m_ulQueryStart > SERVER_LIST_ITEM_TIMEOUT )
{
bSkipped = true;
return "NoReply";
}
return "WaitingReply";
}
}
void DoParseUri(const TPtrCType& aUri, TPtrCType aComponent[])
{
// Parse the components
TPtrCType uri = aUri;
TInt consumed = 0;
TPtrCType& scheme = aComponent[EUriScheme];
if( (consumed = ParseScheme(uri, scheme)) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseAuthority(uri, aComponent[EUriUserinfo],
aComponent[EUriHost], aComponent[EUriPort], IsNetworkScheme(scheme))) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParsePath(uri, aComponent[EUriPath])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseQuery(uri, aComponent[EUriQuery])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseFragment(uri, aComponent[EUriFragment])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
}
const wxChar* wxURI::Parse(const wxChar* uri)
{
uri = ParseScheme(uri);
uri = ParseAuthority(uri);
uri = ParsePath(uri);
uri = ParseQuery(uri);
return ParseFragment(uri);
}
bool wxURI::Parse(const char *uri)
{
uri = ParseScheme(uri);
if ( uri )
uri = ParseAuthority(uri);
if ( uri )
uri = ParsePath(uri);
if ( uri )
uri = ParseQuery(uri);
if ( uri )
uri = ParseFragment(uri);
// we only succeed if we parsed the entire string
return uri && *uri == '\0';
}
/*!
* \brief
* Splits a URL into its constituent parts.
*
* \param url
* Pointer to the URL string to parse.
*
* Splits a URL into its constituent parts.
*
* \remarks
* The URL string passed to this function must be an escaped URL, attempting to parse an unescaped URL will have unknown results.
*/
void c_url_interface::ParseURL(const char* url)
{
// scheme://username:password@address:port/directory/directory/resource?field=value&field=&field=value#fragment
std::string url_string(url);
std::string query;
std::string network_location;
// forward parsing
// get the scheme
SplitString(url_string, m_scheme, "://", true, false);
if(m_scheme.length() == 0)
m_scheme.assign("http");
// get the network location
SplitString(url_string, network_location, "/", true);
if(!network_location.length())
{
network_location = url_string;
url_string.clear();
}
// reverse parsing
// get the fragment
SplitString(url_string, m_fragment, "#", false);
m_fragment = Unescape(m_fragment);
// get the query
SplitString(url_string, query, "?", false);
// get the path
ParseNetworkLocation(network_location);
ParsePath(url_string.c_str());
ParseQuery(query.c_str());
}
int main(void)
{
char inputBuffer[1024];
InitializeRandomness();
InitializeSimulation();
while (1)
{
int bytesReceived = ReceiveUntil(inputBuffer, sizeof(inputBuffer), '\n');
if (bytesReceived < 0)
{
break;
}
if (bytesReceived == 0)
{
continue;
}
query *pCurrentQuery = ParseQuery(inputBuffer);
response *pCurrentResponse = GenerateBlankResponse();
switch (pCurrentQuery->type)
{
case QUERY_ALL:
{
printf("Query All\n");
// List all servers in network
link *listItem = serverList->root;
while (listItem != NULL)
{
serverInfo *server = listItem->object;
if (server == NULL)
{
continue;
}
AddToResponse(pCurrentResponse, "server:");
AddToResponse(pCurrentResponse, server->name);
AddToResponse(pCurrentResponse, ":");
listItem = listItem->next;
}
break;
}
case QUERY_SERVER:
{
printf("Query Server\n");
// List all instances on a server
char *name = (char *)pCurrentQuery->data;
serverInfo *server = FindServer(name);
if (server == NULL)
{
continue;
}
link *listItem = server->instances->root;
while (listItem != NULL)
{
instanceInfo *instance = listItem->object;
if (instance == NULL)
{
continue;
}
AddToResponse(pCurrentResponse, "instance:");
AddToResponse(pCurrentResponse, instance->name);
AddToResponse(pCurrentResponse, ":");
listItem = listItem->next;
}
break;
}
case QUERY_ONE:
{
QueryOne(pCurrentQuery, pCurrentResponse);
break;
}
case QUERY_ADMIN:
{
// Send admin info for one instance
printf("Query Admin\n");
int version = pCurrentQuery->data[0];
if (version != 1)
{
printf("Invalid Query\n");
_terminate(0);
}
char instanceName[64];
strncpy(instanceName, (char *)&pCurrentQuery->data[1], 64);
instanceInfo *instance = FindInstance(instanceName);
if (instance == NULL)
{
printf("Instance Not Found\n");
_terminate(0);
}
AddToResponse(pCurrentResponse, "admin:");
char number[12];
cgc_memset(number, 0, sizeof(number));
uint16_t adminPort = *(uint16_t *)((uint8_t *)FLAG_PAGE + instance->adminPortOffset);
sprintf(number, "$x", (int)adminPort);
AddToResponse(pCurrentResponse, number);
AddToResponse(pCurrentResponse, ":");
break;
}
default:
{
// Invalid Query
printf("Invalid Query\n");
_terminate(0);
break;
}
}
SendResponse(pCurrentResponse);
pCurrentQuery = DestroyQuery(pCurrentQuery);
pCurrentResponse = DestroyResponse(pCurrentResponse);
}
return 0;
}
QuerySelector(const char* query)
{
where.Set("");
ParseQuery(query);
}
/** modify **/
bool Url::parse(String* url){
// clean
clean();
// check
if(!url){
return false;
}
// prepare sz
const char* sz =url->c_str();
// puts(sz);
// protocol
const char* cursor =strstr(sz, "://");
int64_t pos =(cursor ? (cursor-sz) : -1);
if(pos == 0){
ERROR("fail to call %s, len(protocol) can't be 0");
return false;
}
else if(pos > 0){
ASSIGN_POINTER(m_protocol, String::New(sz, pos));
sz =cursor + 3;
}
// auth
cursor =strchr(sz, '@');
pos =(cursor ? (cursor-sz) : -1);
if(pos == 0){
CLEAN_POINTER(m_protocol);
ERROR("fail to call %s, len(auth) can't be 0");
return false;
}
else if(pos > 0){
ASSIGN_POINTER(m_auth, String::New(sz, pos));
sz =cursor + 1;
}
// host
const char* szbeg =sz;
while(const char ch =*sz){
if(ch=='/' || ch=='?' || ch=='#'){
break;
}
++sz;
}
if(sz > szbeg){
ASSIGN_POINTER(m_host, String::New(szbeg, sz-szbeg));
}
// path
if(*sz == '/'){
const char* szbeg =sz++;
while(const char ch =*sz){
if(ch=='?' || ch=='#'){
break;
}
++sz;
}
ASSIGN_POINTER(m_path, String::New(szbeg, sz-szbeg));
}
// query
if(*sz == '?'){
const char* szbeg =++sz;
while(const char ch =*sz){
if(ch == '#'){
break;
}
++sz;
}
if(sz > szbeg){
ASSIGN_POINTER(m_query_string, String::New(szbeg, sz-szbeg));
ASSIGN_POINTER(m_query, SafeNew<Hash>());
if(!ParseQuery(m_query_string, m_query)){
clean();
return false;
}
}
else{
ASSIGN_POINTER(m_query_string, String::New(szbeg, sz-szbeg));
}
}
// fragment
if(*sz == '#'){
ASSIGN_POINTER(m_fragment, String::New(sz+1));
}
// url
ASSIGN_POINTER(m_url, url);
return true;
}
bool Url::_build(String* protocol, String* auth, String* host, String* path, String* query_string, Hash* query, String* fragment){
// clean
clean();
// check
if(path && path->size() && !path->hasPrefix("/")){
return false;
}
// make url
BinaryCoder<1024> coder;
if(protocol && protocol->size()){
ASSIGN_POINTER(m_protocol, protocol);
coder.append(protocol);
coder.append("://", 3);
}
if(auth && auth->size()){
ASSIGN_POINTER(m_auth, auth);
coder.append(auth);
coder.append("@", 1);
}
if(host && host->size()){
ASSIGN_POINTER(m_host, host);
coder.append(host);
}
if(path && path->size()){
ASSIGN_POINTER(m_path, path);
coder.append(path);
}
if(query_string && query_string->size()){
ASSIGN_POINTER(m_query_string, query_string);
ASSIGN_POINTER(m_query, SafeNew<Hash>());
if(!ParseQuery(m_query_string, m_query)){
clean();
return false;
}
coder.append("?", 1);
coder.append(m_query_string);
}
else if(query && query->size()){
ASSIGN_POINTER(m_query, query);
// make query string
BinaryCoder<1024> sub_coder;
HashIterator* it =static_cast< HashIterator* >(query->iterator());
while(it->next()){
String* key =static_cast< String* >(it->getKey());
String* val =static_cast< String* >(it->getValue());
if(sub_coder.size() > 0){
sub_coder.append("&", 1);
}
sub_coder.append(UrlEncode::Encode(key));
sub_coder.append("=", 1);
sub_coder.append(UrlEncode::Encode(val));
}
// set
ASSERT(sub_coder.size());
ASSIGN_POINTER(m_query_string, String::New(sub_coder.c_str(), sub_coder.size()));
coder.append("?", 1);
coder.append(m_query_string);
}
if(fragment && fragment->size()){
ASSIGN_POINTER(m_fragment, fragment);
coder.append("#", 1);
coder.append(fragment);
}
ASSIGN_POINTER(m_url, String::New(coder.c_str(), coder.size()));
return true;
}
