int main()
{
//mysql_start();
print_header();
print_html_header(titel_);
//var_copy=getenv("QUERY_STRING");
parse_content(getdata_force("GET"), "=", "&", "POST");
parse_content(getdata_force("POST"), "=", "&", "GET");
//parse_content(getdata_force("POST"), "=", "&", "POST");
// parse_content(getdata_force("POST"), "=", "&", 0);
// printf("%s\n%s", getdata_force("GET"),getdata_force("POST"));
//char *post_query=(char*) malloc(100 * sizeof(char));
//char *get_query=(char*) malloc(strlen(default_string)*100* sizeof(char));
//sprintf(post_query, "%s", getdata_force("POST"));
//sprintf(get_query, "%s", getdata_force("GET"));
// printf("%s", post_query);
//strcpy(get_query, getdata_force("GET"));
/*if(strcmp(_GET[0][0],"method")==0){
if(strcmp(_GET[0][1], "normal")==0){
if(strcmp(_GET[1][0],"action")==0){
if(strcmp(_GET[1][1],"post")==0){
char *content_length = getenv("CONTENT_LENGTH");
if(content_length==NULL){
goto exit;
}
else{
size = (unsigned long) atoi(content_length);
if(size<=0){
goto exit;
}else{
content_post = (char *) malloc(size+1);
if(content_post==NULL){
free(content_post);
goto exit;
}*/
//scanf("%s", post_var);
//printf("%s", post_query);
//parse_content(post_query, "=", "&", "POST");
printf("<h1>!%s!!</h1>", _POST[0][1]);
//printf("Hallo!!!%s", _POST[0][1]);
//printf("%d", (int)strlen(*_POST[0]));
// for(a=0;a<(int)strlen(_POST[a]))
//for(b=0;b<(int)strlen(_POST[0][1]);b++){
// stringReplace("+", "", _POST[0][1]);
//}
printf("\n%s=%s\n", _POST[0][0],_POST[0][1]);
add_tag("ul", "style={float:left;} id='left' class='left'");
addslash("ul");
//free(content_post);
//goto exit;
}
void
CClientMimeHandler::body()
{
theBody->type = TYPEOTHER;
Iterator_t lChildIter;
Item lChild;
String lNodeName;
lChildIter = theBodyItem.getChildren();
lChildIter->open();
while (lChildIter->next(lChild)) {
if (lChild.getNodeKind() != store::StoreConsts::elementNode) {
continue;
}
getNodeName(lChild, lNodeName);
if (lNodeName == "content") {
parse_content(theBody, lChild);
}
else if (lNodeName == "multipart") {
parse_multipart(theBody, lChild);
}
}
lChildIter->close();
}
static void
parse_file(const std::string &file_name) {
mm_file_io_c in(file_name);
g_in = ∈
g_file_size = in.get_size();
g_start = std::min(g_file_size, g_start);
g_end = std::min(g_file_size, g_end);
if (!in.setFilePointer2(g_start))
mxerror(boost::format(Y("Error: Seek to %1%\n")) % g_start);
parse_content(0, g_end);
}
static void
parse_content(int level,
int64_t end_pos) {
while (static_cast<int64_t>(g_in->getFilePointer()) < end_pos) {
int64_t element_start_pos = g_in->getFilePointer();
try {
vint_c id = read_id(end_pos);
vint_c size = read_size(end_pos);
std::string element_name = g_element_names[id.value];
if (element_name.empty())
element_name = Y("unknown");
mxinfo(boost::format(Y("%1%pos %2% id 0x%|3$x| size %4% header size %5% (%6%)\n"))
% level_string(level) % element_start_pos % id.value % size.value % (id.coded_size + size.coded_size) % element_name);
if (size.is_unknown()) {
mxinfo(boost::format(Y("%1% Warning: size is coded as 'unknown' (all bits are set)\n")) % level_string(level));
// In Matroska segments often have an unknown size – so don't
// warn about it.
if (element_name != "Segment")
g_warnings_found = true;
}
int64_t content_end_pos = size.is_unknown() ? end_pos : g_in->getFilePointer() + size.value;
if (content_end_pos > end_pos) {
mxinfo(boost::format(Y("%1% Error: Element ends after scope\n")) % level_string(level));
g_errors_found = true;
if (!g_in->setFilePointer2(end_pos))
mxerror(boost::format(Y("Error: Seek to %1%\n")) % end_pos);
return;
}
if (g_is_master[id.value])
parse_content(level + 1, content_end_pos);
if (!g_in->setFilePointer2(content_end_pos))
mxerror(boost::format(Y("Error: Seek to %1%\n")) % content_end_pos);
} catch (id_error_c &error) {
std::string message
= id_error_c::end_of_file == error.code ? Y("End of file")
: id_error_c::end_of_scope == error.code ? Y("End of scope")
: id_error_c::first_byte_is_zero == error.code ? Y("First byte is zero")
: id_error_c::longer_than_four_bytes == error.code ? Y("ID is longer than four bytes")
: Y("reason is unknown");
mxinfo(boost::format(Y("%1%Error at %2%: error reading the element ID (%3%)\n")) % level_string(level) % element_start_pos % message);
g_errors_found = true;
if (!g_in->setFilePointer2(end_pos))
mxerror(boost::format(Y("Error: Seek to %1%\n")) % end_pos);
return;
} catch (size_error_c &error) {
std::string message
= size_error_c::end_of_file == error.code ? Y("End of file")
: size_error_c::end_of_scope == error.code ? Y("End of scope")
: Y("reason is unknown");
mxinfo(boost::format(Y("%1%Error at %2%: error reading the element size (%3%)\n")) % level_string(level) % element_start_pos % message);
g_errors_found = true;
if (!g_in->setFilePointer2(end_pos))
mxerror(boost::format(Y("Error: Seek to %1%\n")) % end_pos);
return;
} catch (...) {
mxerror(Y("Unknown error occured\n"));
}
}
}
bool ScanDataBuilder::Parse(char*& buffer, size_t& size) {
char* prev_buf = NULL;
bool success;
while (method_index <= 25) {
// std::cout << "method index: " << method_index <<std::endl;
prev_buf = buffer;
switch (method_index) {
case -1:
success = parse_byte(buffer, size, lms100_cola::STX_BYTE);
break;
case 0:
success = parse_command_type(buffer, size, data);
break;
case 1:
success = parse_command(buffer, size, data);
break;
case 2:
success = parse_version_number(buffer, size, data);
break;
case 3:
success = parse_device_number(buffer, size, data);
break;
case 4:
success = parse_serial_number(buffer, size, data);
break;
case 5:
success = parse_device_status(buffer, size, data);
break;
case 6:
success = parse_telegram_counter(buffer, size, data);
break;
case 7:
success = parse_scan_counter(buffer, size, data);
break;
case 8:
success = parse_time_since_startup(buffer, size, data);
break;
case 9:
success = parse_time_of_transmission(buffer, size, data);
break;
case 10:
success = parse_status_of_digital_inputs(buffer, size, data);
break;
case 11:
success = parse_status_of_digital_outputs(buffer, size, data);
break;
case 12:
success = parse_reserved_byte(buffer, size, data);
break;
case 13:
success = parse_scan_frequency(buffer, size, data);
break;
case 14:
success = parse_measurement_frequency(buffer, size, data);
break;
case 15:
success = parse_encoders(buffer, size, data);
break;
case 16:
success = parse_amount_of_16_bit_channels(buffer, size, data);
break;
case 17:
success = parse_content(buffer, size, data);
break;
case 18:
success = parse_scale_factor(buffer, size, data);
break;
case 19:
success = parse_scale_factor_offset(buffer, size, data);
break;
case 20:
success = parse_start_angle(buffer, size, data);
break;
case 21:
success = parse_steps(buffer, size, data);
break;
case 22:
success = parse_amount_of_data(buffer, size, data);
break;
case 23:
success = parse_data(buffer, size, data);
break;
case 24:
success = parse_irrelevant_data(buffer, size);
break;
case 25:
success = parse_byte(buffer, size, lms100_cola::ETX_BYTE);
break;
default:
return false;
}
// method didn't have enough data to parse
if (!success) {
return false;
}
method_index += 1;
}
return true;
}
void as_loadvars::advance(float delta_time)
{
lfl_string str;
for(int i=0;i<m_requests.size();++i)
{
request_data & request = m_requests[i];
while(request.m_ns->is_readable())
{
int byte_read = request.m_ns->read_line(&str, 100000, 0);
if( byte_read == -1 || request.m_state == PARSE_END )
{
//Handle end of connection
if( request.m_target )
{
as_value function;
if (request.m_target->get_member("onHttpStatus", &function))
{
as_environment env(get_player());
env.push(request.m_http_status);
call_method(function, &env, request.m_target, 0, env.get_top_index());
}
if (request.m_target->get_member("onLoad", &function))
{
as_environment env(get_player());
env.push(request.m_state != PARSE_END);
call_method(function, &env, request.m_target, 1, env.get_top_index());
}
if (request.m_target->get_member("onData", &function))
{
as_environment env(get_player());
env.push(request.m_rawdata);
call_method(function, &env, request.m_target, 1, env.get_top_index());
}
}
get_root()->remove_listener(this);
delete request.m_ns;
delete request.m_iface;
m_requests.remove(i);
i--;
return;
}
switch(request.m_state)
{
case PARSE_REQUEST:
parse_request(str, request);
break;
case PARSE_HEADER:
parse_header(str, request);
break;
case PARSE_CONTENT:
parse_content(str, request);
break;
}
str.clear();
}
}
}
int main( int argc, char* argv[] )
{
if( argc <= 2 )
{
printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
return 1;
}
const char* ip = argv[1];
int port = atoi( argv[2] );
struct sockaddr_in address;
bzero( &address, sizeof( address ) );
address.sin_family = AF_INET;
inet_pton( AF_INET, ip, &address.sin_addr );
address.sin_port = htons( port );
int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
assert( listenfd >= 0 );
int ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
assert( ret != -1 );
ret = listen( listenfd, 5 );
assert( ret != -1 );
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof( client_address );
int fd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
if( fd < 0 )
{
printf( "errno is: %d\n", errno );
}
else
{
char buffer[ BUFFER_SIZE ];
memset( buffer, '\0', BUFFER_SIZE );
int data_read = 0;
int read_index = 0;
int checked_index = 0;
int start_line = 0;
CHECK_STATE checkstate = CHECK_STATE_REQUESTLINE;
while( 1 )
{
data_read = recv( fd, buffer + read_index, BUFFER_SIZE - read_index, 0 );
if ( data_read == -1 )
{
printf( "reading failed\n" );
break;
}
else if ( data_read == 0 )
{
printf( "remote client has closed the connection\n" );
break;
}
read_index += data_read;
HTTP_CODE result = parse_content( buffer, checked_index, checkstate, read_index, start_line );
if( result == NO_REQUEST )
{
continue;
}
else if( result == GET_REQUEST )
{
send( fd, szret[0], strlen( szret[0] ), 0 );
break;
}
else
{
send( fd, szret[1], strlen( szret[1] ), 0 );
break;
}
}
close( fd );
}
close( listenfd );
return 0;
}
int main(int argc, const char *argv[])
{
if (argc <= 2)
{
fprintf(stdout, "usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = socket(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
int ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int fd = accept(listenfd, (struct sockaddr *)&client_address, &client_addrlength);
if (fd < 0)
{
fprintf(stderr, "accept error! errno:%d, errstr:%s\n", errno, strerror(errno));
}
else
{
char buffer[BUFFER_SIZE]; /* reading buffer */
memset(buffer, '\0', BUFFER_SIZE);
int data_read = 0;
int read_index = 0;
int checked_index= 0; /*how many bytes data have read from request,currently*/
int start_line = 0; /*the start postion of row in buffer */
/*set the main state machine's initial state */
CHECK_STATE checkstate = CHECK_STATE_REQUESTLINE;
while(1)
{
data_read = recv(fd, buffer + read_index, BUFFER_SIZE - read_index, 0);
if(data_read == -1)
{
fprintf(stderr, "read falied, sockfd:%d\n", fd);
break;
}
else if (data_read == 0)
{
fprintf(stdout, "remote client has closed the connection\n");
break;
}
read_index += data_read;
/*analyze data which has read from client */
HTTP_CODE result = parse_content(buffer, checked_index, checkstate,
read_index, start_line);
if (result == NO_REQUEST)
{
continue;
}
else if (result == GET_REQUEST)
{
send(fd, szret[0], strlen(szret[0]), 0);
break;
}
else
{
send(fd, szret[1], strlen(szret[1]), 0);
break;
}
}
close(fd);
}
close(listenfd);
return 0;
}
