自学教程：C++ uip_abort函数代码示例

/*---------------------------------------------------------------------------*/voidhttpd_appcall(void *state){  struct httpd_state *s = (struct httpd_state *)state;  if(uip_closed() || uip_aborted() || uip_timedout()) {    if(s != NULL) {      memb_free(&conns, s);    }  } else if(uip_connected()) {    s = (struct httpd_state *)memb_alloc(&conns);    if(s == NULL) {      uip_abort();      return;    }    tcp_markconn(uip_conn, s);    PSOCK_INIT(&s->sin, s->inputbuf, sizeof(s->inputbuf) - 1);    PSOCK_INIT(&s->sout, s->inputbuf, sizeof(s->inputbuf) - 1);    PT_INIT(&s->outputpt);    s->state = STATE_WAITING;    timer_set(&s->timer, CLOCK_SECOND * 10);    handle_connection(s);  } else if(s != NULL) {    if(uip_poll()) {      if(timer_expired(&s->timer)) {	uip_abort();      }    } else {      timer_reset(&s->timer);    }    handle_connection(s);  } else {    uip_abort();  }}

/*---------------------------------------------------------------------------*/voidhttpd_appcall(void){  struct httpd_state *s = (struct httpd_state *)&(uip_conn->appstate);  if(uip_closed() || uip_aborted() || uip_timedout()) {  } else if(uip_connected()) {    PSOCK_INIT(&s->sin, s->inputbuf, sizeof(s->inputbuf) - 1);    PSOCK_INIT(&s->sout, s->inputbuf, sizeof(s->inputbuf) - 1);    PT_INIT(&s->outputpt);    s->state = STATE_WAITING;    /*    timer_set(&s->timer, CLOCK_SECOND * 100);*/    s->timer = 0;    handle_connection(s);  } else if(s != NULL) {    if(uip_poll()) {      ++s->timer;      if(s->timer >= 20) {	uip_abort();      }    } else {      s->timer = 0;    }    handle_connection(s);  } else {    uip_abort();  }}

/*-----------------------------------------------------------------------------------*/voidwebclient_appcall(void){  if(uip_connected()) {    s.timer = 0;    s.state = WEBCLIENT_STATE_STATUSLINE;    senddata();    webclient_connected();    return;  }  if(s.state == WEBCLIENT_STATE_CLOSE) {    webclient_closed();    uip_abort();    return;  }  if(uip_aborted()) {    webclient_aborted();  }  if(uip_timedout()) {    webclient_timedout();  }    if(uip_acked()) {    s.timer = 0;    acked();  }  if(uip_newdata()) {    s.timer = 0;    newdata();  }  if(uip_rexmit() ||     uip_newdata() ||     uip_acked()) {    senddata();  } else if(uip_poll()) {    ++s.timer;    if(s.timer == WEBCLIENT_TIMEOUT) {      webclient_timedout();      uip_abort();      return;    }        /*    senddata();*/  }  if(uip_closed()) {    if(s.httpflag != HTTPFLAG_MOVED) {      /* Send NULL data to signal EOF. */      webclient_datahandler(NULL, 0);    } else {      if(resolv_lookup(s.host) == NULL) {	resolv_query(s.host);      }      webclient_get(s.host, s.port, s.file);    }  }}

/* identify_data(): * * This function looks at the state of the connection (i.e., if it is * handshaking or in steady-state) as well as on the contents of the * incoming message and returns the number of bytes of data that is to * be expected. */static uint16_tidentify_data(CC_REGISTER_ARG uint8_t *data, uint16_t datalen){  switch(vs->waitmsg) {  case VNC_WAIT_VERSION:    /* Expecting version string (12 bytes). */    return 12;    break;  case VNC_WAIT_AUTH:    return 4;    break;  case VNC_WAIT_AUTH_RESPONSE:    return 1;    break;  case VNC_WAIT_SINIT:    /* XXX: We should check that the entire message header is       received, otherwise we should buffer it. */    return sizeof(struct rfb_server_init) +      ((struct rfb_server_init *)uip_appdata)->namelength[3] +      ((struct rfb_server_init *)uip_appdata)->namelength[2];      case VNC_WAIT_UPDATE:  case VNC_WAIT_NONE:    switch(*data) {    case RFB_FB_UPDATE:      PRINTF(("RFB FB UPDATE received/n"));      return sizeof(struct rfb_fb_update);          case RFB_BELL:      return 1;    case RFB_SERVER_CUT_TEXT:      PRINTF(("Cut text received, unhandled/n"));      return 8 + (data[6] << 8) + data[7];    case RFB_SET_COLORMAP_ENTRIES:      uip_abort();      PRINTF(("Set colormap entries received, unhandled/n"));      return 0;          default:      uip_abort();      PRINTF(("Weird message type received (%d)/n", *(uint8_t *)uip_appdata));      return 0;    }    break;      case VNC_WAIT_UPDATE_RECT:    return sizeof(struct rfb_fb_update_rect_hdr);  default:    PRINTF(("identify: bad waitmsg %d/n", vs->waitmsg));  }    return 0;}

/* next_sciptstate: * * Reads one line of script and decides what to do next. */static voidnext_scriptstate(void){  struct httpd_fs_file fsfile;  u8_t i; again:  switch(hs->script[0]) {  case ISO_t:    /* Send a text string. */    hs->state = HTTP_TEXT;    hs->dataptr = &hs->script[2];    /* Calculate length of string. */    for(i = 0; hs->dataptr[i] != ISO_nl; ++i);    hs->count = i;        break;  case ISO_c:    /* Call a function. */    hs->state = HTTP_FUNC;    hs->dataptr = NULL;    hs->count = 0;    uip_reset_acked();    break;  case ISO_i:       /* Include a file. */    hs->state = HTTP_FILE;    if(!httpd_fs_open(&hs->script[2], &fsfile)) {      uip_abort();      dealloc_state(hs);    }    hs->dataptr = fsfile.data;    hs->count = fsfile.len;    break;  case ISO_hash:    /* Comment line. */    next_scriptline();    goto again;    break;  case ISO_period:    /* End of script. */    hs->state = HTTP_END;    uip_close();    dealloc_state(hs);    break;  default:    uip_abort();    dealloc_state(hs);    break;  }}

/*---------------------------------------------------------------------------*/voidhttpd_appcall(void *state){#if DEBUGLOGIC  struct httpd_state *s;   //Enter here for debugging with output directed to TCPBUF  s = sg = (struct httpd_state *)memb_alloc(&conns);  if (1) {#else  struct httpd_state *s = (struct httpd_state *)state;  if(uip_closed() || uip_aborted() || uip_timedout()) {    if(s != NULL) {      memb_free(&conns, s);    }  } else if(uip_connected()) {    s = (struct httpd_state *)memb_alloc(&conns);    if(s == NULL) {      uip_abort();      return;    }#endif    tcp_markconn(uip_conn, s);    PSOCK_INIT(&s->sin, (uint8_t *)s->inputbuf, sizeof(s->inputbuf) - 1);    PSOCK_INIT(&s->sout, (uint8_t *)s->inputbuf, sizeof(s->inputbuf) - 1);    PT_INIT(&s->outputpt);    s->state = STATE_WAITING;    /*    timer_set(&s->timer, CLOCK_SECOND * 100);*/    s->timer = 0;    handle_connection(s);  } else if(s != NULL) {    if(uip_poll()) {      ++s->timer;      if(s->timer >= 20) {        uip_abort();        memb_free(&conns, s);      }    } else {      s->timer = 0;    }    handle_connection(s);  } else {    uip_abort();  }}/*---------------------------------------------------------------------------*/voidhttpd_init(void){  tcp_listen(UIP_HTONS(80));  memb_init(&conns);  httpd_cgi_init();}

/******************************************************************************* void exosite_appcall(void)** This function is uIP's application function.  It is called whenever a uIP * event occurs (e.g. when a new connection is established, new data arrives, * sent data is acknowledged, data needs to be retransmitted, etc.).* ******************************************************************************/ void exosite_appcall(void){  if(uip_connected()) {    s.timer = 0;    senddata();    return;  }  if(s.state == EXO_STATE_CLOSE) {    uip_abort();    return;  }    if(uip_aborted()) {  }  if(uip_timedout()) {  }  if(uip_acked()) {    s.timer = 0;    acked();  }  if(uip_newdata()) {    s.timer = 0;    newdata();  }   if(uip_rexmit() || uip_newdata() || uip_acked()) {    senddata();  } else if(uip_poll()) {    ++s.timer;    if(s.timer == EXO_TIMEOUT) {      uip_abort();      return;    }  }#if 0    if(uip_closed()) {    if(s.httpflag != HTTPFLAG_MOVED) {      memset(s.rxdata,0,sizeof(s.rxdata));    } else {      if(resolv_lookup(s.host) == NULL) {	      resolv_query(s.host);      }    }  }#endif}

/*---------------------------------------------------------------------------*/staticPT_THREAD(handle_output(struct httpd_state *s)){  PT_BEGIN(&s->outputpt);  s->fd = cfs_open(s->filename, CFS_READ);  if(s->fd < 0) {    s->fd = cfs_open("404.html", CFS_READ);    if(s->fd < 0) {      uip_abort();      PT_EXIT(&s->outputpt);    }    PT_WAIT_THREAD(&s->outputpt,		   send_headers(s, "HTTP/1.0 404 Not found/r/n"));    PT_WAIT_THREAD(&s->outputpt,		   send_file(s));  } else {    PT_WAIT_THREAD(&s->outputpt,		   send_headers(s, "HTTP/1.0 200 OK/r/n"));    PT_WAIT_THREAD(&s->outputpt,		   send_file(s));    cfs_close(s->fd);  }  PSOCK_CLOSE(&s->sout);  PT_END(&s->outputpt);}

/* webclient_datahandler(): * * Callback function. Called from the webclient module when HTTP data * has arrived. */voidwebclient_datahandler(char *data, u16_t len){  if(len > 0) {    if(strcmp(webclient_mimetype(), http_texthtml) == 0) {      count = (count + 1) & 3;      show_statustext(receivingmsgs[count]);      htmlparser_parse(data, len);      redraw_window();    } else {      uip_abort();#if WWW_CONF_WITH_WGET      ctk_dialog_open(&wgetdialog);#endif /* WWW_CONF_WITH_WGET */    }  } else {    /* Clear remaining parts of page. */    loading = 0;  }    if(data == NULL) {    loading = 0;    show_statustext("Done.");    petsciiconv_topetscii(&webpage[(WWW_CONF_WEBPAGE_HEIGHT - 1) *				   WWW_CONF_WEBPAGE_WIDTH], WWW_CONF_WEBPAGE_WIDTH);    CTK_WIDGET_FOCUS(&mainwindow, &urlentry);    redraw_window();  }}

/*---------------------------------------------------------------------*/PROCESS_THREAD(tcp_loader_process, ev, data){  PROCESS_BEGIN();    tcp_listen(HTONS(CODEPROP_DATA_PORT));    while(1) {    PROCESS_YIELD();    if(ev == tcpip_event && uip_conn->lport == HTONS(CODEPROP_DATA_PORT)) {      if(uip_connected()) {	/* Really uip_connecting()!!! */	if(data == NULL) {	  PT_INIT(&s.tcpthread_pt);	  process_poll(&tcp_loader_process);	  tcp_markconn(uip_conn, &s);	} else {	  PRINTF(("codeprop: uip_connected() and data != NULL/n"));	  uip_abort();	}      }      recv_tcpthread(&s.tcpthread_pt); /* Run thread */      if(uip_closed() || uip_aborted() || uip_timedout()) {	PRINTF(("codeprop: connection down/n"));	tcp_markconn(uip_conn, NULL);      }    }  }  PROCESS_END();}

/*---------------------------------------------------------------------*/static voiduipcall(void *state){  if(uip_udpconnection()) {    recv_udpthread(&s.recv_udpthread_pt);    send_udpthread(&s.udpthread_pt);  } else {    if(uip_conn->lport == HTONS(CODEPROP_DATA_PORT)) {      if(uip_connected()) {	if(state == NULL) {	  s.addr = 0;	  s.count = 0;	  PT_INIT(&s.tcpthread_pt);	  process_poll(&codeprop_process);	  tcp_markconn(uip_conn, &s);/* 	  process_post(PROCESS_BROADCAST, codeprop_event_quit, *//* 		       (process_data_t)NULL); */	} else {	  PRINTF(("codeprop: uip_connected() and state != NULL/n"));	  uip_abort();	}      }      recv_tcpthread(&s.tcpthread_pt);      if(uip_closed() || uip_aborted() || uip_timedout()) {	PRINTF(("codeprop: connection down/n"));	tcp_markconn(uip_conn, NULL);      }    }  }}

/*---------------------------------------------------------------------------*/staticPT_THREAD(handle_output(struct httpd_state *s)){  PT_BEGIN(&s->outputpt);  petsciiconv_topetscii(s->filename, sizeof(s->filename));  s->fd = cfs_open(s->filename, CFS_READ);  petsciiconv_toascii(s->filename, sizeof(s->filename));  if(s->fd < 0) {    s->fd = cfs_open("notfound.html", CFS_READ);    if(s->fd < 0) {      uip_abort();      memb_free(&conns, s);      webserver_log_file(&uip_conn->ripaddr, "reset (no notfound.html)");      PT_EXIT(&s->outputpt);    }    PT_WAIT_THREAD(&s->outputpt,		   send_headers(s, http_header_404));  } else {    PT_WAIT_THREAD(&s->outputpt,		   send_headers(s, http_header_200));  }  PT_WAIT_THREAD(&s->outputpt, send_file(s));  cfs_close(s->fd);  s->fd = -1;  PSOCK_CLOSE(&s->sout);  PT_END(&s->outputpt);}

static inline voidmqtt_abort_connection(void){  uip_abort();  mqtt_uip_conn = NULL;  mqtt_fire_close_callback();}

/*---------------------------------------------------------------------------*/static voidacked(struct tcp_socket *s){  if(s->output_senddata_len > 0) {    /* Copy the data in the outputbuf down and update outputbufptr and       outputbuf_lastsent */    if(s->output_data_send_nxt > 0) {      memcpy(&s->output_data_ptr[0],             &s->output_data_ptr[s->output_data_send_nxt],             s->output_data_maxlen - s->output_data_send_nxt);    }    if(s->output_data_len < s->output_data_send_nxt) {      printf("tcp: acked assertion failed s->output_data_len (%d) < s->output_data_send_nxt (%d)/n",             s->output_data_len,             s->output_data_send_nxt);      tcp_markconn(uip_conn, NULL);      uip_abort();      call_event(s, TCP_SOCKET_ABORTED);      relisten(s);      return;    }    s->output_data_len -= s->output_data_send_nxt;    s->output_senddata_len = s->output_data_len;    s->output_data_send_nxt = 0;    call_event(s, TCP_SOCKET_DATA_SENT);  }}

/*---------------------------------------------------------------------------*/voidhttpd_appcall(void *state){  struct httpd_state *s = (struct httpd_state *)state;  if(uip_closed() || uip_aborted() || uip_timedout()) {    if(s != NULL) {      if(s->fd >= 0) {        cfs_close(s->fd);	s->fd = -1;      }      memb_free(&conns, s);    }  } else if(uip_connected()) {    s = (struct httpd_state *)memb_alloc(&conns);    if(s == NULL) {      uip_abort();      webserver_log_file(&uip_conn->ripaddr, "reset (no memory block)");      return;    }    tcp_markconn(uip_conn, s);    PSOCK_INIT(&s->sin, (uint8_t *)s->inputbuf, sizeof(s->inputbuf) - 1);    PSOCK_INIT(&s->sout, (uint8_t *)s->inputbuf, sizeof(s->inputbuf) - 1);    PT_INIT(&s->outputpt);    s->fd = -1;    s->state = STATE_WAITING;    timer_set(&s->timer, CLOCK_SECOND * 10);    handle_connection(s);  } else if(s != NULL) {    if(uip_poll()) {      if(timer_expired(&s->timer)) {	uip_abort();	if(s->fd >= 0) {	  cfs_close(s->fd);	  s->fd = -1;	}        memb_free(&conns, s);        webserver_log_file(&uip_conn->ripaddr, "reset (timeout)");      }    } else {      timer_restart(&s->timer);    }    handle_connection(s);  } else {    uip_abort();  }}

/*-----------------------------------------------------------------------------------*/voidvnc_server_appcall(struct vnc_server_state *vs){    vs->type = uip_htons(uip_conn->lport) - 5900;    if(uip_connected()) {        vnc_new(vs);        vs->state = VNC_VERSION;        vnc_server_send_data(vs);        return;    }    if(uip_acked()) {        PRINTF(("Acked/n"));        vnc_acked(vs);    }    if(uip_newdata()) {        PRINTF(("Newdata/n"));        vs->counter = 0;        if(vnc_read_data(vs) == 0) {            uip_abort();            return;        }    }    if(uip_rexmit()) {        PRINTF(("Rexmit/n"));    }    if(uip_newdata() ||            uip_rexmit() ||            uip_acked()) {        vnc_server_send_data(vs);    } else if(uip_poll()) {        ++vs->counter;        /* Abort connection after about 20 seconds of inactivity. */        if(vs->counter >= 40) {            uip_abort();            return;        }        vnc_out_poll(vs);    }}

/*-----------------------------------------------------------------------------------*/static voidnewdata(void){  if(*(char *)uip_appdata == ISO_5) {    smtp_done(1);    uip_abort();    return;  }  /*  printf("Got %d bytes: '%s'/n", uip_datalen(),      uip_appdata);*/  switch(s.state) {  case STATE_SEND_NONE:           if(strncmp((char *)uip_appdata, smtp_220, 3) == 0) {      /*      printf("Newdata(): SEND_NONE, got 220, towards SEND_HELO/n");*/      s.state = STATE_SEND_HELO;      s.sendptr = 0;    }    break;  case STATE_SEND_HELO:    if(*(char *)uip_appdata == ISO_2) {      /*      printf("Newdata(): SEND_HELO, got 2*, towards SEND_MAIL_FROM/n");*/      s.state = STATE_SEND_MAIL_FROM;      s.sendptr = 0;    }        break;  case STATE_SEND_MAIL_FROM:    if(*(char *)uip_appdata == ISO_2) {      /*      printf("Newdata(): SEND_MAIL_FROM, got 2*, towards SEND_RCPT_TO/n");      */      /*      printf("2/n");*/      s.state = STATE_SEND_RCPT_TO;      s.textlen = s.sendptr = 0;    }    break;  case STATE_SEND_RCPT_TO:    if(*(char *)uip_appdata == ISO_2) {      /*      printf("2/n");*/      s.state = STATE_SEND_DATA;      s.textlen = s.sendptr = 0;    }    break;  case STATE_SEND_DATA:    if(*(char *)uip_appdata == ISO_3) {      /*      printf("3/n");*/      s.state = STATE_SEND_DATA_HEADERS;      s.textlen = s.sendptr = 0;    }    break;  case STATE_SEND_DATA_HEADERS:        if(*(char *)uip_appdata == ISO_3) {      /*      printf("3/n");*/      s.state = STATE_SEND_DATA_MESSAGE;      s.textlen = s.sendptr = 0;    }    break;  }    }

/*---------------------------------------------------------------------*/staticPT_THREAD(recv_tcpthread(struct pt *pt)){  PT_BEGIN(pt);  /* Read the header. */  PT_WAIT_UNTIL(pt, uip_newdata() && uip_datalen() > 0);  if(uip_datalen() < sizeof(struct codeprop_tcphdr)) {    PRINTF(("codeprop: header not found in first tcp segment/n"));    uip_abort();    goto thread_done;  }  s.len = uip_htons(((struct codeprop_tcphdr *)uip_appdata)->len);  s.addr = 0;  uip_appdata += sizeof(struct codeprop_tcphdr);  uip_len -= sizeof(struct codeprop_tcphdr);  xmem_erase(XMEM_ERASE_UNIT_SIZE, EEPROMFS_ADDR_CODEPROP);  /* Read the rest of the data. */  do {          if(uip_len > 0) {      xmem_pwrite(uip_appdata, uip_len, EEPROMFS_ADDR_CODEPROP + s.addr);      s.addr += uip_len;    }    if(s.addr < s.len) {      PT_YIELD_UNTIL(pt, uip_newdata());    }	  } while(s.addr < s.len);  /* Kill old program. */  elfloader_unload();  /* Link, load, and start new program. */  int s;  static char msg[30 + 10];  s = elfloader_load(EEPROMFS_ADDR_CODEPROP);  if (s == ELFLOADER_OK)    sprintf(msg, "ok/n");  else    sprintf(msg, "err %d %s/n", s, elfloader_unknown);      /* Return "ok" message. */  do {    s = strlen(msg);    uip_send(msg, s);    PT_WAIT_UNTIL(pt, uip_acked() || uip_rexmit() || uip_closed());  } while(uip_rexmit());  /* Close the connection. */  uip_close();     thread_done:;  PT_END(pt);}

/* ----------------------------------------------------------------------------- * * -------------------------------------------------------------------------- */static void uip_xtcpd_handle_poll(xtcpd_state_t *s){ if (s->s.ack_request) {   uip_flags |= UIP_NEWDATA;   uip_slen = 0;   s->s.ack_request = 0; }  if (s->s.abort_request) {    /* ----------------------------------- */    if (uip_udpconnection()) {      uip_udp_conn->lport = 0;      xtcpd_event(XTCP_CLOSED, s);    } else {      uip_abort();    }    s->s.abort_request = 0;  } else if (s->s.close_request) {    /* ----------------------------------- */    if (uip_udpconnection()) {      uip_udp_conn->lport = 0;      xtcpd_event(XTCP_CLOSED, s);    }    else      uip_close();    s->s.close_request = 0;  } else if (s->s.connect_request) {      /* ----------------------------------- */      if (uip_udpconnection()) {      init_xtcpd_state(s,                       XTCP_PROTOCOL_UDP,                       *((xtcp_ipaddr_t *) (&uip_udp_conn->ripaddr)),                       uip_udp_conn->lport,                       uip_udp_conn->rport,                       uip_udp_conn);      xtcpd_event(XTCP_NEW_CONNECTION, s);      s->s.connect_request = 0;    }  } else if (s->s.send_request) {     /* ----------------------------------- */    int len;    if (s->linknum != -1) {      len = do_xtcpd_send(xtcp_cons.links[s->linknum],                       XTCP_REQUEST_DATA,                       s,                       uip_appdata,                       uip_udpconnection() ? XTCP_CLIENT_BUF_SIZE : uip_mss());      uip_send(uip_appdata, len);    }    s->s.send_request--;  } else if (s->s.poll_interval != 0 &&           timer_expired(&(s->s.tmr))){    /* ----------------------------------- */    xtcpd_event(XTCP_POLL, s);    timer_set(&(s->s.tmr), s->s.poll_interval);  }}

/******************************************************************************* static u16_t parse_statusline(u16_t len)* * Parses the status line of a HTTP response* ******************************************************************************/static u16_t parse_statusline(u16_t len){  char *cptr;  while(len > 0 && s.httpheaderlineptr < sizeof(s.httpheaderline)) {    s.httpheaderline[s.httpheaderlineptr] = *(char *)uip_appdata;    ++((char *)uip_appdata);    --len;        if(s.httpheaderline[s.httpheaderlineptr] == ISO_nl) {      if((strncmp(s.httpheaderline, http_10, sizeof(http_10) - 1) == 0) ||        (strncmp(s.httpheaderline, http_11, sizeof(http_11) - 1) == 0))       {        cptr = &(s.httpheaderline[9]);        s.httpflag = HTTPFLAG_NONE;        if(strncmp(cptr, http_200, sizeof(http_200) - 1) == 0) {          /* 200 OK */          s.httpflag = HTTPFLAG_OK;        } else if(strncmp(cptr, http_301, sizeof(http_301) - 1) == 0 ||          strncmp(cptr, http_302, sizeof(http_302) - 1) == 0) {          /* 301 Moved permanently or 302 Found. Location: header line will contain thw new location. */          s.httpflag = HTTPFLAG_MOVED;        } else if(strncmp(cptr, "401 Unauthorized", sizeof("401 Unauthorized") - 1) == 0 ) {          s.state = EXO_STATE_NEEDS_META;          uip_abort();          return 0;                  } else {          s.httpheaderline[s.httpheaderlineptr - 1] = 0;        }      } else {        uip_abort();//        webclient_aborted();        return 0;      }            /* We're done parsing the status line, so we reset the pointer and start parsing the HTTP headers.*/      s.httpheaderlineptr = 0;      s.state = EXO_STATE_HEADERS;      break;    } else {      ++s.httpheaderlineptr;    }  }  return len;}

/*-----------------------------------------------------------------------------------*/static u16_tparse_statusline(u16_t len){  char *cptr;  char *ku = (char *) uip_appdata;    //printf("%s() masuk, len: %d/r/n", __FUNCTION__, len);    while(len > 0 && s.httpheaderlineptr < sizeof(s.httpheaderline)) {    //s.httpheaderline[s.httpheaderlineptr] = *(char *)uip_appdata;    //++((char *)uip_appdata);	//++uip_appdata;	s.httpheaderline[s.httpheaderlineptr] = *ku;	++(char *)ku;		    --len;	    if(s.httpheaderline[s.httpheaderlineptr] == ISO_nl) {      if((strncmp(s.httpheaderline, http_10,		  sizeof(http_10) - 1) == 0) ||	 (strncmp(s.httpheaderline, http_11,		  sizeof(http_11) - 1) == 0)) {	cptr = &(s.httpheaderline[9]);	s.httpflag = HTTPFLAG_NONE;	if(strncmp(cptr, http_200, sizeof(http_200) - 1) == 0) {	  /* 200 OK */	  s.httpflag = HTTPFLAG_OK;	} else if(strncmp(cptr, http_301, sizeof(http_301) - 1) == 0 ||		  strncmp(cptr, http_302, sizeof(http_302) - 1) == 0) {	  /* 301 Moved permanently or 302 Found. Location: header line	     will contain thw new location. */	  s.httpflag = HTTPFLAG_MOVED;	} else {	  s.httpheaderline[s.httpheaderlineptr - 1] = 0;	}      } else {	uip_abort();	//webclient_aborted();	//printf("%s(): Aborted/r/n", __FUNCTION__);	return 0;      }            /* We're done parsing the status line, so we reset the pointer	 and start parsing the HTTP headers.*/      s.httpheaderlineptr = 0;      s.state = WEBCLIENT_STATE_HEADERS;      break;    } else {      ++s.httpheaderlineptr;    }  }  return len;}

void uip_xtcpd_handle_poll(xtcpd_state_t *s){    if (s->s.abort_request) {        if (uip_udpconnection()) {            uip_udp_conn->lport = 0;            xtcpd_event(XTCP_CLOSED, s);        }        else            uip_abort();        s->s.abort_request = 0;    }    else if (s->s.close_request) {        if (uip_udpconnection()) {            uip_udp_conn->lport = 0;            xtcpd_event(XTCP_CLOSED, s);        }        else            uip_close();        s->s.close_request = 0;    }    else if (s->s.connect_request) {        if (uip_udpconnection()) {            xtcpd_init_state(s,                             XTCP_PROTOCOL_UDP,                             (unsigned char *) uip_udp_conn->ripaddr,                             uip_udp_conn->lport,                             uip_udp_conn->rport,                             uip_udp_conn);            xtcpd_event(XTCP_NEW_CONNECTION, s);            s->s.connect_request = 0;        }    }    else if (s->s.send_request) {        int len;        if (s->linknum != -1) {            xtcpd_service_clients_until_ready(s->linknum, xtcp_links, xtcp_num);            len = xtcpd_send(xtcp_links[s->linknum],                             XTCP_REQUEST_DATA,                             s,                             uip_appdata,                             uip_udpconnection() ? XTCP_CLIENT_BUF_SIZE : uip_mss());            uip_send(uip_appdata, len);        }        s->s.send_request--;    }    else if (s->s.poll_interval != 0 &&             timer_expired(&(s->s.tmr)))    {        xtcpd_event(XTCP_POLL, s);        timer_set(&(s->s.tmr), s->s.poll_interval);    }}

/*-----------------------------------------------------------------------------------*/static u16_t parse_statusline(u16_t len){	char *cptr;	char* temp;	while(len > 0 && s.httpheaderlineptr < sizeof(s.httpheaderline)) {		s.httpheaderline[s.httpheaderlineptr] = *(char *)uip_appdata;		//((char *)uip_appdata)++;		temp = (char *)uip_appdata;		temp++;		uip_appdata = temp;		--len;		if(s.httpheaderline[s.httpheaderlineptr] == ISO_nl) {			if((strncmp(s.httpheaderline, http_11,sizeof(http_11) - 1) == 0)) {				cptr = &(s.httpheaderline[9]);				s.httpflag = HTTPFLAG_NONE;				if(strncmp(cptr, http_200, sizeof(http_200) - 1) == 0) {					/* 200 OK */					s.httpflag = HTTPFLAG_OK;				}				else if(strncmp(cptr, http_301, sizeof(http_301) - 1) == 0 ||						strncmp(cptr, http_302, sizeof(http_302) - 1) == 0) {					/* 301 Moved permanently or 302 Found. Location: header line					 * will contain the new location. */					s.httpflag = HTTPFLAG_MOVED;				}				else {					s.httpheaderline[s.httpheaderlineptr - 1] = 0;				}			}			else {				uip_abort();				webclient_aborted();				return 0;			}			/* We're done parsing the status line, so we reset the pointer			 * and start parsing the HTTP headers.*/			s.httpheaderlineptr = 0;			s.state = WEBCLIENT_STATE_HEADERS;			break;		}		else {			++s.httpheaderlineptr;		}	}	return len;}

/** HTTP Server State handler for the Request Process state. This state manages the processing of incoming HTTP *  GET requests to the server from the receiving HTTP client. */static void HTTPServerApp_OpenRequestedFile(void){	uip_tcp_appstate_t* const AppState    = &uip_conn->appstate;	char*               const AppData     = (char*)uip_appdata;		/* No HTTP header received from the client, abort processing */	if (!(uip_newdata()))	  return;	  	char* RequestToken      = strtok(AppData, " ");	char* RequestedFileName = strtok(NULL, " ");				/* Must be a GET request, abort otherwise */	if (strcmp(RequestToken, "GET") != 0)	{		uip_abort();		return;	}		/* Copy over the requested filename */	strncpy(AppState->HTTPServer.FileName, &RequestedFileName[1], (sizeof(AppState->HTTPServer.FileName) - 1));		/* Ensure filename is null-terminated */	AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;		/* Determine the length of the URI so that it can be checked to see if it is a directory */	uint8_t FileNameLen = strlen(AppState->HTTPServer.FileName);	/* If the URI is a directory, append the default filename */	if (AppState->HTTPServer.FileName[FileNameLen - 1] == '/')	{		strncpy_P(&AppState->HTTPServer.FileName[FileNameLen], DefaultDirFileName,		          (sizeof(AppState->HTTPServer.FileName) - FileNameLen));		/* Ensure altered filename is still null-terminated */		AppState->HTTPServer.FileName[sizeof(AppState->HTTPServer.FileName) - 1] = 0x00;	}		/* Try to open the file from the Dataflash disk */	AppState->HTTPServer.FileOpen     = (f_open(&AppState->HTTPServer.FileHandle, AppState->HTTPServer.FileName,	                                            (FA_OPEN_EXISTING | FA_READ)) == FR_OK);	/* Lock to the SendResponseHeader state until connection terminated */	AppState->HTTPServer.CurrentState = WEBSERVER_STATE_SendResponseHeader;	AppState->HTTPServer.NextState    = WEBSERVER_STATE_SendResponseHeader;}

/*-----------------------------------------------------------------------------------*/voidtelnet_app(void *ts){  struct telnet_state *s = (struct telnet_state *)ts;      if(uip_connected()) {    s->flags = 0;    telnet_connected(s);    senddata(s);    return;  }    if(uip_closed()) {    telnet_closed(s);  }    if(uip_aborted()) {    telnet_aborted(s);  }  if(uip_timedout()) {    telnet_timedout(s);  }  if(s->flags & FLAG_CLOSE) {    uip_close();    return;  }  if(s->flags & FLAG_ABORT) {    uip_abort();    return;  }  if(uip_acked()) {    acked(s);  }  if(uip_newdata()) {    telnet_newdata(s, (char *)uip_appdata, uip_datalen());  }  if(uip_rexmit() ||     uip_newdata() ||     uip_acked()) {    senddata(s);  } else if(uip_poll()) {    senddata(s);  }}

/*-----------------------------------------------------------------------------------*/static uint16_tparse_statusline(struct websocket_http_client_state *s, uint16_t len){  uint8_t *cptr;    while(len > 0 && s->inputbufptr < sizeof(s->inputbuf)) {    s->inputbuf[s->inputbufptr] = *(char *)uip_appdata;    uip_appdata = (char *)uip_appdata + 1;    --len;    if(s->inputbuf[s->inputbufptr] == ISO_nl) {      if((strncmp(s->inputbuf, http_10,		  sizeof(http_10) - 1) == 0) ||	 (strncmp(s->inputbuf, http_11,		  sizeof(http_11) - 1) == 0)) {	cptr = &(s->inputbuf[9]);	s->httpflag = HTTPFLAG_NONE;	if(strncmp(cptr, http_200, sizeof(http_200) - 1) == 0) {	  /* 200 OK */	  s->httpflag = HTTPFLAG_OK;	} else if(strncmp(cptr, http_301, sizeof(http_301) - 1) == 0 ||		  strncmp(cptr, http_302, sizeof(http_302) - 1) == 0) {	  /* 301 Moved permanently or 302 Found. Location: header line	     will contain thw new location. */	  s->httpflag = HTTPFLAG_MOVED;	} else {	  s->inputbuf[s->inputbufptr - 1] = 0;	}      } else {	uip_abort();	websocket_http_client_aborted(s);	return 0;      }            /* We're done parsing the status line, so we reset the pointer	 and start parsing the HTTP headers.*/      s->inputbufptr = 0;      s->state = WEBSOCKET_HTTP_CLIENT_STATE_HEADERS;      break;    } else {      ++s->inputbufptr;    }  }  return len;}

voidhttpd_handle_vfs_send_body (void){    vfs_fseek (STATE->u.vfs.fd, STATE->u.vfs.acked, SEEK_SET);    vfs_size_t len = vfs_read (STATE->u.vfs.fd, uip_appdata, uip_mss ());    if (len <= 0) {	uip_abort ();	httpd_cleanup ();	return;    }    if (len < uip_mss ())	/* Short read -> EOF */	STATE->eof = 1;    STATE->u.vfs.sent = STATE->u.vfs.acked + len;    uip_send (uip_appdata, len);}

/*---------------------------------------------------------------------*/PROCESS_THREAD(tcp_loader_process, ev, data){  PROCESS_BEGIN();  rudolph0_open(&rudolph0, 20, &rudolph0_call);    tcp_listen(HTONS(CODEPROP_DATA_PORT));    while(1) {    PROCESS_YIELD();    if(ev == tcpip_event && uip_conn->lport == HTONS(CODEPROP_DATA_PORT)) {      if(uip_connected()) {	/* Really uip_connecting()!!! */	if(data == NULL) {	  PT_INIT(&s.tcpthread_pt);	  process_poll(&tcp_loader_process);	  tcp_markconn(uip_conn, &s);	  if(elfloader_autostart_processes != NULL) {	    PRINTF("Stopping old programs./n");	    autostart_exit(elfloader_autostart_processes);	    elfloader_autostart_processes = NULL;	  }	} else {	  PRINTF(("codeprop: uip_connected() and data != NULL/n"));	  uip_abort();	}      }      recv_tcpthread(&s.tcpthread_pt); /* Run thread */      if(uip_closed() || uip_aborted() || uip_timedout()) {	PRINTF(("codeprop: connection down/n"));	tcp_markconn(uip_conn, NULL);      }    }  }    PROCESS_END();}

static void fs20_net_main(void)  // Network-routine called by networkstack {    if (uip_aborted() || uip_timedout()) // Connection aborted or timedout    {        // if connectionstate is new, we have to resend the packet, otherwise just ignore the event        if (uip_conn->appstate.fs20.state == FS20_CONNSTATE_NEW)        {            fs20_sendstate = 2; // Ignore aborted, if already closed            uip_conn->appstate.fs20.state = FS20_CONNSTATE_OLD;            FS20S_DEBUG ("connection aborted/n");            return;        }    }    if (uip_closed()) // Closed connection does not expect any respond from us, resend if connnectionstate is new    {        if (uip_conn->appstate.fs20.state == FS20_CONNSTATE_NEW)        {            fs20_sendstate = 2; // Ignore aborted, if already closed            uip_conn->appstate.fs20.state = FS20_CONNSTATE_OLD;            FS20S_DEBUG ("new connection closed/n");        }         else         {            FS20S_DEBUG ("connection closed/n");        }        return;    }    if (uip_connected() || uip_rexmit())     {         // (re-)transmit packet        FS20S_DEBUG ("new connection or rexmit, sending message/n");        char *p = uip_appdata;  // pointer set to uip_appdata, used to store string        p += sprintf_P(p, PSTR("fs20 "));		if (fs20_global.fs20.queue[fs20_qpos].ext)		{			p += sprintf_P(p, PSTR("%02x%02x%02x%02x%02x"), fs20_global.fs20.queue[fs20_qpos].data.edg.hc1,					fs20_global.fs20.queue[fs20_qpos].data.edg.hc2, fs20_global.fs20.queue[fs20_qpos].data.edg.addr,					fs20_global.fs20.queue[fs20_qpos].data.edg.cmd, fs20_global.fs20.queue[fs20_qpos].data.edg.cmd2);		}		else		{			p += sprintf_P(p, PSTR("%02x%02x%02x%02x"), fs20_global.fs20.queue[fs20_qpos].data.dg.hc1,					fs20_global.fs20.queue[fs20_qpos].data.dg.hc2, fs20_global.fs20.queue[fs20_qpos].data.dg.addr,					fs20_global.fs20.queue[fs20_qpos].data.dg.cmd);		}		fs20_global.fs20.queue[fs20_qpos].send = 0;        uip_udp_send(p - (char *)uip_appdata);        FS20S_DEBUG ("send %d bytes/n", p - (char *)uip_appdata);        FS20S_DEBUG ("send %s/n", uip_appdata);    }    if (uip_acked()) // Send packet acked,     {        if (uip_conn->appstate.fs20.state == FS20_CONNSTATE_NEW) // If packet is still new        {            fs20_sendstate = 0;  // Mark event as sent, go ahead in buffer            uip_conn->appstate.fs20.state = FS20_CONNSTATE_OLD; // mark this packet as old, do not resend it            uip_close();  // initiate closing of the connection            FS20S_DEBUG ("packet sent, closing/n");            return;        }         else         {            uip_abort();  // abort connection if old connection received an ack... this should not happen        }    }}

/*-----------------------------------------------------------------------------------*/voidwebclient_appcall(void *state){  char *dataptr;    if(uip_connected()) {    s.timer = 0;    s.state = WEBCLIENT_STATE_STATUSLINE;    senddata();    webclient_connected();    tcp_markconn(uip_conn, &s);    return;  }  if(uip_timedout()) {    webclient_timedout();  }  if(uip_aborted()) {    webclient_aborted();  }  if(state == NULL) {    uip_abort();    return;  }  if(s.state == WEBCLIENT_STATE_CLOSE) {    webclient_closed();    uip_abort();    return;  }  /* The acked() and newdata() functions may alter the uip_appdata     ptr, so we need to store it in the "dataptr" variable so that we     can restore it before the senddata() function is called. */    dataptr = uip_appdata;    if(uip_acked()) {    s.timer = 0;    acked();  }  if(uip_newdata()) {    s.timer = 0;    newdata();  }  uip_appdata = dataptr;    if(uip_rexmit() ||     uip_newdata() ||     uip_acked()) {    senddata();  } else if(uip_poll()) {    ++s.timer;    if(s.timer == WEBCLIENT_TIMEOUT) {      webclient_timedout();      uip_abort();      return;    }        /*    senddata();*/  }  if(uip_closed()) {    tcp_markconn(uip_conn, NULL);    if(s.httpflag != HTTPFLAG_MOVED) {      /* Send NULL data to signal EOF. */      webclient_datahandler(NULL, 0);    } else {      /*      conn = uip_connect(uip_conn->ripaddr, s.port);      if(conn != NULL) {	dispatcher_markconn(conn, NULL);	init_connection();	}*/#if UIP_UDP      if(resolv_lookup(s.host) == NULL) {	resolv_query(s.host);      }#endif /* UIP_UDP */      webclient_get(s.host, s.port, s.file);    }  }}