Merge origin/netpush (networking code) (XCC)
[akaros.git] / kern / src / net / udp.c
1 /**
2  * Contains shamelessly stolen code from BSD & lwip, both have
3  * BSD-style licenses
4  *
5  */
6 #include <ros/common.h>
7 #include <string.h>
8 #include <kmalloc.h>
9 #include <socket.h>
10 #include <net.h>
11 #include <sys/queue.h>
12 #include <atomic.h>
13
14 #include <bits/netinet.h>
15 #include <net/ip.h>
16 #include <net/udp.h>
17 #include <slab.h>
18 #include <socket.h>
19 #include <debug.h>
20
21 struct udp_pcb *udp_pcbs;
22 uint16_t udp_port_num = SOCKET_PORT_START;
23
24 struct udp_pcb* udp_new(void){
25         struct udp_pcb *pcb = kmem_cache_alloc(udp_pcb_kcache, 0);
26     // if pcb is only tracking ttl, then no need!
27         if (pcb!= NULL){
28                 pcb->ttl = UDP_TTL;
29         memset(pcb, 0, sizeof(struct udp_pcb));
30         }
31         return pcb;
32 }
33
34 int udp_send(struct udp_pcb *pcb, struct pbuf *p)
35 {
36   /* send to the packet using remote ip and port stored in the pcb */
37   // rip and rport should be in socket not pcb?
38   return udp_sendto(pcb, p, &pcb->remote_ip, pcb->remote_port);
39 }
40
41 typedef unsigned char u16;
42 typedef unsigned long u32;
43
44 u16 udp_sum_calc(u16 len_udp, u16 src_addr[],u16 dest_addr[],  int padding, u16 buff[])
45 {
46 u16 prot_udp=17;
47 u16 padd=0;
48 u16 word16;
49 u32 sum;
50 int i;
51         
52         // Find out if the length of data is even or odd number. If odd,
53         // add a padding byte = 0 at the end of packet
54         if ((padding&1)==1){
55                 padd=1;
56                 buff[len_udp]=0;
57         }
58         
59         //initialize sum to zero
60         sum=0;
61         
62         // make 16 bit words out of every two adjacent 8 bit words and 
63         // calculate the sum of all 16 vit words
64         for (i=0;i<len_udp+padd;i=i+2){
65                 word16 =((buff[i]<<8)&0xFF00)+(buff[i+1]&0xFF);
66                 sum = sum + (unsigned long)word16;
67         }       
68         // add the UDP pseudo header which contains the IP source and destinationn addresses
69         for (i=0;i<4;i=i+2){
70                 word16 =((src_addr[i]<<8)&0xFF00)+(src_addr[i+1]&0xFF);
71                 sum=sum+word16; 
72         }
73         for (i=0;i<4;i=i+2){
74                 word16 =((dest_addr[i]<<8)&0xFF00)+(dest_addr[i+1]&0xFF);
75                 sum=sum+word16;         
76         }
77         // the protocol number and the length of the UDP packet
78         sum = sum + prot_udp + len_udp;
79
80         // keep only the last 16 bits of the 32 bit calculated sum and add the carries
81         while (sum>>16)
82                 sum = (sum & 0xFFFF)+(sum >> 16);
83                 
84         // Take the one's complement of sum
85         sum = ~sum;
86
87 return ((u16) sum);
88 }
89
90 int udp_sendto(struct udp_pcb *pcb, struct pbuf *p,
91                     struct in_addr *dst_ip, uint16_t dst_port){
92     // we now have one netif to send to, otherwise we need to route
93     // ip_route();
94     struct udp_hdr *udphdr;
95     struct pbuf *q;
96                 printd("udp_sendto ip %x, port %d\n", dst_ip->s_addr, dst_port); 
97     // broadcast?
98     if (pcb->local_port == 0) {
99                                 /* if the PCB not bound to a port, bind it and give local ip */
100         if (udp_bind(pcb, &pcb->local_ip, pcb->local_port)!=0)
101                                         warn("udp binding failed \n");
102     }
103     if (pbuf_header(p, UDP_HLEN)){ // we could probably save this check for block.
104         // CHECK: should allocate enough for the other headers too
105         q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM);
106         if (q == NULL)
107            panic("out of memory");
108         // if the original packet is not empty
109         if (p->tot_len !=0) {
110             pbuf_chain(q,p);
111             // check if it is chained properly ..
112         }
113     } else {
114                                 /* Successfully padded the header*/
115                                 q = p;
116     }
117
118     udphdr = (struct udp_hdr *) q->payload;
119                 printd("src port %d, dst port %d \n, length %d ", pcb->local_port, ntohs(dst_port), q->tot_len);
120     udphdr->src_port = htons(pcb->local_port);
121     udphdr->dst_port = (dst_port);
122     udphdr->length = htons(q->tot_len); 
123                 udphdr->checksum = 0; // just to be sure.
124                 // printd("checksum inet_chksum %x \n", udphdr->checksum);
125                 printd("params src addr %x, dst addr %x, length %x \n", LOCAL_IP_ADDR.s_addr, (dst_ip->s_addr), 
126                                           q->tot_len);
127
128     udphdr->checksum = inet_chksum_pseudo(q, htonl(LOCAL_IP_ADDR.s_addr), dst_ip->s_addr,
129                                                                                          IPPROTO_UDP, q->tot_len);
130                 printd ("method ours %x\n", udphdr->checksum);
131                 // 0x0000; //either use brho's checksum or use cards' capabilities
132                 ip_output(q, &LOCAL_IP_ADDR, dst_ip, pcb->ttl, pcb->tos, IPPROTO_UDP);
133                 // ip_output(q, &global_ip, dst_ip, IPPROTO_UDP);
134     return 0;
135 }
136 /* TODO: use the real queues we have implemented... */
137 int udp_bind(struct udp_pcb *pcb, const struct in_addr *ip, uint16_t port){ 
138     int rebind = pcb->local_port;
139     struct udp_pcb *ipcb;
140                 assert(pcb);
141                 /* trying to assign port */
142     if (port != 0)
143         pcb->local_port = port;
144
145     /* no lock needed since we are just traversing/reading */
146     /* Check for double bind and rebind of the same pcb */
147     for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) {
148         /* is this UDP PCB already on active list? */
149         if (pcb == ipcb) {
150             rebind = 1; //already on the list
151         } else if (ipcb->local_port == port){
152             warn("someone else is using the port %d\n" , port); 
153             return -1;
154         }
155     }
156     /* accept data for all interfaces */
157     if (ip == NULL || (ip->s_addr == INADDR_ANY.s_addr))
158                 /* true right now */
159         pcb->local_ip = INADDR_ANY;
160     /* assign a port */
161     if (port == 0) {
162         port = SOCKET_PORT_START; 
163         ipcb = udp_pcbs;
164         while ((ipcb != NULL) && (port != SOCKET_PORT_END)) {
165             if (ipcb->local_port == port) {
166                 /* port is already used by another udp_pcb */
167                 port++;
168                 /* restart scanning all udp pcbs */
169                 ipcb = udp_pcbs;
170             } else {
171                 /* go on with next udp pcb */
172                 ipcb = ipcb->next;
173             }
174         }
175         if (ipcb != NULL){
176             warn("No more udp ports available!");
177         }
178     }
179     if (rebind == 0) {
180         /* place the PCB on the active list if not already there */
181                                 pcb->next = udp_pcbs;
182                                 udp_pcbs = pcb;
183     }
184                 printk("local port bound to 0x%x \n", port);
185     pcb->local_port = port;
186     return 0;
187 }
188
189 /* port are in host order, ips are in network order */
190 /* Think: a pcb is here, if someone is waiting for a connection or the udp conn
191  * has been established */
192 static struct udp_pcb* find_pcb(struct udp_pcb* list, uint16_t src_port, uint16_t dst_port,
193                                                                 uint16_t srcip, uint16_t dstip) {
194         struct udp_pcb* uncon_pcb = NULL;
195         struct udp_pcb* pcb = NULL;
196         uint8_t local_match = 0;
197
198         for (pcb = list; pcb != NULL; pcb = pcb->next) {
199                 local_match = 0;
200                 if ((pcb->local_port == dst_port) 
201                         && (pcb->local_ip.s_addr == dstip 
202                         || ip_addr_isany(&pcb->local_ip))){
203                                 local_match = 1;
204         if ((uncon_pcb == NULL) && 
205             ((pcb->flags & UDP_FLAGS_CONNECTED) == 0)) {
206           /* the first unconnected matching PCB */
207           uncon_pcb = pcb;
208         }
209                 }
210
211                 if (local_match && (pcb->remote_port == src_port) &&
212                                 (ip_addr_isany(&pcb->remote_ip) ||
213                                  pcb->remote_ip.s_addr == srcip))
214                         /* perfect match */
215                         return pcb;
216         }
217         return uncon_pcb;
218 }
219
220 #if 0 // not working yet
221 // need to have pbuf queue support
222 int udp_attach(struct pbuf *p, struct sock *socket) {
223         // pretend the attaching of packet is succesful
224         /*
225         recv_q->last->next = p;
226         recv_q->last=p->last
227         */ 
228 }
229
230 #endif 
231
232 /** Process an incoming UDP datagram. 
233  * Given an incoming UDP datagram, this function finds the right PCB
234  * which links to the right socket buffer, and attaches the datagram
235  * to the right socket. 
236  * If no appropriate PCB is found, the pbuf is freed.
237  */ 
238
239 /** TODO: think about combining udp_input and ip_input together */
240 // TODO: figure out if we even need a PCB? or just socket buff. 
241 // TODO: test out looking up pcbs.. since matching function may fail
242
243 int udp_input(struct pbuf *p){
244         struct udp_hdr *udphdr;
245
246         struct udp_pcb *pcb, uncon_pcb;
247         struct ip_hdr *iphdr;
248         uint16_t src, dst;
249         bool local_match = 0;
250         iphdr = (struct ip_hdr *)p->payload;
251         /* Move the header to where the udp header is */
252         if (pbuf_header(p, -((int16_t)((iphdr->hdr_len) * 4)))) {
253                 warn("udp_input: Did not find a matching PCB for a udp packet\n");
254                 pbuf_free(p);
255                 return -1;
256         }
257         printk("start of udp %p\n", p->payload);
258         udphdr = (struct udp_hdr *)p->payload;
259         /* convert the src port and dst port to host order */
260         src = ntohs(udphdr->src_port);
261         dst = ntohs(udphdr->dst_port);
262         pcb = find_pcb(udp_pcbs, src, dst, iphdr->src_addr, iphdr->dst_addr);
263         /* TODO: Possibly adjust the pcb to the head of the queue? */
264         /* TODO: Linux uses a set of hashtables to lookup PCBs 
265          * Look at __udp4_lib_lookup function in Linux kernel 2.6.21.1
266          */
267         /* Anything that is not directed at this pcb should have been dropped */
268         if (pcb == NULL){
269                 warn("udp_input: Did not find a matching PCB for a udp packet\n");
270                 pbuf_free(p);
271                 return -1;
272         }
273
274         /* checksum check */
275   if (udphdr->checksum != 0) {
276     if (inet_chksum_pseudo(p, (iphdr->src_addr), (iphdr->dst_addr), 
277                                  IPPROTO_UDP, p->tot_len) != 0){
278                         warn("udp_input: UPD datagram discarded due to failed chksum!");
279                         pbuf_free(p);
280                         return -1;
281     }
282         }
283   /* ignore SO_REUSE */
284         if (pcb != NULL && pcb->pcbsock != NULL){
285                 /* For each in the pbuf chain, disconnect from the chain and add it to the
286                  * recv_buff of the correct socket 
287                  */ 
288                 struct socket *sock = pcb->pcbsock;
289                 attach_pbuf(p, &sock->recv_buff);
290                 struct kthread *kthread;
291                 int8_t irq_state = 0;
292                 /* First notify any blocking recv calls,
293                  * then notify anyone who might be waiting in a select
294                  */ 
295                 // multiple people might be waiting on the socket here..
296                 /* TODO: consider a helper with this and tcp.c */
297                 if (!sem_up_irqsave(&sock->sem, &irq_state)) {
298                         // wake up all waiters
299                         struct semaphore_entry *sentry, *sentry_tmp;
300                         spin_lock(&sock->waiter_lock);
301                         LIST_FOREACH_SAFE(sentry, &sock->waiters, link, sentry_tmp) {
302                                 //should only wake up one waiter
303                                 sem_up_irqsave(&sentry->sem, &irq_state);
304                                 LIST_REMOVE(sentry, link);
305                                 /* do not need to free since all the sentry are stack-based vars
306                                  * */
307                         }
308                         spin_unlock(&sock->waiter_lock);
309                 }
310                 // the attaching of pbuf should have increfed pbuf ref, so free is simply a decref
311                 pbuf_free(p);
312         }
313         return 0;
314 }