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; }