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