arm: Centralize fixed register logic
[platform/kernel/u-boot.git] / net / wget.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * WGET/HTTP support driver based on U-BOOT's nfs.c
4  * Copyright Duncan Hare <dh@synoia.com> 2017
5  */
6
7 #include <command.h>
8 #include <common.h>
9 #include <display_options.h>
10 #include <env.h>
11 #include <image.h>
12 #include <mapmem.h>
13 #include <net.h>
14 #include <net/tcp.h>
15 #include <net/wget.h>
16
17 static const char bootfile1[] = "GET ";
18 static const char bootfile3[] = " HTTP/1.0\r\n\r\n";
19 static const char http_eom[] = "\r\n\r\n";
20 static const char http_ok[] = "200";
21 static const char content_len[] = "Content-Length";
22 static const char linefeed[] = "\r\n";
23 static struct in_addr web_server_ip;
24 static int our_port;
25 static int wget_timeout_count;
26
27 struct pkt_qd {
28         uchar *pkt;
29         unsigned int tcp_seq_num;
30         unsigned int len;
31 };
32
33 /*
34  * This is a control structure for out of order packets received.
35  * The actual packet bufers are in the kernel space, and are
36  * expected to be overwritten by the downloaded image.
37  */
38 static struct pkt_qd pkt_q[PKTBUFSRX / 4];
39 static int pkt_q_idx;
40 static unsigned long content_length;
41 static unsigned int packets;
42
43 static unsigned int initial_data_seq_num;
44
45 static enum  wget_state current_wget_state;
46
47 static char *image_url;
48 static unsigned int wget_timeout = WGET_TIMEOUT;
49
50 static enum net_loop_state wget_loop_state;
51
52 /* Timeout retry parameters */
53 static u8 retry_action;                 /* actions for TCP retry */
54 static unsigned int retry_tcp_ack_num;  /* TCP retry acknowledge number*/
55 static unsigned int retry_tcp_seq_num;  /* TCP retry sequence number */
56 static int retry_len;                   /* TCP retry length */
57
58 /**
59  * store_block() - store block in memory
60  * @src: source of data
61  * @offset: offset
62  * @len: length
63  */
64 static inline int store_block(uchar *src, unsigned int offset, unsigned int len)
65 {
66         ulong newsize = offset + len;
67         uchar *ptr;
68
69         ptr = map_sysmem(image_load_addr + offset, len);
70         memcpy(ptr, src, len);
71         unmap_sysmem(ptr);
72
73         if (net_boot_file_size < (offset + len))
74                 net_boot_file_size = newsize;
75
76         return 0;
77 }
78
79 /**
80  * wget_send_stored() - wget response dispatcher
81  *
82  * WARNING, This, and only this, is the place in wget.c where
83  * SEQUENCE NUMBERS are swapped between incoming (RX)
84  * and outgoing (TX).
85  * Procedure wget_handler() is correct for RX traffic.
86  */
87 static void wget_send_stored(void)
88 {
89         u8 action = retry_action;
90         int len = retry_len;
91         unsigned int tcp_ack_num = retry_tcp_ack_num + len;
92         unsigned int tcp_seq_num = retry_tcp_seq_num;
93         uchar *ptr, *offset;
94
95         switch (current_wget_state) {
96         case WGET_CLOSED:
97                 debug_cond(DEBUG_WGET, "wget: send SYN\n");
98                 current_wget_state = WGET_CONNECTING;
99                 net_send_tcp_packet(0, SERVER_PORT, our_port, action,
100                                     tcp_seq_num, tcp_ack_num);
101                 packets = 0;
102                 break;
103         case WGET_CONNECTING:
104                 pkt_q_idx = 0;
105                 net_send_tcp_packet(0, SERVER_PORT, our_port, action,
106                                     tcp_seq_num, tcp_ack_num);
107
108                 ptr = net_tx_packet + net_eth_hdr_size() +
109                         IP_TCP_HDR_SIZE + TCP_TSOPT_SIZE + 2;
110                 offset = ptr;
111
112                 memcpy(offset, &bootfile1, strlen(bootfile1));
113                 offset += strlen(bootfile1);
114
115                 memcpy(offset, image_url, strlen(image_url));
116                 offset += strlen(image_url);
117
118                 memcpy(offset, &bootfile3, strlen(bootfile3));
119                 offset += strlen(bootfile3);
120                 net_send_tcp_packet((offset - ptr), SERVER_PORT, our_port,
121                                     TCP_PUSH, tcp_seq_num, tcp_ack_num);
122                 current_wget_state = WGET_CONNECTED;
123                 break;
124         case WGET_CONNECTED:
125         case WGET_TRANSFERRING:
126         case WGET_TRANSFERRED:
127                 net_send_tcp_packet(0, SERVER_PORT, our_port, action,
128                                     tcp_seq_num, tcp_ack_num);
129                 break;
130         }
131 }
132
133 static void wget_send(u8 action, unsigned int tcp_ack_num,
134                       unsigned int tcp_seq_num, int len)
135 {
136         retry_action = action;
137         retry_tcp_ack_num = tcp_ack_num;
138         retry_tcp_seq_num = tcp_seq_num;
139         retry_len = len;
140
141         wget_send_stored();
142 }
143
144 void wget_fail(char *error_message, unsigned int tcp_seq_num,
145                unsigned int tcp_ack_num, u8 action)
146 {
147         printf("wget: Transfer Fail - %s\n", error_message);
148         net_set_timeout_handler(0, NULL);
149         wget_send(action, tcp_seq_num, tcp_ack_num, 0);
150 }
151
152 void wget_success(u8 action, unsigned int tcp_seq_num,
153                   unsigned int tcp_ack_num, int len, int packets)
154 {
155         printf("Packets received %d, Transfer Successful\n", packets);
156         wget_send(action, tcp_seq_num, tcp_ack_num, len);
157 }
158
159 /*
160  * Interfaces of U-BOOT
161  */
162 static void wget_timeout_handler(void)
163 {
164         if (++wget_timeout_count > WGET_RETRY_COUNT) {
165                 puts("\nRetry count exceeded; starting again\n");
166                 wget_send(TCP_RST, 0, 0, 0);
167                 net_start_again();
168         } else {
169                 puts("T ");
170                 net_set_timeout_handler(wget_timeout +
171                                         WGET_TIMEOUT * wget_timeout_count,
172                                         wget_timeout_handler);
173                 wget_send_stored();
174         }
175 }
176
177 #define PKT_QUEUE_OFFSET 0x20000
178 #define PKT_QUEUE_PACKET_SIZE 0x800
179
180 static void wget_connected(uchar *pkt, unsigned int tcp_seq_num,
181                            struct in_addr action_and_state,
182                            unsigned int tcp_ack_num, unsigned int len)
183 {
184         u8 action = action_and_state.s_addr;
185         uchar *pkt_in_q;
186         char *pos;
187         int hlen, i;
188         uchar *ptr1;
189
190         pkt[len] = '\0';
191         pos = strstr((char *)pkt, http_eom);
192
193         if (!pos) {
194                 debug_cond(DEBUG_WGET,
195                            "wget: Connected, data before Header %p\n", pkt);
196                 pkt_in_q = (void *)image_load_addr + PKT_QUEUE_OFFSET +
197                         (pkt_q_idx * PKT_QUEUE_PACKET_SIZE);
198
199                 ptr1 = map_sysmem((phys_addr_t)pkt_in_q, len);
200                 memcpy(ptr1, pkt, len);
201                 unmap_sysmem(ptr1);
202
203                 pkt_q[pkt_q_idx].pkt = pkt_in_q;
204                 pkt_q[pkt_q_idx].tcp_seq_num = tcp_seq_num;
205                 pkt_q[pkt_q_idx].len = len;
206                 pkt_q_idx++;
207         } else {
208                 debug_cond(DEBUG_WGET, "wget: Connected HTTP Header %p\n", pkt);
209                 /* sizeof(http_eom) - 1 is the string length of (http_eom) */
210                 hlen = pos - (char *)pkt + sizeof(http_eom) - 1;
211                 pos = strstr((char *)pkt, linefeed);
212                 if (pos > 0)
213                         i = pos - (char *)pkt;
214                 else
215                         i = hlen;
216                 printf("%.*s", i,  pkt);
217
218                 current_wget_state = WGET_TRANSFERRING;
219
220                 if (strstr((char *)pkt, http_ok) == 0) {
221                         debug_cond(DEBUG_WGET,
222                                    "wget: Connected Bad Xfer\n");
223                         initial_data_seq_num = tcp_seq_num + hlen;
224                         wget_loop_state = NETLOOP_FAIL;
225                         wget_send(action, tcp_seq_num, tcp_ack_num, len);
226                 } else {
227                         debug_cond(DEBUG_WGET,
228                                    "wget: Connctd pkt %p  hlen %x\n",
229                                    pkt, hlen);
230                         initial_data_seq_num = tcp_seq_num + hlen;
231
232                         pos = strstr((char *)pkt, content_len);
233                         if (!pos) {
234                                 content_length = -1;
235                         } else {
236                                 pos += sizeof(content_len) + 2;
237                                 strict_strtoul(pos, 10, &content_length);
238                                 debug_cond(DEBUG_WGET,
239                                            "wget: Connected Len %lu\n",
240                                            content_length);
241                         }
242
243                         net_boot_file_size = 0;
244
245                         if (len > hlen)
246                                 store_block(pkt + hlen, 0, len - hlen);
247
248                         debug_cond(DEBUG_WGET,
249                                    "wget: Connected Pkt %p hlen %x\n",
250                                    pkt, hlen);
251
252                         for (i = 0; i < pkt_q_idx; i++) {
253                                 ptr1 = map_sysmem(
254                                         (phys_addr_t)(pkt_q[i].pkt),
255                                         pkt_q[i].len);
256                                 store_block(ptr1,
257                                             pkt_q[i].tcp_seq_num -
258                                             initial_data_seq_num,
259                                             pkt_q[i].len);
260                                 unmap_sysmem(ptr1);
261                                 debug_cond(DEBUG_WGET,
262                                            "wget: Connctd pkt Q %p len %x\n",
263                                            pkt_q[i].pkt, pkt_q[i].len);
264                         }
265                 }
266         }
267         wget_send(action, tcp_seq_num, tcp_ack_num, len);
268 }
269
270 /**
271  * wget_handler() - handler of wget
272  * @pkt: the pointer to the payload
273  * @tcp_seq_num: tcp sequence number
274  * @action_and_state: TCP state
275  * @tcp_ack_num: tcp acknowledge number
276  * @len: length of the payload
277  *
278  * In the "application push" invocation, the TCP header with all
279  * its information is pointed to by the packet pointer.
280  */
281 static void wget_handler(uchar *pkt, unsigned int tcp_seq_num,
282                          struct in_addr action_and_state,
283                          unsigned int tcp_ack_num, unsigned int len)
284 {
285         enum tcp_state wget_tcp_state = tcp_get_tcp_state();
286         u8 action = action_and_state.s_addr;
287
288         net_set_timeout_handler(wget_timeout, wget_timeout_handler);
289         packets++;
290
291         switch (current_wget_state) {
292         case WGET_CLOSED:
293                 debug_cond(DEBUG_WGET, "wget: Handler: Error!, State wrong\n");
294                 break;
295         case WGET_CONNECTING:
296                 debug_cond(DEBUG_WGET,
297                            "wget: Connecting In len=%x, Seq=%x, Ack=%x\n",
298                            len, tcp_seq_num, tcp_ack_num);
299                 if (!len) {
300                         if (wget_tcp_state == TCP_ESTABLISHED) {
301                                 debug_cond(DEBUG_WGET,
302                                            "wget: Cting, send, len=%x\n", len);
303                                 wget_send(action, tcp_seq_num, tcp_ack_num,
304                                           len);
305                         } else {
306                                 printf("%.*s", len,  pkt);
307                                 wget_fail("wget: Handler Connected Fail\n",
308                                           tcp_seq_num, tcp_ack_num, action);
309                         }
310                 }
311                 break;
312         case WGET_CONNECTED:
313                 debug_cond(DEBUG_WGET, "wget: Connected seq=%x, len=%x\n",
314                            tcp_seq_num, len);
315                 if (!len) {
316                         wget_fail("Image not found, no data returned\n",
317                                   tcp_seq_num, tcp_ack_num, action);
318                 } else {
319                         wget_connected(pkt, tcp_seq_num, action_and_state,
320                                        tcp_ack_num, len);
321                 }
322                 break;
323         case WGET_TRANSFERRING:
324                 debug_cond(DEBUG_WGET,
325                            "wget: Transferring, seq=%x, ack=%x,len=%x\n",
326                            tcp_seq_num, tcp_ack_num, len);
327
328                 if (tcp_seq_num >= initial_data_seq_num &&
329                     store_block(pkt, tcp_seq_num - initial_data_seq_num,
330                                 len) != 0) {
331                         wget_fail("wget: store error\n",
332                                   tcp_seq_num, tcp_ack_num, action);
333                         return;
334                 }
335
336                 switch (wget_tcp_state) {
337                 case TCP_FIN_WAIT_2:
338                         wget_send(TCP_ACK, tcp_seq_num, tcp_ack_num, len);
339                         fallthrough;
340                 case TCP_SYN_SENT:
341                 case TCP_CLOSING:
342                 case TCP_FIN_WAIT_1:
343                 case TCP_CLOSED:
344                         net_set_state(NETLOOP_FAIL);
345                         break;
346                 case TCP_ESTABLISHED:
347                         wget_send(TCP_ACK, tcp_seq_num, tcp_ack_num,
348                                   len);
349                         wget_loop_state = NETLOOP_SUCCESS;
350                         break;
351                 case TCP_CLOSE_WAIT:     /* End of transfer */
352                         current_wget_state = WGET_TRANSFERRED;
353                         wget_send(action | TCP_ACK | TCP_FIN,
354                                   tcp_seq_num, tcp_ack_num, len);
355                         break;
356                 }
357                 break;
358         case WGET_TRANSFERRED:
359                 printf("Packets received %d, Transfer Successful\n", packets);
360                 net_set_state(wget_loop_state);
361                 break;
362         }
363 }
364
365 #define RANDOM_PORT_START 1024
366 #define RANDOM_PORT_RANGE 0x4000
367
368 /**
369  * random_port() - make port a little random (1024-17407)
370  *
371  * Return: random port number from 1024 to 17407
372  *
373  * This keeps the math somewhat trivial to compute, and seems to work with
374  * all supported protocols/clients/servers
375  */
376 static unsigned int random_port(void)
377 {
378         return RANDOM_PORT_START + (get_timer(0) % RANDOM_PORT_RANGE);
379 }
380
381 #define BLOCKSIZE 512
382
383 void wget_start(void)
384 {
385         image_url = strchr(net_boot_file_name, ':');
386         if (image_url > 0) {
387                 web_server_ip = string_to_ip(net_boot_file_name);
388                 ++image_url;
389                 net_server_ip = web_server_ip;
390         } else {
391                 web_server_ip = net_server_ip;
392                 image_url = net_boot_file_name;
393         }
394
395         debug_cond(DEBUG_WGET,
396                    "wget: Transfer HTTP Server %pI4; our IP %pI4\n",
397                    &web_server_ip, &net_ip);
398
399         /* Check if we need to send across this subnet */
400         if (net_gateway.s_addr && net_netmask.s_addr) {
401                 struct in_addr our_net;
402                 struct in_addr server_net;
403
404                 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
405                 server_net.s_addr = net_server_ip.s_addr & net_netmask.s_addr;
406                 if (our_net.s_addr != server_net.s_addr)
407                         debug_cond(DEBUG_WGET,
408                                    "wget: sending through gateway %pI4",
409                                    &net_gateway);
410         }
411         debug_cond(DEBUG_WGET, "URL '%s'\n", image_url);
412
413         if (net_boot_file_expected_size_in_blocks) {
414                 debug_cond(DEBUG_WGET, "wget: Size is 0x%x Bytes = ",
415                            net_boot_file_expected_size_in_blocks * BLOCKSIZE);
416                 print_size(net_boot_file_expected_size_in_blocks * BLOCKSIZE,
417                            "");
418         }
419         debug_cond(DEBUG_WGET,
420                    "\nwget:Load address: 0x%lx\nLoading: *\b", image_load_addr);
421
422         net_set_timeout_handler(wget_timeout, wget_timeout_handler);
423         tcp_set_tcp_handler(wget_handler);
424
425         wget_timeout_count = 0;
426         current_wget_state = WGET_CLOSED;
427
428         our_port = random_port();
429
430         /*
431          * Zero out server ether to force arp resolution in case
432          * the server ip for the previous u-boot command, for example dns
433          * is not the same as the web server ip.
434          */
435
436         memset(net_server_ethaddr, 0, 6);
437
438         wget_send(TCP_SYN, 0, 0, 0);
439 }