/*---------------------------------------------------------------------------*/ static unsigned short make_tcp_stats(void *arg) { static const char httpd_cgi_tcpstat1[] HTTPD_STRING_ATTR = "<tr align=\"center\"><td>%d</td><td>"; static const char httpd_cgi_tcpstat2[] HTTPD_STRING_ATTR = "-%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n"; static const char httpd_cgi_tcpstat3[] HTTPD_STRING_ATTR = "[Room for %d more]"; struct uip_conn *conn; struct httpd_state *s = (struct httpd_state *)arg; char tstate[20]; uint16_t numprinted; if (s->u.count==UIP_CONNS){ for(numprinted = 0; numprinted < UIP_CONNS; numprinted++ ) { if((uip_conns[numprinted].tcpstateflags & UIP_TS_MASK) != UIP_CLOSED) s->u.count--; } return(httpd_snprintf((char *)uip_appdata, uip_mss(), httpd_cgi_tcpstat3, s->u.count)); } conn = &uip_conns[s->u.count]; numprinted = httpd_snprintf((char *)uip_appdata, uip_mss(), httpd_cgi_tcpstat1, uip_htons(conn->lport)); numprinted += httpd_cgi_sprint_ip6(conn->ripaddr, uip_appdata + numprinted); httpd_strcpy(tstate,states[conn->tcpstateflags & UIP_TS_MASK]); numprinted += httpd_snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, httpd_cgi_tcpstat2, uip_htons(conn->rport), tstate, conn->nrtx, conn->timer, (uip_outstanding(conn))? '*':' ', (uip_stopped(conn))? '!':' '); return numprinted; }
void uip_task_appcall() { if(uip_connected()) { socket_process_new_connect_(); }else if(uip_poll()) { if(uip_stopped(uip_conn)) { socket_process_try_restart_(); } socket_process_write_(); }else if(uip_newdata()) { socket_process_new_data_(); socket_process_write_(); }else if(uip_aborted() || uip_closed()) { socket_process_close_(); }else if(uip_timedout()) { socket_process_timeout_(); uip_close(); }else if(uip_acked() || uip_rexmit()) { socket_process_write_(); } }
int UIPClient::read(uint8_t *buf, size_t size) { if (*this) { int remain = size; memhandle* p = &data->packets_in[0]; if (*p == NOBLOCK) return 0; int read; do { read = UIPEthernet.network.readPacket(*p,0,buf+size-remain,remain); if (read == UIPEthernet.network.blockSize(*p)) { remain -= read; _eatBlock(p); if (_uip_conn && uip_stopped(_uip_conn) && !(data->state & (UIP_CLIENT_CLOSE | UIP_CLIENT_CLOSED))) data->state |= UIP_CLIENT_RESTART; if (*p == NOBLOCK) return size-remain; } else { UIPEthernet.network.resizeBlock(*p,read); break; } } while(remain > 0); return size; } return -1; }
/*---------------------------------------------------------------------------*/ static unsigned short make_tcp_stats(void *arg) { struct uip_conn *conn; struct httpd_state *s = (struct httpd_state *)arg; uint16_t numprinted; conn = &uip_conns[s->u.count]; numprinted = snprintf((char *)uip_appdata, uip_mss(), "<tr align=\"center\"><td>%d</td><td>", htons(conn->lport)); numprinted += sprint_ip6(conn->ripaddr, uip_appdata + numprinted); numprinted += snprintf((char *)uip_appdata + numprinted, uip_mss() - numprinted, "-%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n", htons(conn->rport), states[conn->tcpstateflags & UIP_TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn))? '*':' ', (uip_stopped(conn))? '!':' '); return numprinted; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_netstat_process, ev, data) { char buf[BUFLEN]; int i; struct uip_conn *conn; PROCESS_BEGIN(); for(i = 0; i < UIP_CONNS; ++i) { conn = &uip_conns[i]; snprintf(buf, BUFLEN, "%d, %u.%u.%u.%u:%u, %s, %u, %u, %c %c", htons(conn->lport), conn->ripaddr.u8[0], conn->ripaddr.u8[1], conn->ripaddr.u8[2], conn->ripaddr.u8[3], htons(conn->rport), states[conn->tcpstateflags & UIP_TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn))? '*':' ', (uip_stopped(conn))? '!':' '); shell_output_str(&netstat_command, "TCP ", buf); } PROCESS_END(); }
void yport_net_main(void) { if(uip_connected()) { if (yport_conn == NULL) { yport_conn = uip_conn; uip_conn->wnd = YPORT_BUFFER_LEN - 1; } else /* if we have already an connection, send an error */ uip_send("ERROR: Connection blocked\n", 27); } else if (uip_acked()) { /* If the peer is not our connection, close it */ if (yport_conn != uip_conn) uip_close(); else { /* Some data we have sent was acked, jipphie */ /* disable interrupts */ uint8_t sreg = SREG; cli(); yport_recv_buffer.len -= yport_recv_buffer.sent; /* We should use memmove, because the data may overlap */ memmove(yport_recv_buffer.data, yport_recv_buffer.data + yport_recv_buffer.sent, yport_recv_buffer.len); /* enable interrupts again */ SREG = sreg; } } else if (uip_closed() || uip_aborted() || uip_timedout()) { /* if the closed connection was our connection, clean yport_conn */ if (yport_conn == uip_conn) yport_conn = NULL; } else if (uip_newdata()) { if (uip_len <= YPORT_BUFFER_LEN && yport_rxstart(uip_appdata, uip_len) != 0) { /* Prevent the other side from sending more data */ uip_stop(); } } if (uip_poll() && uip_conn == yport_conn && uip_stopped(yport_conn) && yport_send_buffer.sent == yport_send_buffer.len) uip_restart(); /* Send data */ if ((uip_poll() || uip_acked() || uip_rexmit()) && yport_conn == uip_conn && yport_recv_buffer.len > 0) { /* We have recieved data, lets propagade it */ /* disable interrupts */ uint8_t sreg = SREG; cli(); /* Send the data */ uip_send(yport_recv_buffer.data, yport_recv_buffer.len); /* so many data was send */ yport_recv_buffer.sent = yport_recv_buffer.len; /* enable interrupts again */ SREG = sreg; } }
static unsigned short function_tcp_connections(char* buffer, int bufsize) { unsigned short len = 0; // list as many connections as fit into the buffer for (int i = 0; len < bufsize && i<UIP_CONF_MAX_CONNECTIONS; i++) { len+=snprintf_P(buffer+len, bufsize-len, tcp_conn_formatter1, htons(uip_conns[i].lport), htons(uip_conns[i].ripaddr[0]) >> 8, htons(uip_conns[i].ripaddr[0]) & 0xff, htons(uip_conns[i].ripaddr[1]) >> 8, htons(uip_conns[i].ripaddr[1]) & 0xff, htons(uip_conns[i].rport)); switch (uip_conns[i].tcpstateflags & UIP_TS_MASK) { case UIP_CLOSED: strncpy_P(buffer+len,tcp_closed,bufsize-len); len+=sizeof(tcp_closed)-1; break; case UIP_SYN_RCVD: strncpy_P(buffer+len,tcp_syn_rcvd,bufsize-len); len+=sizeof(tcp_syn_rcvd)-1; break; case UIP_SYN_SENT: strncpy_P(buffer+len,tcp_syn_sent,bufsize-len); len+=sizeof(tcp_syn_sent)-1; break; case UIP_ESTABLISHED: strncpy_P(buffer+len,tcp_established,bufsize-len); len+=sizeof(tcp_established)-1; break; case UIP_FIN_WAIT_1: strncpy_P(buffer+len,tcp_fin_wait_1,bufsize-len); len+=sizeof(tcp_fin_wait_1)-1; break; case UIP_FIN_WAIT_2: strncpy_P(buffer+len,tcp_fin_wait_2,bufsize-len); len+=sizeof(tcp_fin_wait_1)-1; break; case UIP_CLOSING: strncpy_P(buffer+len,tcp_closing,bufsize-len); len+=sizeof(tcp_closing); break; case UIP_TIME_WAIT: strncpy_P(buffer+len,tcp_time_wait,bufsize-len); len+=sizeof(tcp_time_wait)-1; break; case UIP_LAST_ACK: strncpy_P(buffer+len,tcp_last_ack,bufsize-len); len+=sizeof(tcp_last_ack)-1; break; } len+=snprintf_P(buffer+len, bufsize-len, tcp_conn_formatter2, uip_conns[i].nrtx, uip_conns[i].timer, (uip_outstanding(&uip_conns[i])) ? '*' : ' ', (uip_stopped(&uip_conns[i])) ? '!' : ' '); } return len; }
static unsigned short generate_tcp_stats( void *arg ) { struct uip_conn *conn; struct httpd_state *s = ( struct httpd_state * ) arg; conn = &uip_conns[s->count]; return snprintf( ( char * ) uip_appdata, UIP_APPDATA_SIZE, "<tr><td>%d</td><td>%u.%u.%u.%u:%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n", htons(conn->lport), htons(conn->ripaddr[0]) >> 8, htons(conn->ripaddr[0]) & 0xff, htons(conn->ripaddr[1]) >> 8, htons(conn->ripaddr[1]) & 0xff, htons(conn->rport), states[conn->tcpstateflags & UIP_TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn)) ? '*' : ' ', (uip_stopped(conn)) ? '!' : ' ' ); }
/*---------------------------------------------------------------------------*/ static unsigned short make_tcp_stats(void *arg) { struct uip_conn *conn; struct httpd_state *s = (struct httpd_state *)arg; conn = &uip_conns[s->u.count]; #if UIP_CONF_IPV6 char buf[48]; httpd_sprint_ip6(&conn->ripaddr, buf); return snprintf((char *)uip_appdata, uip_mss(), "<tr><td>%d</td><td>%s:%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n", uip_htons(conn->lport), buf, uip_htons(conn->rport), states[conn->tcpstateflags & UIP_TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn)) ? '*' : ' ', (uip_stopped(conn)) ? '!' : ' '); #else return snprintf((char *)uip_appdata, uip_mss(), "<tr><td>%d</td><td>%u.%u.%u.%u:%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n", uip_htons(conn->lport), conn->ripaddr.u8[0], conn->ripaddr.u8[1], conn->ripaddr.u8[2], conn->ripaddr.u8[3], uip_htons(conn->rport), states[conn->tcpstateflags & UIP_TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn)) ? '*' : ' ', (uip_stopped(conn)) ? '!' : ' '); #endif /* UIP_CONF_IPV6 */ }
/*-----------------------------------------------------------------------------------*/ static u8_t tcp_stats(void) { struct uip_conn *conn; if(uip_acked()) { /* If the previously sent data has been acknowledged, we move forward one connection. */ if(++hs->count == UIP_CONNS) { /* If all connections has been printed out, we are done and return 1. */ return 1; } } conn = &uip_conns[hs->count]; while((conn->tcpstateflags & TS_MASK) == CLOSED) { if(++hs->count == UIP_CONNS) { /* If all connections has been printed out, we are done and return 1. */ return 1; } conn = &uip_conns[hs->count]; } sprintf((char *)uip_appdata, "<tr><td>%d</td><td>%u.%u.%u.%u:%u</td><td>%s</td><td>%u</td><td>%u</td><td>%c %c</td></tr>\r\n", htons(conn->lport), htons(conn->ripaddr[0]) >> 8, htons(conn->ripaddr[0]) & 0xff, htons(conn->ripaddr[1]) >> 8, htons(conn->ripaddr[1]) & 0xff, htons(conn->rport), states[conn->tcpstateflags & TS_MASK], conn->nrtx, conn->timer, (uip_outstanding(conn))? '*':' ', (uip_stopped(conn))? '!':' '); uip_send(uip_appdata, strlen((char *)uip_appdata)); return 0; }
int UIPClient::read(uint8_t *buf, size_t size) { if (*this) { uint16_t remain = size; if (data->packets_in[0] == NOBLOCK) return 0; uint16_t read; do { read = Enc28J60Network::readPacket(data->packets_in[0],0,buf+size-remain,remain); if (read == Enc28J60Network::blockSize(data->packets_in[0])) { remain -= read; _eatBlock(&data->packets_in[0]); if (uip_stopped(&uip_conns[data->state & UIP_CLIENT_SOCKETS]) && !(data->state & (UIP_CLIENT_CLOSE | UIP_CLIENT_REMOTECLOSED))) data->state |= UIP_CLIENT_RESTART; if (data->packets_in[0] == NOBLOCK) { if (data->state & UIP_CLIENT_REMOTECLOSED) { data->state = 0; data = NULL; } return size-remain; } } else { Enc28J60Network::resizeBlock(data->packets_in[0],read); break; } } while(remain > 0); return size; } return -1; }
static void connections(char *str, Shell *sh) { char istr[128]; struct uip_conn *connr; snprintf(istr, sizeof(istr), "Initial MSS: %d, MSS: %d\n", uip_initialmss(), uip_mss()); sh->output(istr); sh->output("Current connections: \n"); for (connr = &uip_conns[0]; connr <= &uip_conns[UIP_CONNS - 1]; ++connr) { if(connr->tcpstateflags != UIP_CLOSED) { snprintf(istr, sizeof(istr), "%d, %u.%u.%u.%u:%u, %s, %u, %u, %c %c\n", HTONS(connr->lport), uip_ipaddr1(connr->ripaddr), uip_ipaddr2(connr->ripaddr), uip_ipaddr3(connr->ripaddr), uip_ipaddr4(connr->ripaddr), HTONS(connr->rport), states[connr->tcpstateflags & UIP_TS_MASK], connr->nrtx, connr->timer, (uip_outstanding(connr)) ? '*' : ' ', (uip_stopped(connr)) ? '!' : ' '); sh->output(istr); } } }
void TCPIP_TCPCallback(void) { if (uip_acked()) Debug_Print("[ACK] "); if (uip_newdata()) { Debug_Print("New Data:\r\n"); TCPIP_QueueData(uip_appdata, uip_datalen()); if (TCPIP_IsDataQueueFull()) uip_stop(); } if (uip_connected()) { Debug_Print("Connected - Maximum Segment Size: 0x"); Debug_PrintHex(uip_mss() / 256); Debug_PrintHex(uip_mss() & 255); Debug_Print("\r\n"); } if (uip_closed()) { Debug_Print("Closed - Reconnecting..."); _delay_ms(1000); ConnectedState = LINKMANAGEMENT_STATE_ConnectToRemoteHost; } if (uip_aborted()) { Debug_Print("Aborted - Reconnecting... "); _delay_ms(1000); ConnectedState = LINKMANAGEMENT_STATE_ConnectToRemoteHost; } if (uip_timedout()) { Debug_Print("Timeout - Reconnecting..."); uip_abort(); _delay_ms(1000); ConnectedState = LINKMANAGEMENT_STATE_ConnectToRemoteHost; } if (uip_poll() && (SystemTicks > 3000)) { SystemTicks = 0; Debug_Print("\r\nSending GET\r\n"); TCPIP_SendGET(); } if (uip_rexmit()) { Debug_Print("\r\nRetransmit GET\r\n"); TCPIP_SendGET(); } if (uip_poll() && uip_stopped(TCPConnection)) { if (!(TCPIP_IsDataQueueFull())) uip_restart(); } }