#include <geekos/socket.h>
#include <geekos/malloc.h>
+#include <palacios/vmm_types.h>
#include <geekos/ne2k.h>
#include <uip/uip.h>
#include <uip/uip_arp.h>
-#include <geekos/int.h>
#include <geekos/vmm_stubs.h>
-#include <geekos/queue.h>
+#define NULL (void *)0
-// for some reason, there are compile warnings without these
#define BUF ((struct uip_eth_hdr *)&uip_buf[0])
#define MAX_SOCKS 1024
+#define BUF_SIZE 1000
struct socket sockets[MAX_SOCKS];
-struct gen_queue in_packets;
+extern void* memcpy(void *dst, const void* src, int n);
-struct sock_packet {
- int size;
- uchar_t *data;
-};
-int Packet_Received(struct NE2K_Packet_Info* info, uchar_t *pkt) ;
+int Packet_Received(struct NE2K_Packet_Info* info, uchar_t *pkt);
void init_network() {
int i = 0;
- init_queue(&in_packets);
-
for (i = 0; i < MAX_SOCKS; i++) {
sockets[i].in_use = 0;
- init_queue(&(sockets[i].send_queue));
- init_queue(&(sockets[i].recv_queue));
+ sockets[i].send_buf = NULL;
+ sockets[i].recv_buf = NULL;
}
- //initiate uIP
+
+ //initiate uIP
uip_init();
uip_arp_init();
-
- // set up interrupt handler
- // set up device driver
-
+
+ //setup device driver
Init_Ne2k(&Packet_Received);
+
}
static int allocate_socket_fd() {
for (i = 0; i < MAX_SOCKS; i++) {
if (sockets[i].in_use == 0) {
sockets[i].in_use = 1;
+ sockets[i].send_buf = create_ring_buffer(BUF_SIZE);
+ if (sockets[i].send_buf == NULL)
+ return -1;
+ sockets[i].recv_buf = create_ring_buffer(BUF_SIZE);
+ if (sockets[i].recv_buf == NULL){
+ free_ring_buffer(sockets[i].send_buf);
+ return -1;
+ }
return i;
}
}
}
static int release_socket_fd(int sockfd){
- sockets[sockfd].in_use = 0;
- return 0;
+ if (sockfd >= 0 && sockfd < MAX_SOCKS){
+ sockets[sockfd].in_use = 0;
+ free_ring_buffer(sockets[sockfd].send_buf);
+ free_ring_buffer(sockets[sockfd].recv_buf);
+ sockets[sockfd].send_buf = NULL;
+ sockets[sockfd].recv_buf = NULL;
+ }
+
+ return 0;
}
}
-
-
int connect(const uchar_t ip_addr[4], ushort_t port) {
int sockfd = -1;
sockfd = allocate_socket_fd();
sockets[sockfd].con = uip_connect((uip_ipaddr_t *)&ip_addr, htons(port));
+
if (sockets[sockfd].con == NULL){
release_socket_fd(sockfd);
return -1;
return sockfd;
}
+int recv(int sockfd, void * buf, uint_t len){
+ uint_t recvlen;
-void timer_int_Handler(struct Interrupt_State * state){
- int i;
- //handle the periodic calls of uIP
- for(i = 0; i < UIP_CONNS; ++i) {
- uip_periodic(i);
- if(uip_len > 0) {
- //devicedriver_send();
- NE2K_Transmit(uip_len);
- }
- }
- for(i = 0; i < UIP_UDP_CONNS; i++) {
- uip_udp_periodic(i);
- if(uip_len > 0) {
- //devicedriver_send();
- NE2K_Transmit(uip_len);
- }
+ struct socket *sock = get_socket_from_fd(sockfd);
+
+
+ // here we need some lock mechnism, just disable interrupt may not work properly because recv() will be run as a kernel thread
+buf_read:
+ recvlen = rb_read(sock->recv_buf, buf, len);
+
+ if (recvlen == 0){
+ Wait(&(sock->recv_wait_queue));
+ goto buf_read;
}
+
+ return recvlen;
+}
+
+void timer_int_Handler(struct Interrupt_State * state){
+ int i;
+ //handle the periodic calls of uIP
+ for(i = 0; i < UIP_CONNS; ++i) {
+ uip_periodic(i);
+ if(uip_len > 0) {
+ //devicedriver_send();
+ NE2K_Transmit(uip_len);
+ }
+ }
+ for(i = 0; i < UIP_UDP_CONNS; i++) {
+ uip_udp_periodic(i);
+ if(uip_len > 0) {
+ //devicedriver_send();
+ NE2K_Transmit(uip_len);
+ }
+ }
}
// a series of utilities to handle conncetion states
}
static void newdata(int sockfd){
+ uint_t len;
+ char *dataptr;
+ uint_t wrlen;
+ struct socket *sock;
+
+ len = uip_datalen();
+ dataptr = (char *)uip_appdata;
+
+ if (len == 0)
+ return;
+
+ sock = get_socket_from_fd(sockfd);
+
+ wrlen = rb_write(sock->recv_buf, dataptr, len);
+
+ if (wrlen < len){ //write error, what should I do?
+ return;
+ }
+
+ Wake_Up(&(sock->recv_wait_queue));
+
+ return;
}
// not finished yet
-static void senddata(int sockfd){
- uchar_t *bufptr;
- int len = 0;
+static void
+senddata(int sockfd){
+ struct socket * sock = get_socket_from_fd(sockfd);
+ int mss = uip_mss();
+ int pending_bytes = rb_data_len(sock->send_buf);
+ int len = (mss < pending_bytes) ? mss: pending_bytes;
+ int bytes_read = 0;
+ uchar_t * send_buf = uip_appdata;
- bufptr = uip_appdata;
-
- if(len < uip_mss()) {
- // memcpy(bufptr, data, len);
- } else {
-
+ bytes_read = rb_peek(sock->send_buf, send_buf, len);
+
+ if (bytes_read == 0) {
+ // no packet for send
+ return;
}
- //uip_send(uip_appdata,len);
+
+ uip_send(send_buf, len);
}
static int get_socket_from_port(ushort_t lport) {
int i;
- for (i = 0; i<MAX_SOCKS; i++){
+
+ for (i = 0; i < MAX_SOCKS; i++){
if (sockets[i].con->lport == lport) {
return i;
}
-
void socket_appcall(void) {
+
int sockfd;
sockfd = get_socket_from_port(uip_conn->lport);
- if (sockfd == -1) return;
-
- if(uip_connected()) {
- connected(sockfd);
+
+ if (sockfd == -1) {
+ return;
+ }
+
+ if (uip_connected()) {
+ connected(sockfd);
+
}
- if(uip_closed() ||uip_aborted() ||uip_timedout()) {
+ if (uip_closed() ||uip_aborted() ||uip_timedout()) {
closed(sockfd);
return;
}
- if(uip_acked()) {
+ if (uip_acked()) {
acked(sockfd);
}
- if(uip_newdata()) {
+ if (uip_newdata()) {
newdata(sockfd);
}
- if(uip_rexmit() ||
- uip_newdata() ||
- uip_acked() ||
- uip_connected() ||
- uip_poll()) {
- senddata(sockfd);
+ if (uip_rexmit() ||
+ uip_newdata() ||
+ uip_acked() ||
+ uip_connected() ||
+ uip_poll()) {
+ senddata(sockfd);
}
}
-int Packet_Received(struct NE2K_Packet_Info* info, uchar_t *pkt) {
- struct sock_packet next;
- int i;
-
- next.size = info->size;
- next.data = (uchar_t *)Malloc(next.size);
-
- if (next.data == NULL) {
- return 1;
- }
- //uip_len = info->size;
+int Packet_Received(struct NE2K_Packet_Info * info, uchar_t * pkt) {
+ //int i;
- for(i = 0; i < info->size; i++) {
- *((next.data) + i) = *(pkt + i);
- }
+ uip_len = info->size;
+
+ // for (i = 0; i < info->size; i++) {
+ // uip_buf[i] = *(pkt + i);
+ //}
+
+ memcpy(uip_buf, pkt, uip_len);
+
+
Free(pkt);
-
- Disable_Interrupts();
- enqueue(&in_packets, &next);
- Enable_Interrupts();
-
- //triger_receiver_interrupt();
-
- return 0;
-}
+ if (BUF->type == htons(UIP_ETHTYPE_ARP)) {
+ uip_arp_arpin();
-void int_handler_packet_receive(struct Interrupt_State * state){
- //device driver got a incoming packet and enqueue that packet to the receive queue
- struct sock_packet * next_packet;
- void * pkt;
- int i;
-
- while(1){
- //currently disable interrupt because no lock for the queue
- Disable_Interrupts();
- pkt = dequeue(&in_packets);
- Enable_Interrupts();
-
- if (pkt == NULL) {
- break;
- }
+ if (uip_len > 0) {
+ NE2K_Transmit(uip_len);
+ }
- //there are new packets in the receiver queue
- next_packet = (struct sock_packet *)pkt;
- uip_len = next_packet->size;
-
- for(i = 0; i < uip_len; i++) {
- uip_buf[i] = *((next_packet->data) + i);
+ } else {
+
+ uip_arp_ipin();
+ uip_input();
+
+ if (uip_len > 0) {
+ uip_arp_out();
+ NE2K_Transmit(uip_len);
}
-
- Free(next_packet->data);
- Free(next_packet);
-
- if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
- uip_arp_arpin();
- if (uip_len > 0){
- //ethernet_devicedriver_send();
- NE2K_Transmit(uip_len);
- }
- } else {
- uip_arp_ipin();
- uip_input();
- if(uip_len > 0) {
- uip_arp_out();
- //ethernet_devicedriver_send();
- NE2K_Transmit(uip_len);
- }
- }
- }
+ }
+
+ return 0;
+
}
