int main(int argc,char** argv) { char property[MAX_PROPERTY]; char value[MAX_VALUE]; char tag[MAX_TAG]; int do_next=0; char* fullurl=NULL; char* baseurl=NULL; if (argc>1) baseurl=argv[1]; while (gettag(stdin,tag)) { if (!IS_LINK_TAG(tag)) continue; DEBUG_PRINT_STR(tag); while (getproperty(stdin,property)) { if (!IS_LINK_PROP(property)) continue; DEBUG_PRINT_STR(property); do_next=getvalue(stdin,value); DEBUG_PRINT_STR(value); if (do_next) { fullurl=getfullurl(value,baseurl); if (fullurl!=NULL) { printf("%s\n",fullurl); free(fullurl); } } } } while (0) { do_next=getproperty(stdin,property); // printf("%s=",property); if (!do_next) break; do_next=getvalue(stdin,value); if (IS_LINK(property)) { fullurl=getfullurl(value,baseurl); if (fullurl!=NULL) { printf("%s\n",fullurl); free(fullurl); } } if (!do_next) break; } return 0; }
sebs_parse_return_t sebs_parse_url(sebs_parser_data_t *pdata) { sebs_parse_url_data_t* fdata = (sebs_parse_url_data_t*) pdata->current_parser.parser_data; if (pdata->function_init) { int i; pdata->function_init = false; fdata->cur_pos = 0; fdata->cur_fig = 0; for (i = 0; i < 8; ++i) fdata->ip.v6[i] = 0; fdata->dot_cnt = 0; //Save current return function fdata->caller.parser_function = pdata->next_parser.parser_function; fdata->caller.parser_data = pdata->next_parser.parser_data; fdata->called_by_handler = pdata->return_to_handler; pdata->return_to_handler = 0; fdata->result = SEBS_PARSE_URL_RESULT_IPV6; fdata->state = SEBS_PARSE_URL_STATE_START; } bool finished = false; bool grabChar = false; while (*pdata->len > 0) { bool malformed = false; switch(fdata->state) { case SEBS_PARSE_URL_STATE_START: DEBUG_PRINT_STR("PARSE URL..."); fdata->state = SEBS_PARSE_URL_STATE_CHECK_SCHEME; SEBS_PARSE_SEEKSTRING_INIT(pdata, fdata->seekstring, fdata->scheme_list, fdata->scheme_list_len, "!*'();:@$=+$,/?%#[]", false, fdata->url_length) ; break; case SEBS_PARSE_URL_STATE_CHECK_SCHEME: fdata->url_scheme=fdata->seekstring.result; if(fdata->url_scheme>=0) { fdata->state=SEBS_PARSE_URL_STATE_CHECK_SCHEME_END; } else { finished=true; fdata->result=SEBS_PARSE_URL_RESULT_ERROR_URL_SCHEME; } break; case SEBS_PARSE_URL_STATE_PARSE_PORT: fdata->state=SEBS_PARSE_URL_STATE_CHECK_PORT; SEBS_PARSE_NUMBERPARSE_INIT(pdata, fdata->numberparse, 5, false, 10); break; case SEBS_PARSE_URL_STATE_CHECK_PORT: switch(fdata->numberparse.result) { case SEBS_PARSE_NUMBERPARSE_ANOTHER_CHAR: if(fdata->numberparse.number>1 && fdata->numberparse.number<0xFFFF) { DEBUG_PRINT_STR("NUMBER!"); fdata->port=fdata->numberparse.number; fdata->state=SEBS_PARSE_URL_STATE_PARSE_WAIT_DASH; } else { malformed=true; } break; case SEBS_PARSE_NUMBERPARSE_MAX_FIGURES: malformed=true; break; case SEBS_PARSE_NUMBERPARSE_ERROR_NONUMBER: malformed=true; break; } break; case SEBS_PARSE_URL_STATE_PARSE_IPV6: fdata->state=SEBS_PARSE_URL_STATE_CHECK_IPV6; SEBS_PARSE_NUMBERPARSE_INIT(pdata, fdata->numberparse, 4, false, 16); break; default: //If non of the states above { switch(**pdata->buf) { case ':': switch(fdata->state) { case SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE: malformed=true; break; case SEBS_PARSE_URL_STATE_CHECK_SCHEME_END: fdata->state=SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE; break; case SEBS_PARSE_URL_STATE_PARSE_IPV4_HOSTNAME: case SEBS_PARSE_URL_STATE_PARSE_HOSTNAME: fdata->state=fdata->state=SEBS_PARSE_URL_STATE_PARSE_PORT; break; case SEBS_PARSE_URL_STATE_CHECK_IPV6: switch(fdata->numberparse.result) { case SEBS_PARSE_NUMBERPARSE_ANOTHER_CHAR: //FIXME - management said: implement that later. ok ok... I 'll do that later. //Notes to implement //Problem: IPv6 has the :: feature for multiple zeros (only allowed once!) //thats no problem but ipv6 has a resolv address feature adding a ipv4 address in the back //unfortunately this is separated through a doublepoint, so we know about if it's a ipv4 resolving part //when the first . is reached... DAMN! //remove numberparse stuff and add it directly here doing Base 16 and Base 10 conversion the same time... //or add that to numberparse... malformed=true; case SEBS_PARSE_NUMBERPARSE_ERROR_NONUMBER: break; case SEBS_PARSE_NUMBERPARSE_MAX_FIGURES: break; } break; default: break; } break; case '.': switch(fdata->state) { case SEBS_PARSE_URL_STATE_PARSE_IPV4_HOSTNAME: if(fdata->dot_cnt < 3) { ++fdata->dot_cnt; fdata->cur_fig=0; } else //If we have more than three dots... it's a hostname { fdata->result=SEBS_PARSE_URL_RESULT_HOSTNAME; fdata->state=fdata->state=SEBS_PARSE_URL_STATE_PARSE_HOSTNAME; } grabChar=true; break; case SEBS_PARSE_URL_STATE_PARSE_HOSTNAME: grabChar=true; break; case SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE: malformed=true; break; default: //TODO check break; } break; case '[': switch(fdata->state) { case SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE: // fdata->result=SEBS_PARSE_URL_RESULT_IPV6; // fdata->state=SEBS_PARSE_URL_STATE_PARSE_IPV6; malformed=true; //TODO REMOVE when implemented break; default: //TODO check break; } break; case '/': switch(fdata->state) { case SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE: break; case SEBS_PARSE_URL_STATE_PARSE_IPV4_HOSTNAME: case SEBS_PARSE_URL_STATE_PARSE_HOSTNAME: case SEBS_PARSE_URL_STATE_PARSE_WAIT_DASH: finished=true; break; default: //TODO check break; } break; default: switch(fdata->state) { case SEBS_PARSE_URL_STATE_ANALYSE_URI_TYPE: case SEBS_PARSE_URL_STATE_PARSE_IPV4_HOSTNAME: if(**pdata->buf>='0' && **pdata->buf<='9') //It's an IP while there are only numbers... { fdata->result=SEBS_PARSE_URL_RESULT_IPV4; fdata->state=fdata->state=SEBS_PARSE_URL_STATE_PARSE_IPV4_HOSTNAME; if(fdata->cur_fig<3) { fdata->ip.v4[fdata->dot_cnt]*=10; fdata->ip.v4[fdata->dot_cnt]+=**pdata->buf-'0'; //convert to integer ++fdata->cur_fig; } else //If there are more than 3 figures, it's a hostname { fdata->result=SEBS_PARSE_URL_RESULT_HOSTNAME; fdata->state=fdata->state=SEBS_PARSE_URL_STATE_PARSE_HOSTNAME; } } else //If there is another char than 0-9 it's a hostname { fdata->result=SEBS_PARSE_URL_RESULT_HOSTNAME; fdata->state=fdata->state=SEBS_PARSE_URL_STATE_PARSE_HOSTNAME; } grabChar=true; break; case SEBS_PARSE_URL_STATE_PARSE_HOSTNAME: grabChar=true; break; default: malformed=true; break; } } if(grabChar) { if(fdata->cur_pos<(__HOSTNAME_BUFFER_LEN__+20)) { fdata->hostname_buf[fdata->cur_pos]=**pdata->buf; fdata->cur_pos++; } else { finished=true; fdata->result=SEBS_PARSE_URL_RESULT_ERROR_URL_MALFORMED; } } if(malformed) { fdata->result=SEBS_PARSE_URL_RESULT_ERROR_URL_MALFORMED; finished=true; } else if(!finished) { ++*pdata->buf; --*pdata->len; ++fdata->url_length; } } break; } if (finished) { //Restore calling function and return pdata->next_parser.parser_function = fdata->caller.parser_function; pdata->next_parser.parser_data = fdata->caller.parser_data; pdata->return_to_handler = fdata->called_by_handler; fdata->hostname_buf[fdata->cur_pos] = '\0'; return (SEBS_PARSE_RETURN_FINISHED); } } return (SEBS_PARSE_RETURN_GO_AHEAD); }
sebs_parse_return_t socket_connect(sebs_parser_data_t* pdata) { socket_connect_data_t* fdata = pdata->current_parser.parser_data; if (pdata->function_init) { pdata->function_init = false; switch (fdata->connect_data->data_state) { case CONNECT_DATA_STATE_URL: { fdata->state = SOCKET_CONNECT_STATE_URL_SCHEME; } break; default: fdata->state = SOCKET_CONNECT_STATE_CONNECT; break; } } char *url = fdata->connect_data->url; while (fdata->state != SOCKET_CONNECT_STATE_ERROR && fdata->state != SOCKET_CONNECT_STATE_CONNECT) { switch (fdata->state) { case SOCKET_CONNECT_STATE_URL_SCHEME: //Maybe seek for string http / rosrpc (we skip that here for now) while (1) { if (*url < 48) break; else if (*url > '9' && *url < 'A') break; else if (*url > 'Z' && *url < 'a') break; else if (*url > 'z') break; else //Next char url++; } bool ok = false; if (*url == ':') if (*(url + 1) == '/') if (*(url + 2) == '/') { ok = true; url += 3; if (*url == '[') { url++; fdata->state = SOCKET_CONNECT_STATE_URL_IPV6; } else { fdata->state = SOCKET_CONNECT_STATE_URL_IPV4_HOSTNAME; } fdata->connect_data->hostname_size = 0; fdata->connect_data->hostname = url; } if (!ok) fdata->state = SOCKET_CONNECT_STATE_ERROR; break; case SOCKET_CONNECT_STATE_URL_IPV6: //NOT SUPPORTED YET fdata->state = SOCKET_CONNECT_STATE_ERROR; break; case SOCKET_CONNECT_STATE_URL_IPV4_HOSTNAME: { fdata->connect_data->data_state=CONNECT_DATA_STATE_IPV4; uint8_t digit=0, dot, *ip = fdata->connect_data->remote_ip; while (1) if ((*url >= '0' && *url <= '9') || *url == '.') { if (*url == '.') { dot++; if (dot == 4) { fdata->state = SOCKET_CONNECT_STATE_URI_HOSTNAME; break; } digit = 0; ip++; } else { digit++; if (digit == 4) { fdata->state = SOCKET_CONNECT_STATE_URI_HOSTNAME; break; } else { if (digit > 1) { (*ip) *= 10; } (*ip) += *url - 48; } } url++; fdata->connect_data->hostname_size++; } else { if (*url == ':') { if (dot == 3) { fdata->state = SOCKET_CONNECT_STATE_URL_PORT; url++; } else { fdata->state=SOCKET_CONNECT_STATE_ERROR; } } else { fdata->state = SOCKET_CONNECT_STATE_URI_HOSTNAME; } break; } break; } case SOCKET_CONNECT_STATE_URL_PORT: { uint8_t digit=0; fdata->connect_data->remote_port=0; while(1) if(*url >= '0' && *url <= '9') { if(digit!=0) { fdata->connect_data->remote_port*=10; } fdata->connect_data->remote_port+=*url-48; digit++; url++; } else { if((*url=='\0' || *url=='/') && digit!=0) { fdata->state=SOCKET_CONNECT_STATE_CONNECT; } else { fdata->state=SOCKET_CONNECT_STATE_ERROR; break; } break; } } break; case SOCKET_CONNECT_STATE_URI_HOSTNAME: while (1) { fdata->connect_data->data_state=CONNECT_DATA_STATE_RESOLVE; if (((*url < 48) || (*url > '9' && *url < 'A') || (*url > 'Z' && *url < 'a') || (*url > 'z')) && *url != '_' && *url != '-' && *url != '.') { if (*url == ':') { fdata->state = SOCKET_CONNECT_STATE_URL_PORT; url++; break; } else { fdata->state = SOCKET_CONNECT_STATE_ERROR; break; } } else { fdata->connect_data->hostname_size++; url++; } } break; } } if(fdata->state == SOCKET_CONNECT_STATE_CONNECT) { DEBUG_PRINT_STR("Connecting to:"); DEBUG_PRINT(INT,"Port",fdata->connect_data->remote_port); DEBUG_PRINT(INT,"IP",fdata->connect_data->remote_ip[0]); DEBUG_PRINT(INT,"IP",fdata->connect_data->remote_ip[1]); DEBUG_PRINT(INT,"IP",fdata->connect_data->remote_ip[2]); DEBUG_PRINT(INT,"IP",fdata->connect_data->remote_ip[3]); pdata->out_len=SOCKET_SIG_CONNECT; printf("Hostname %.*s\n", fdata->connect_data->hostname_size, fdata->connect_data->hostname); return (SEBS_PARSE_RETURN_GO_AHEAD); } else { DEBUG_PRINT_STR("ERROR in connection details!"); fdata->state=CONNECT_DATA_STATE_ERROR; pdata->sending=false; } return (SEBS_PARSE_RETURN_FINISHED); }
sebs_parse_return_t ros_handler(sebs_parser_data_t* pdata) { ros_handler_data_t *hdata=pdata->handler_data; ros_iface_init_t *idata=(ros_iface_init_t*)pdata->init_data; sebs_parse_ros_data_t *fdata=(sebs_parse_ros_data_t *)pdata->current_parser.parser_data; if(pdata->handler_init) { DEBUG_PRINT_STR("ROS HANDLER INIT"); pdata->handler_init=false; pdata->function_init=true; pdata->return_to_handler=false; pdata->overall_len=0; //pdata->security_len=1024; hdata->hstate=ROS_HANDLER_STATE_NONE; hdata->iface_ok=false; hdata->md5sum_ok=false; hdata->publisher_ready=false; pdata->sending=false; if(idata->ros_type==ROS_HANDLER_TYPE_TOPIC_SUBSCRIBER) { hdata->genPayloadData[0]=idata->message_definition; hdata->genPayloadData[1]=idata->md5sum; hdata->genPayloadData[2]=idata->iface_name; hdata->genPayloadData[3]=idata->type_name; hdata->hstate=ROS_HANDLER_STATE_SUBSCRIBER_HEADER_SEND; SEBS_PARSE_MSG_GEN(pdata, hdata->gen, pdata->additional_storage, rosc_static_socket_additional_data_size, MSGGEN_TYPE_ROSMSG_HEADER, 0, hdata->genPayloadData); } else { SEBS_PARSE_ROS_INIT_RPC(pdata,hdata->ros); } } sebs_parse_ros_event_t *ros_event=(sebs_parse_ros_event_t *)&pdata->event; switch (pdata->event) { case SEBS_PARSE_EVENT_LEN_EQUAL_SMALLER_ZERO: switch (*pdata->len) { case SOCKET_SIG_CLOSE: DEBUG_PRINT_STR("ROSHANDLER Connection close"); pdata->out_len = SOCKET_SIG_RELEASE; return (SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_TIMEOUT: DEBUG_PRINT_STR("ROSHANDLER Timeout"); pdata->out_len=SOCKET_SIG_RELEASE; return(SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_NO_CONNECTION: DEBUG_PRINT_STR("ROSHANDLER No Connection"); pdata->out_len=SOCKET_SIG_RELEASE; return(SEBS_PARSE_RETURN_GO_AHEAD); break; /* ***********/ /*Only Client*/ /* ***********/ case SOCKET_SIG_COULD_NOT_CONNECT: DEBUG_PRINT_STR("ROSHANDLER could not connect"); pdata->out_len=SOCKET_SIG_RELEASE; return(SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_COULD_NOT_RESOLVE_HOST: DEBUG_PRINT_STR("ROSHANDLER Resolve Host"); pdata->out_len=SOCKET_SIG_RELEASE; return(SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_CONNECTED: DEBUG_PRINT_STR("CONNECTED"); break; /* SIGNALS which should not occur here: */ case SOCKET_SIG_DATA_SENT: /*should be caught by sending function*/ if(idata->ros_type==ROS_HANDLER_TYPE_TOPIC_PUBLISHER) { hdata->publisher_ready=true; pdata->out_len=SOCKET_SIG_NO_DATA; } else DEBUG_PRINT_STR("ROSHANDLER ignoring unexpected signal Data Sent"); return (SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_RELEASE: /*outgoing*/ DEBUG_PRINT_STR("ROSHANDLER ignoring unexpected signal Release"); return (SEBS_PARSE_RETURN_GO_AHEAD); break; case SOCKET_SIG_CONNECT: /*outgoing*/ DEBUG_PRINT_STR("ROSHANDLER ignoring unexpected signal Connect"); return (SEBS_PARSE_RETURN_GO_AHEAD); break; default: break; } break; } switch(hdata->hstate) { case ROS_HANDLER_STATE_SUBSCRIBER_HEADER_SEND: hdata->hstate=ROS_HANDLER_STATE_NONE; SEBS_PARSE_ROS_INIT_RPC(pdata,hdata->ros); break; case ROS_HANDLER_STATE_CHECK_MD5SUM: if (hdata->ros.seekstring.result==0) { DEBUG_PRINT_STR("MD5SUM OK!"); hdata->md5sum_ok=false; } else { DEBUG_PRINT_STR("MD5SUM DOES NOT MATCH!!!!"); } hdata->ros.field_length-=hdata->ros.seekstring.curChrPos; hdata->ros.message_length-=hdata->ros.seekstring.curChrPos; break; case ROS_HANDLER_STATE_CHECK_IFACE_NAME: if (hdata->ros.seekstring.result==0) { DEBUG_PRINT_STR("IFACE NAME OK!"); hdata->iface_ok=false; } else { DEBUG_PRINT_STR("IFACE NAME DOES NOT MATCH!!!!"); } hdata->ros.field_length-=hdata->ros.seekstring.curChrPos; hdata->ros.message_length-=hdata->ros.seekstring.curChrPos; break; case ROS_HANDLER_STATE_NONE: switch(*ros_event) { case SEBS_PARSE_ROS_EVENT_RPC_FIELD_START: DEBUG_PRINT(STR,"Field",ros_field_strings[hdata->ros.rpc_field_id]); DEBUG_PRINT(INT,"Field Content Length", hdata->ros.field_length); /* ******************** ROS RPC INFO **********************/ switch(hdata->ros.rpc_field_id) { case SEBS_PARSE_ROS_FIELD_MD5SUM: switch(idata->ros_type) { case ROS_HANDLER_TYPE_TOPIC_SUBSCRIBER: case ROS_HANDLER_TYPE_TOPIC_PUBLISHER: case ROS_HANDLER_TYPE_SERVICE_CLIENT: case ROS_HANDLER_TYPE_SERVICE_SERVER: hdata->hstate=ROS_HANDLER_STATE_CHECK_MD5SUM; SEBS_PARSE_SEEKSTRING_INIT(pdata,hdata->ros.seekstring,(const char**)&idata->md5sum, 1, "",true, hdata->ros.field_length); break; default: break; } break; case SEBS_PARSE_ROS_FIELD_SERVICE: case SEBS_PARSE_ROS_FIELD_TOPIC: switch(idata->ros_type) { case ROS_HANDLER_TYPE_TOPIC_SUBSCRIBER: case ROS_HANDLER_TYPE_TOPIC_PUBLISHER: case ROS_HANDLER_TYPE_SERVICE_CLIENT: case ROS_HANDLER_TYPE_SERVICE_SERVER: hdata->hstate=ROS_HANDLER_STATE_CHECK_IFACE_NAME; SEBS_PARSE_SEEKSTRING_INIT(pdata,hdata->ros.seekstring,(const char**)&idata->iface_name, 1, "",true, hdata->ros.field_length); break; } } break; case SEBS_PARSE_ROS_EVENT_MESSAGE_END: DEBUG_PRINT_STR("HANDLER: MESSAGE END!") switch(idata->ros_type) { case ROS_HANDLER_TYPE_TOPIC_PUBLISHER: DEBUG_PRINT_STR("Publisher: Send header!"); fdata->mode=SEBS_PARSE_ROS_MODE_BINARY; hdata->publisher_ready=true; hdata->genPayloadData[0]=idata->message_definition; hdata->genPayloadData[1]=idata->md5sum; hdata->genPayloadData[2]=idata->iface_name; hdata->genPayloadData[3]="narf"; hdata->hstate=ROS_HANDLER_STATE_SUBSCRIBER_HEADER_SEND; SEBS_PARSE_MSG_GEN(pdata, hdata->gen, pdata->additional_storage, rosc_static_socket_additional_data_size, MSGGEN_TYPE_ROSMSG_HEADER, 0, hdata->genPayloadData); break; case ROS_HANDLER_TYPE_TOPIC_SUBSCRIBER: switch(fdata->mode) { case SEBS_PARSE_ROS_MODE_ROSRPC: DEBUG_PRINT_STR("ROSRPC END->BINARY PARSING..."); SEBS_PARSE_ROS_INIT_MSG(pdata,hdata->ros,idata->buildup,idata->submessage_sizes,idata->array_lengths,idata->memory_offsets,idata->message_definition,pdata->additional_storage,pdata->additional_storage+idata->submessage_states_offset); break; case SEBS_PARSE_ROS_MODE_BINARY: DEBUG_PRINT_STR("BINARY END... CALLBACK!") idata->callback(fdata->msg_storage); SEBS_PARSE_ROS_INIT_MSG(pdata,hdata->ros,idata->buildup,idata->submessage_sizes,idata->array_lengths,idata->memory_offsets,idata->message_definition,pdata->additional_storage,pdata->additional_storage+idata->submessage_states_offset); break; } break; default: ROSC_FATAL("ros handler: Not a ros handler type!"); break; } break; default: //TODO check break; } break; } hdata->hstate=ROS_HANDLER_STATE_NONE; return (SEBS_PARSE_RETURN_GO_AHEAD); }
void rosc_spin() { int i; while(1) { usleep(10); //Check for interface tasks iface_t *iface=interface_list_start; socket_t* con_sock=socket_list_start; while(iface) { //Check for available interface while(con_sock) { /** \todo port reservation for xmlrpc */ if(con_sock->state==SOCKET_STATE_INACTIVE /*&& ( con_sock->reserved == 0 || con_sock->reserved == iface_rpc_client) */) { break; } con_sock=con_sock->next; } if(con_sock) { switch(iface->state) { case IFACE_STATE_DO_REGISTER: case IFACE_STATE_DO_UNREGISTER: if(iface->handler_function==&ros_handler) { xmlrpc_data_t *hdata=con_sock->pdata.handler_data; hdata->client_type=(iface->state==IFACE_STATE_DO_REGISTER)? XMLRPC_CLIENT_TYPE_REGISTER: XMLRPC_CLIENT_TYPE_UNREGISTER; iface->state=IFACE_STATE_STATE_OPERATION_PENDING; con_sock->iface=iface; con_sock->state=SOCKET_STATE_NOT_CONNECTED; con_sock->pdata.init_data=iface; con_sock->pdata.handler_init=true; con_sock->pdata.handler_function=&xmlrpc; con_sock->pdata.connection_interface=con_sock; //Init here, because the memory can change later ... //TODO probably unnecessary call when later the init of the rpc points only to current iface sebs_parser_frame(0,SOCKET_SIG_NO_CONNECTION,&con_sock->pdata); } break; break; default: break; } } iface=iface->next; } //Connect Interfaces con_sock=socket_list_start; while(con_sock) { if(/*con_sock->state==SOCKET_STATE_WAITING_FOR_CONNECTION &&*/ con_sock->pdata.out_len==SOCKET_SIG_CONNECT) { con_sock->pdata.out_len=SOCKET_SIG_NO_DATA; socket_connect_info_t* connect_data=&con_sock->connect_info; //TODO remove that variable if(connect_data->data_state==CONNECT_DATA_STATE_RESOLVE) { if(!rosc_hostlist_resolve(connect_data->hostname,connect_data->hostname_size, connect_data->remote_ip)) connect_data->data_state=CONNECT_DATA_STATE_IPV4; } if(connect_data->data_state==CONNECT_DATA_STATE_IPV4) { con_sock->socket_id=abstract_connect_socket(connect_data->remote_ip,connect_data->remote_port); if(con_sock->socket_id>0) { con_sock->state=SOCKET_STATE_CONNECTED; sebs_parser_frame(0,SOCKET_SIG_CONNECTED,&con_sock->pdata); } else sebs_parser_frame(0,SOCKET_SIG_COULD_NOT_CONNECT,&con_sock->pdata); } else { sebs_parser_frame(0,SOCKET_SIG_COULD_NOT_RESOLVE_HOST,&con_sock->pdata); } } con_sock=con_sock->next; } //Check for new connections on the listen ports listen_socket_t *listen_sock=listen_socket_list_start; int i; while(listen_sock) { socket_t* con_sock=socket_list_start; while(con_sock) { if(con_sock->state==SOCKET_STATE_INACTIVE && ( con_sock->reserved == 0 || con_sock->reserved == listen_sock->interface)) { break; } con_sock=con_sock->next; } if(con_sock) { socket_id_t con_sock_id = abstract_socket_accept(listen_sock->id); if(con_sock_id >= 0) { con_sock->socket_id=con_sock_id; con_sock->state=SOCKET_STATE_CONNECTED; con_sock->pdata.out_len=SOCKET_SIG_NO_DATA; con_sock->iface=listen_sock->interface; con_sock->pdata.handler_init=true; con_sock->pdata.handler_function=listen_sock->interface->handler_function; con_sock->pdata.init_data=listen_sock->interface->init_data; DEBUG_PRINT_STR("New connection ... "); } } listen_sock=listen_sock->next; } //Receive incoming data char buffer[30000]; int size=3; int s; con_sock=socket_list_start; while(con_sock) { if(con_sock->state!=SOCKET_STATE_INACTIVE) { bool had_data=false; do { switch(con_sock->state) { case SOCKET_STATE_CONNECTED: s=recv_packet(con_sock->socket_id,buffer,size); break; case SOCKET_STATE_NOT_CONNECTED: s=SOCKET_SIG_NO_CONNECTION; break; case SOCKET_STATE_WAITING_FOR_CONNECTION: break; default: break; } //if(s!=SOCKET_SIG_NO_DATA) { sebs_parser_frame(buffer,s, &con_sock->pdata); while(con_sock->pdata.out_len>0) { unsigned sig; switch(abstract_send_packet(con_sock->socket_id,con_sock->pdata.out_buf,con_sock->pdata.out_len)) { case SEND_RESULT_OK: sig=SOCKET_SIG_DATA_SENT; // con_sock->pdata.out_len=0; break; } sebs_parser_frame(0,sig, &con_sock->pdata); } switch(con_sock->pdata.out_len) { case SOCKET_SIG_CONNECT: break; case SOCKET_SIG_CLOSE: DEBUG_PRINT_STR("Closing socket!"); abstract_close_socket(con_sock->socket_id); con_sock->state=SOCKET_STATE_NOT_CONNECTED; break; case SOCKET_SIG_RELEASE: DEBUG_PRINT_STR("Release socket memory!"); abstract_close_socket(con_sock->socket_id); con_sock->state=SOCKET_STATE_INACTIVE; break; case SOCKET_SIG_NO_DATA: //Do nothing break; default: //Do nothing break; } } }while(s>0 && con_sock->state!=SOCKET_STATE_INACTIVE); if(had_data) printf("\n"); } con_sock=con_sock->next; } } }
sebs_parse_return_t sebs_parse_numberparse(sebs_parser_data_t *pdata) //work around for inlining the function { sebs_parse_numberparse_data_t *fdata=(sebs_parse_numberparse_data_t *)pdata->current_parser.parser_data; if(pdata->function_init) { pdata->function_init=false; fdata->cur_place=0; fdata->number=0; #ifdef __DEBUG__PRINTS__ if(fdata->base>36) { DEBUG_PRINT_STR("NUMBERPARSE_BASE_ERROR! BASE MUST BE SMALLER THAN 36!"); while(1); }else if(fdata->base>16) { DEBUG_PRINT_STR("WARNING NUMBERPARSE: You are using a base greater than 16! What the hell are you up for? Is that intended!?!?"); } #endif } while(*pdata->len > 0) { bool isFigure=false; uint8_t figureConvertValue; //Check if char is a figure ... if(**pdata->buf>='0' && **pdata->buf<=('9'+fdata->base-10)) { isFigure=true; figureConvertValue='0'; } else if(**pdata->buf>='a' && **pdata->buf<=('a'+fdata->base-10) && (fdata->base>10)) { isFigure=true; figureConvertValue='a'-10; } else if(**pdata->buf>='A' && **pdata->buf<=('A'+fdata->base-10) && fdata->base>10) { isFigure=true; figureConvertValue='A'-10; } if(isFigure) { if(fdata->cur_place < fdata->figure_max)//Is the length still acceptable? { if(fdata->cur_place>0) fdata->number*=fdata->base;//multiply current number by 10 to shift it left fdata->number+=**pdata->buf-figureConvertValue; //convert char to integer ++fdata->cur_place; ++*pdata->buf; --*pdata->len; } else { fdata->result=SEBS_PARSE_NUMBERPARSE_MAX_FIGURES; return(SEBS_PARSE_RETURN_FINISHED); } } else { if(fdata->cur_place == 0) //Are we still at the beginning? { if(**pdata->buf=='-' && fdata->negative_allowed)//Is it a negative number? { fdata->negative=true; ++*pdata->buf; --*pdata->len; break; } else { fdata->result=SEBS_PARSE_NUMBERPARSE_ERROR_NONUMBER; return(SEBS_PARSE_RETURN_FINISHED); } } else { fdata->result=SEBS_PARSE_NUMBERPARSE_ANOTHER_CHAR; fdata->last_byte=**pdata->buf; return(SEBS_PARSE_RETURN_FINISHED); } break; } } return(SEBS_PARSE_RETURN_GO_AHEAD); }