[GDB] UDP clean up and add netdev refcnt
[people/balajirrao/gpxe.git] / src / core / gdbudp.c
1 /*
2  * Copyright (C) 2008 Stefan Hajnoczi <stefanha@gmail.com>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <stdio.h>
20 #include <string.h>
21 #include <byteswap.h>
22 #include <gpxe/iobuf.h>
23 #include <gpxe/in.h>
24 #include <gpxe/if_arp.h>
25 #include <gpxe/if_ether.h>
26 #include <gpxe/ip.h>
27 #include <gpxe/udp.h>
28 #include <gpxe/netdevice.h>
29 #include <gpxe/gdbstub.h>
30 #include <bios.h>
31
32 /** @file
33  *
34  * GDB over UDP transport
35  *
36  */
37
38 enum {
39         DEFAULT_PORT = 43770, /* UDP listen port */
40 };
41
42 struct gdb_transport udp_gdb_transport __gdb_transport;
43
44 static struct net_device *netdev;
45 static uint8_t dest_eth[ETH_ALEN];
46 static uint8_t source_eth[ETH_ALEN];
47 static struct sockaddr_in dest_addr;
48 static struct sockaddr_in source_addr;
49
50 static void gdbudp_ensure_netdev_open ( struct net_device *netdev ) {
51         /* The device may have been closed between breakpoints */
52         assert ( netdev );
53         netdev_open ( netdev );
54
55         /* Strictly speaking, we may need to close the device when leaving the interrupt handler */
56 }
57
58 static size_t gdbudp_recv ( char *buf, size_t len ) {
59         struct io_buffer *iob;
60         struct ethhdr *ethhdr;
61         struct arphdr *arphdr;
62         struct iphdr *iphdr;
63         struct udp_header *udphdr;
64         size_t payload_len;
65
66         gdbudp_ensure_netdev_open ( netdev );
67
68         for ( ; ; ) {
69                 netdev_poll ( netdev );
70                 while ( ( iob = netdev_rx_dequeue ( netdev ) ) != NULL ) {
71                         /* Ethernet header */
72                         if ( iob_len ( iob ) < sizeof ( *ethhdr ) ) {
73                                 goto bad_packet;
74                         }
75                         ethhdr = iob->data;
76                         iob_pull ( iob, sizeof ( *ethhdr ) );
77
78                         /* Handle ARP requests so the client can find our MAC */
79                         if ( ethhdr->h_protocol == htons ( ETH_P_ARP ) ) {
80                                 arphdr = iob->data;
81                                 if ( iob_len ( iob ) < sizeof ( *arphdr ) + 2 * ( ETH_ALEN + sizeof ( struct in_addr ) ) ||
82                                                 arphdr->ar_hrd != htons ( ARPHRD_ETHER ) ||
83                                                 arphdr->ar_pro != htons ( ETH_P_IP ) ||
84                                                 arphdr->ar_hln != ETH_ALEN ||
85                                                 arphdr->ar_pln != sizeof ( struct in_addr ) ||
86                                                 arphdr->ar_op != htons ( ARPOP_REQUEST ) ||
87                                                 * ( uint32_t * ) arp_target_pa ( arphdr ) != source_addr.sin_addr.s_addr ) {
88                                         goto bad_packet;
89                                 }
90
91                                 /* Generate an ARP reply */
92                                 arphdr->ar_op = htons ( ARPOP_REPLY );
93                                 memswap ( arp_sender_pa ( arphdr ), arp_target_pa ( arphdr ), sizeof ( struct in_addr ) );
94                                 memcpy ( arp_target_ha ( arphdr ), arp_sender_ha ( arphdr ), ETH_ALEN );
95                                 memcpy ( arp_sender_ha ( arphdr ), source_eth, ETH_ALEN );
96
97                                 /* Fix up ethernet header */
98                                 ethhdr = iob_push ( iob, sizeof ( *ethhdr ) );
99                                 memswap ( ethhdr->h_source, ethhdr->h_dest, ETH_ALEN );
100
101                                 netdev_tx ( netdev, iob );
102                                 continue; /* no need to free iob */
103                         }
104
105                         if ( ethhdr->h_protocol != htons ( ETH_P_IP ) ) {
106                                 goto bad_packet;
107                         }
108
109                         /* IP header */
110                         if ( iob_len ( iob ) < sizeof ( *iphdr ) ) {
111                                 goto bad_packet;
112                         }
113                         iphdr = iob->data;
114                         iob_pull ( iob, sizeof ( *iphdr ) );
115                         if ( iphdr->protocol != IP_UDP || iphdr->dest.s_addr != source_addr.sin_addr.s_addr ) {
116                                 goto bad_packet;
117                         }
118
119                         /* UDP header */
120                         if ( iob_len ( iob ) < sizeof ( *udphdr ) ) {
121                                 goto bad_packet;
122                         }
123                         udphdr = iob->data;
124                         if ( udphdr->dest != source_addr.sin_port ) {
125                                 goto bad_packet;
126                         }
127
128                         /* Learn the remote connection details */
129                         memcpy ( dest_eth, ethhdr->h_source, ETH_ALEN );
130                         dest_addr.sin_addr.s_addr = iphdr->src.s_addr;
131                         dest_addr.sin_port = udphdr->src;
132
133                         /* Payload */
134                         payload_len = ntohs ( udphdr->len );
135                         if ( payload_len < sizeof ( *udphdr ) || payload_len > iob_len ( iob ) ) {
136                                 goto bad_packet;
137                         }
138                         payload_len -= sizeof ( *udphdr );
139                         iob_pull ( iob, sizeof ( *udphdr ) );
140                         if ( payload_len > len ) {
141                                 goto bad_packet;
142                         }
143                         memcpy ( buf, iob->data, payload_len );
144
145                         free_iob ( iob );
146                         return payload_len;
147
148 bad_packet:
149                         free_iob ( iob );
150                 }
151                 cpu_nap();
152         }
153 }
154
155 static void gdbudp_send ( const char *buf, size_t len ) {
156         struct io_buffer *iob;
157         struct ethhdr *ethhdr;
158         struct iphdr *iphdr;
159         struct udp_header *udphdr;
160
161         /* Check that we are connected */
162         if ( dest_addr.sin_port == 0 ) {
163                 return;
164         }
165
166         gdbudp_ensure_netdev_open ( netdev );
167
168         iob = alloc_iob ( sizeof ( *ethhdr ) + sizeof ( *iphdr ) + sizeof ( *udphdr ) + len );
169         if ( !iob ) {
170                 return;
171         }
172
173         /* Payload */
174         iob_reserve ( iob, sizeof ( *ethhdr ) + sizeof ( *iphdr ) + sizeof ( *udphdr ) );
175         memcpy ( iob_put ( iob, len ), buf, len );
176
177         /* UDP header */
178         udphdr = iob_push ( iob, sizeof ( *udphdr ) );
179         udphdr->src = source_addr.sin_port;
180         udphdr->dest = dest_addr.sin_port;
181         udphdr->len = htons ( iob_len ( iob ) );
182         udphdr->chksum = 0; /* optional and we are not using it */
183
184         /* IP header */
185         iphdr = iob_push ( iob, sizeof ( *iphdr ) );
186         memset ( iphdr, 0, sizeof ( *iphdr ) );
187         iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
188         iphdr->service = IP_TOS;
189         iphdr->len = htons ( iob_len ( iob ) ); 
190         iphdr->ttl = IP_TTL;
191         iphdr->protocol = IP_UDP;
192         iphdr->dest.s_addr = dest_addr.sin_addr.s_addr;
193         iphdr->src.s_addr = source_addr.sin_addr.s_addr;
194         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
195
196         /* Ethernet header */
197         ethhdr = iob_push ( iob, sizeof ( *ethhdr ) );
198         memcpy ( ethhdr->h_dest, dest_eth, ETH_ALEN );
199         memcpy ( ethhdr->h_source, source_eth, ETH_ALEN );
200         ethhdr->h_protocol = htons ( ETH_P_IP );
201
202         netdev_tx ( netdev, iob );
203 }
204
205 static int gdbudp_init ( int argc, char **argv ) {
206         struct settings *settings;
207
208         if ( argc != 1 ) {
209                 printf ( "udp: missing <interface> argument\n" );
210                 return 1;
211         }
212
213         /* Release old network device */
214         netdev_put ( netdev );
215
216         netdev = find_netdev ( argv[0] );
217         if ( !netdev ) {
218                 printf ( "%s: no such interface\n", argv[0] );
219                 return 1;
220         }
221
222         /* Hold network device */
223         netdev_get ( netdev );
224
225         if ( !netdev_link_ok ( netdev ) ) {
226                 printf ( "%s: link not up\n", argv[0] );
227                 netdev_put ( netdev );
228                 netdev = NULL;
229                 return 1;
230         }
231
232         /* Load network settings from device.  We keep the MAC address,
233          * IP address, and UDP port.  The MAC and IP could be fetched
234          * from the network device each time they are used in rx/tx.
235          * Storing a separate copy makes it possible to use different
236          * MAC/IP settings than the network stack. */
237         memcpy ( source_eth, netdev->ll_addr, ETH_ALEN );
238         source_addr.sin_port = htons ( DEFAULT_PORT );
239         settings = netdev_settings ( netdev );
240         fetch_ipv4_setting ( settings, &ip_setting, &source_addr.sin_addr );
241         if ( source_addr.sin_addr.s_addr == 0 ) {
242                 printf ( "%s: no IP address configured\n", argv[0] );
243                 netdev_put ( netdev );
244                 netdev = NULL;
245                 return 1;
246         }
247
248         return 0;
249 }
250
251 struct gdb_transport udp_gdb_transport __gdb_transport = {
252         .name = "udp",
253         .init = gdbudp_init,
254         .send = gdbudp_send,
255         .recv = gdbudp_recv,
256 };