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