RequestHandler Class Reference

Collaboration diagram for RequestHandler:

Public Member Functions
	RequestHandler (SOCKET s)
	~RequestHandler ()
void	RecvData (string input)
void	OkToSend ()
SOCKET	GetSocket () const
bool	ShouldDie () const
bool	WantPollout () const

Private Types
enum	_RHState { NO_REQUEST_YET , REQUEST_RECVD_SENDING_REPLY , SHOULD_DIE }
typedef enum RequestHandler::_RHState	RHState

Private Member Functions
string	urlenc (string in)
string	urldec (string in)
string	dump_one_line (const char *data, int llen, int len, int addr)
string	bindump (const char *data, int len)
string	present_value (DWORD type, const char *data, DWORD len)
void	process_valid_request (HKEY open_reg_key, string key_name)
void	process_invalid_request (string reg_key)
void	process_root_request ()
void	process_request (string reg_key)

Private Attributes
string	full_input
string	remaining_output
SOCKET	socket
RHState	state

Detailed Description

Definition at line 42 of file netreg.cpp.

Member Typedef Documentation

RHState

typedef enum RequestHandler::_RHState RequestHandler::RHState

private

Member Enumeration Documentation

_RHState

enum RequestHandler::_RHState

private

Enumerator
NO_REQUEST_YET
REQUEST_RECVD_SENDING_REPLY
SHOULD_DIE

Definition at line 398 of file netreg.cpp.

                        {
    NO_REQUEST_YET,
    REQUEST_RECVD_SENDING_REPLY,
    SHOULD_DIE
  } RHState;

Constructor & Destructor Documentation

RequestHandler()

RequestHandler::RequestHandler ( SOCKET  s )

inline

Definition at line 44 of file netreg.cpp.

: socket( s ), state( NO_REQUEST_YET ) {}

~RequestHandler()

RequestHandler::~RequestHandler ( )

inline

Definition at line 45 of file netreg.cpp.

{ closesocket( socket ); }

Member Function Documentation

bindump()

string RequestHandler::bindump ( const char *  data, int  len  )

inlineprivate

Definition at line 166 of file netreg.cpp.

                                              {
    const char *end = data + len;
    string out;
    int addr = 0;
 
    out += "<pre>";
 
    while( data < end ) {
      out += dump_one_line( data, 16, end - data, addr );
      addr += 16;
      data += 16;
    }
 
    out += "</pre>";
 
    return out;
  }

Referenced by present_value().

dump_one_line()

string RequestHandler::dump_one_line ( const char *  data, int  llen, int  len, int  addr  )

inlineprivate

Definition at line 142 of file netreg.cpp.

                                                                        {
    ostringstream out;
    int i;
 
    out << setw( 8 ) << setfill( '0' ) << hex << addr << ": ";
 
    for( i = 0; i < llen; i++ ) {
      if( i < len ) out << setw( 2 ) << setfill( '0' ) << hex <<
              (data[i] & 0xff) << " ";
      else out << "   ";
    }
 
    out << " : ";
 
    for( i = 0; i < llen; i++ ) {
      if( i < len && i < llen &&
      data[i] >= ' ' && data[i] < 0x7f ) out << data[i]; else out << '.';
    }
 
    out << "\n";
 
    return out.str();
  }

Referenced by bindump().

GetSocket()

SOCKET RequestHandler::GetSocket ( ) const

inline

Definition at line 82 of file netreg.cpp.

{ return socket; }

OkToSend()

void RequestHandler::OkToSend ( )

inline

Definition at line 66 of file netreg.cpp.

                  {
    int rv = send( socket,
           remaining_output.c_str(),
           remaining_output.size(), 0 );
    if( rv < 0 ) {
      state = SHOULD_DIE;
      return;
    } else {
      remaining_output =
    remaining_output.substr( rv, remaining_output.size() - rv );
      if( remaining_output.size() == 0 ) {
    state = SHOULD_DIE;
      }
    }
  }

present_value()

string RequestHandler::present_value ( DWORD  type, const char *  data, DWORD  len  )

inlineprivate

Definition at line 184 of file netreg.cpp.

                                                                  {
    //switch( type ) {
    //default:
      return bindump( data, len );
    //}
  }

Referenced by process_valid_request().

process_invalid_request()

void RequestHandler::process_invalid_request ( string  reg_key )

inlineprivate

Definition at line 294 of file netreg.cpp.

                                                 {
    ostringstream text_out;
    text_out << "HTTP/1.0 404 Not Found\r\n"
         << "Content-Type: text/html\r\n"
         << "\r\n"
         << "<html><head><title>Can't find registry key `"
         << reg_key
         << "'</title></head><body>\r\n"
         << "<H1>Can't find registry key `"
         << reg_key
         << "'</H1>\r\n"
         << "The registry key doesn't exist in the local registry.\r\n"
         << "</body></html>\r\n";
 
    remaining_output = text_out.str();
  }

Referenced by process_request(), and process_valid_request().

process_request()

void RequestHandler::process_request ( string  reg_key )

inlineprivate

Definition at line 338 of file netreg.cpp.

                                         {
    int i;
    bool is_predefined_key = true;
 
    if( reg_key == "" ) { process_root_request(); return; }
    HKEY hRegKey = 0;
 
    // Parse the key name...
    size_t slash = reg_key.find( '/' );
    string reg_initial = "";
 
    if( slash == string::npos ) // A root key...
      reg_initial = reg_key;
    else // Any other key
      reg_initial = reg_key.substr( 0, slash );
 
    fprintf( stderr, "reg_init = %s, reg_key = %s\n",
         reg_initial.c_str(),
         reg_key.c_str() );
 
    for( i = 0; root_entries[i]; i++ )
      if( reg_initial == root_entries[i] ) hRegKey = root_handles[i];
 
    if( hRegKey != 0 && reg_initial != reg_key ) {
      size_t start_of_reg_path = reg_initial.size() + 1;
      string reg_path = reg_key.substr( start_of_reg_path,
                    reg_key.size() - start_of_reg_path );
 
      string reg_open_path = reg_path;
      do {
    slash = reg_open_path.find( '/' );
    string reg_single_key = reg_open_path;
 
    if( slash != string::npos ) {
      reg_single_key = reg_open_path.substr( 0, slash );
      reg_open_path = reg_open_path.substr( slash+1,
                        reg_open_path.size() );
    }
 
    HKEY oldKey = hRegKey;
 
    fprintf( stderr, "Opening %s\n", reg_single_key.c_str() );
 
    if( RegOpenKey( hRegKey, reg_single_key.c_str(), &hRegKey ) !=
        ERROR_SUCCESS ) {
      hRegKey = 0;
      break;
    } else RegCloseKey( oldKey );
 
    is_predefined_key = false;
      } while( slash != string::npos );
    }
 
    if( hRegKey == 0 ) process_invalid_request( reg_key );
    else {
      process_valid_request( hRegKey, reg_key );
      if( !is_predefined_key ) RegCloseKey( hRegKey );
    }
  }

Referenced by RecvData().

process_root_request()

void RequestHandler::process_root_request ( )

inlineprivate

Definition at line 311 of file netreg.cpp.

                              {
    ostringstream text_out;
    int i;
 
    text_out << "HTTP/1.0 200 OK\r\n"
         << "Content-Type: text/html\r\n"
         << "\r\n"
         << "<html><head><title>Registry Browser</title></head>\r\n"
         << "<body>\r\n"
         << "<H1>Registry Browser</H1>"
         << "You can use this interface to browse the registry."
         << "You will be presented with one registry key at a time and "
         << "the decendents.\r\n"
         << "<h2>Root Level</h2>\r\n"
         << "Subkeys:<ul>\r\n";
 
      for( i = 0; root_entries[i]; i++ )
    text_out << "<li>"
         << "<a href='/" << urlenc(root_entries[i])
         << "'>" << root_entries[i]
         << "</a></li>\r\n";
 
      text_out << "</ul></body></html>\r\n";
 
      remaining_output = text_out.str();
  }

Referenced by process_request().

process_valid_request()

void RequestHandler::process_valid_request ( HKEY  open_reg_key, string  key_name  )

inlineprivate

Definition at line 191 of file netreg.cpp.

                                                                   {
    size_t ending_slash;
    string up_level;
    ostringstream text_out;
 
    DWORD num_sub_keys;
    DWORD max_subkey_len;
    DWORD num_values;
    DWORD max_value_name_len;
    DWORD max_value_len;
 
    char *value_name_buf;
    char *value_buf;
    char *key_name_buf;
 
    if( RegQueryInfoKey( open_reg_key,
             NULL,
             NULL,
             NULL,
             &num_sub_keys,
             &max_subkey_len,
             NULL,
             &num_values,
             &max_value_name_len,
             &max_value_len,
             NULL,
             NULL ) != ERROR_SUCCESS ) {
      process_invalid_request( key_name );
      return;
    }
 
    value_name_buf = new char [max_value_name_len+1];
    value_buf      = new char [max_value_len+1];
    key_name_buf   = new char [max_subkey_len+1];
 
    ending_slash = key_name.rfind( '/' );
    if( ending_slash != string::npos )
      up_level = key_name.substr( 0, ending_slash );
 
    text_out << "HTTP/1.0 200 OK\r\n"
         << "Content-Type: text/html\r\n"
         << "\r\n"
         << "<html><head><title>Registry Key `"
         << key_name
         << "'</title></head><body>\r\n"
         << "<h1>Registry Key `" << key_name << "'</h1>\r\n"
         << "<a href='/" << urlenc(up_level)
         << "'>(Up one level)</a><p>\r\n"
         << "<h2>Subkeys:</h2><table border='1'>\r\n";
 
    DWORD which_index;
    DWORD key_name_size;
 
    for( which_index = 0; which_index < num_sub_keys; which_index++ ) {
      key_name_size = max_subkey_len+1;
      RegEnumKeyEx( open_reg_key,
            which_index,
            key_name_buf,
            &key_name_size,
            NULL,
            NULL,
            NULL,
            NULL );
      text_out << "<tr><td><a href='/" << urlenc(key_name) << "/"
           << urlenc(string(key_name_buf,key_name_size)) << "'>"
           << string(key_name_buf,key_name_size)
           << "</a></td></tr>\r\n";
    }
 
    text_out << "</table><h2>Values:</h2><table border='1'>\r\n";
 
    DWORD value_name_size;
    DWORD value_data_size;
    DWORD value_type;
 
    for( which_index = 0; which_index < num_values; which_index++ ) {
      value_name_size = max_value_name_len+1;
      value_data_size = max_value_len+1;
 
      RegEnumValue( open_reg_key,
            which_index,
            value_name_buf,
            &value_name_size,
            NULL,
            &value_type,
            (BYTE *)value_buf,
            &value_data_size );
 
      text_out << "<tr><td><b>" << string(value_name_buf,value_name_size)
           << "</b></td><td>"
           << present_value( value_type, value_buf, value_data_size )
           << "</td></tr>";
    }
 
    text_out << "</ul></body></html>\r\n";
 
    delete [] key_name_buf;
    delete [] value_name_buf;
    delete [] value_buf;
 
    remaining_output = text_out.str();
  }

Referenced by process_request().

RecvData()

void RequestHandler::RecvData ( string  input )

inline

Definition at line 46 of file netreg.cpp.

                                {
    full_input += input;
    if( full_input.find( "\r\n\r\n" ) != string::npos ) {
      // Full request received...
      size_t space_pos = full_input.find( ' ' );
      if( space_pos == string::npos ) { state = SHOULD_DIE; return; }
      string method = full_input.substr( 0, space_pos );
      if( method != "GET" ) { state = SHOULD_DIE; return; }
      space_pos++;
      if( full_input[space_pos] != '/' ) { state = SHOULD_DIE; return; }
      space_pos++;
      string reg_key_and_remainder =
    full_input.substr( space_pos, full_input.size() - space_pos );
      space_pos = reg_key_and_remainder.find( ' ' );
      if( space_pos == string::npos ) { state = SHOULD_DIE; return; }
      string reg_key_name = reg_key_and_remainder.substr( 0, space_pos );
      process_request( urldec( reg_key_name ) );
      state = REQUEST_RECVD_SENDING_REPLY;
    }
  }

ShouldDie()

bool RequestHandler::ShouldDie ( ) const

inline

Definition at line 84 of file netreg.cpp.

                         {
    return state == SHOULD_DIE;
  }

urldec()

string RequestHandler::urldec ( string  in )

inlineprivate

Definition at line 112 of file netreg.cpp.

                             {
    string out;
 
    for( string::iterator i = in.begin();
     i != in.end();
     i++ ) {
      if( *i == '%' ) {
    char buf[3];
    int res = ' ';
 
    i++;
    if( i != in.end() ) {
      buf[0] = *i;
      i++;
      if( i != in.end() ) {
        buf[1] = *i;
        buf[2] = 0;
        sscanf( buf, "%x", &res );
        fprintf( stderr, "Interpreting %c%c as %02x\n",
             buf[0], buf[1],
             res );
        out += (char)res;
      }
    }
      } else out += *i;
    }
 
    return out;
  }

Referenced by RecvData().

urlenc()

string RequestHandler::urlenc ( string  in )

inlineprivate

Definition at line 94 of file netreg.cpp.

                             {
    ostringstream out;
 
    for( string::iterator i = in.begin();
     i != in.end();
     i++ ) {
      if( isalnum( *i ) || *i == '/' )
    out << *i;
      else {
    char minibuf[10];
    sprintf( minibuf, "%02x", *i );
    out << "%" << minibuf;
      }
    }
 
    return out.str();
  }

Referenced by process_root_request(), and process_valid_request().

WantPollout()

bool RequestHandler::WantPollout ( ) const

inline

Definition at line 88 of file netreg.cpp.

                           {
    return state == REQUEST_RECVD_SENDING_REPLY;
  }

Member Data Documentation

full_input

string RequestHandler::full_input

private

Definition at line 404 of file netreg.cpp.

Referenced by RecvData().

remaining_output

string RequestHandler::remaining_output

private

Definition at line 405 of file netreg.cpp.

Referenced by OkToSend(), process_invalid_request(), process_root_request(), and process_valid_request().

socket

SOCKET RequestHandler::socket

private

Definition at line 406 of file netreg.cpp.

Referenced by GetSocket(), OkToSend(), and ~RequestHandler().

state

RHState RequestHandler::state

private

Definition at line 407 of file netreg.cpp.

Referenced by OkToSend(), RecvData(), ShouldDie(), and WantPollout().

---

The documentation for this class was generated from the following file:

• modules/rosapps/applications/net/netreg/netreg.cpp