fastboot_udp.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288
  1. // SPDX-License-Identifier: BSD-2-Clause
  2. /*
  3. * Copyright (C) 2016 The Android Open Source Project
  4. */
  5. #include <common.h>
  6. #include <command.h>
  7. #include <fastboot.h>
  8. #include <net.h>
  9. #include <net/fastboot_udp.h>
  10. enum {
  11. FASTBOOT_ERROR = 0,
  12. FASTBOOT_QUERY = 1,
  13. FASTBOOT_INIT = 2,
  14. FASTBOOT_FASTBOOT = 3,
  15. };
  16. struct __packed fastboot_header {
  17. uchar id;
  18. uchar flags;
  19. unsigned short seq;
  20. };
  21. #define PACKET_SIZE 1024
  22. #define DATA_SIZE (PACKET_SIZE - sizeof(struct fastboot_header))
  23. /* Sequence number sent for every packet */
  24. static unsigned short sequence_number = 1;
  25. static const unsigned short packet_size = PACKET_SIZE;
  26. static const unsigned short udp_version = 1;
  27. /* Keep track of last packet for resubmission */
  28. static uchar last_packet[PACKET_SIZE];
  29. static unsigned int last_packet_len;
  30. static struct in_addr fastboot_remote_ip;
  31. /* The UDP port at their end */
  32. static int fastboot_remote_port;
  33. /* The UDP port at our end */
  34. static int fastboot_our_port;
  35. /**
  36. * fastboot_udp_send_info() - Send an INFO packet during long commands.
  37. *
  38. * @msg: String describing the reason for waiting
  39. */
  40. static void fastboot_udp_send_info(const char *msg)
  41. {
  42. uchar *packet;
  43. uchar *packet_base;
  44. int len = 0;
  45. char response[FASTBOOT_RESPONSE_LEN] = {0};
  46. struct fastboot_header response_header = {
  47. .id = FASTBOOT_FASTBOOT,
  48. .flags = 0,
  49. .seq = htons(sequence_number)
  50. };
  51. ++sequence_number;
  52. packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
  53. packet_base = packet;
  54. /* Write headers */
  55. memcpy(packet, &response_header, sizeof(response_header));
  56. packet += sizeof(response_header);
  57. /* Write response */
  58. fastboot_response("INFO", response, "%s", msg);
  59. memcpy(packet, response, strlen(response));
  60. packet += strlen(response);
  61. len = packet - packet_base;
  62. /* Save packet for retransmitting */
  63. last_packet_len = len;
  64. memcpy(last_packet, packet_base, last_packet_len);
  65. net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
  66. fastboot_remote_port, fastboot_our_port, len);
  67. }
  68. /**
  69. * fastboot_timed_send_info() - Send INFO packet every 30 seconds
  70. *
  71. * @msg: String describing the reason for waiting
  72. *
  73. * Send an INFO packet during long commands based on timer. An INFO packet
  74. * is sent if the time is 30 seconds after start. Else, noop.
  75. */
  76. static void fastboot_timed_send_info(const char *msg)
  77. {
  78. static ulong start;
  79. /* Initialize timer */
  80. if (start == 0)
  81. start = get_timer(0);
  82. ulong time = get_timer(start);
  83. /* Send INFO packet to host every 30 seconds */
  84. if (time >= 30000) {
  85. start = get_timer(0);
  86. fastboot_udp_send_info(msg);
  87. }
  88. }
  89. /**
  90. * fastboot_send() - Sends a packet in response to received fastboot packet
  91. *
  92. * @header: Header for response packet
  93. * @fastboot_data: Pointer to received fastboot data
  94. * @fastboot_data_len: Length of received fastboot data
  95. * @retransmit: Nonzero if sending last sent packet
  96. */
  97. static void fastboot_send(struct fastboot_header header, char *fastboot_data,
  98. unsigned int fastboot_data_len, uchar retransmit)
  99. {
  100. uchar *packet;
  101. uchar *packet_base;
  102. int len = 0;
  103. const char *error_msg = "An error occurred.";
  104. short tmp;
  105. struct fastboot_header response_header = header;
  106. static char command[FASTBOOT_COMMAND_LEN];
  107. static int cmd = -1;
  108. static bool pending_command;
  109. char response[FASTBOOT_RESPONSE_LEN] = {0};
  110. /*
  111. * We will always be sending some sort of packet, so
  112. * cobble together the packet headers now.
  113. */
  114. packet = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
  115. packet_base = packet;
  116. /* Resend last packet */
  117. if (retransmit) {
  118. memcpy(packet, last_packet, last_packet_len);
  119. net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
  120. fastboot_remote_port, fastboot_our_port,
  121. last_packet_len);
  122. return;
  123. }
  124. response_header.seq = htons(response_header.seq);
  125. memcpy(packet, &response_header, sizeof(response_header));
  126. packet += sizeof(response_header);
  127. switch (header.id) {
  128. case FASTBOOT_QUERY:
  129. tmp = htons(sequence_number);
  130. memcpy(packet, &tmp, sizeof(tmp));
  131. packet += sizeof(tmp);
  132. break;
  133. case FASTBOOT_INIT:
  134. tmp = htons(udp_version);
  135. memcpy(packet, &tmp, sizeof(tmp));
  136. packet += sizeof(tmp);
  137. tmp = htons(packet_size);
  138. memcpy(packet, &tmp, sizeof(tmp));
  139. packet += sizeof(tmp);
  140. break;
  141. case FASTBOOT_ERROR:
  142. memcpy(packet, error_msg, strlen(error_msg));
  143. packet += strlen(error_msg);
  144. break;
  145. case FASTBOOT_FASTBOOT:
  146. if (cmd == FASTBOOT_COMMAND_DOWNLOAD) {
  147. if (!fastboot_data_len && !fastboot_data_remaining()) {
  148. fastboot_data_complete(response);
  149. } else {
  150. fastboot_data_download(fastboot_data,
  151. fastboot_data_len,
  152. response);
  153. }
  154. } else if (!pending_command) {
  155. strlcpy(command, fastboot_data,
  156. min((size_t)fastboot_data_len + 1,
  157. sizeof(command)));
  158. pending_command = true;
  159. } else {
  160. cmd = fastboot_handle_command(command, response);
  161. pending_command = false;
  162. }
  163. /*
  164. * Sent some INFO packets, need to update sequence number in
  165. * header
  166. */
  167. if (header.seq != sequence_number) {
  168. response_header.seq = htons(sequence_number);
  169. memcpy(packet_base, &response_header,
  170. sizeof(response_header));
  171. }
  172. /* Write response to packet */
  173. memcpy(packet, response, strlen(response));
  174. packet += strlen(response);
  175. break;
  176. default:
  177. pr_err("ID %d not implemented.\n", header.id);
  178. return;
  179. }
  180. len = packet - packet_base;
  181. /* Save packet for retransmitting */
  182. last_packet_len = len;
  183. memcpy(last_packet, packet_base, last_packet_len);
  184. net_send_udp_packet(net_server_ethaddr, fastboot_remote_ip,
  185. fastboot_remote_port, fastboot_our_port, len);
  186. fastboot_handle_boot(cmd, strncmp("OKAY", response, 4) == 0);
  187. if (!strncmp("OKAY", response, 4) || !strncmp("FAIL", response, 4))
  188. cmd = -1;
  189. }
  190. /**
  191. * fastboot_handler() - Incoming UDP packet handler.
  192. *
  193. * @packet: Pointer to incoming UDP packet
  194. * @dport: Destination UDP port
  195. * @sip: Source IP address
  196. * @sport: Source UDP port
  197. * @len: Packet length
  198. */
  199. static void fastboot_handler(uchar *packet, unsigned int dport,
  200. struct in_addr sip, unsigned int sport,
  201. unsigned int len)
  202. {
  203. struct fastboot_header header;
  204. char fastboot_data[DATA_SIZE] = {0};
  205. unsigned int fastboot_data_len = 0;
  206. if (dport != fastboot_our_port)
  207. return;
  208. fastboot_remote_ip = sip;
  209. fastboot_remote_port = sport;
  210. if (len < sizeof(struct fastboot_header) || len > PACKET_SIZE)
  211. return;
  212. memcpy(&header, packet, sizeof(header));
  213. header.flags = 0;
  214. header.seq = ntohs(header.seq);
  215. packet += sizeof(header);
  216. len -= sizeof(header);
  217. switch (header.id) {
  218. case FASTBOOT_QUERY:
  219. fastboot_send(header, fastboot_data, 0, 0);
  220. break;
  221. case FASTBOOT_INIT:
  222. case FASTBOOT_FASTBOOT:
  223. fastboot_data_len = len;
  224. if (len > 0)
  225. memcpy(fastboot_data, packet, len);
  226. if (header.seq == sequence_number) {
  227. fastboot_send(header, fastboot_data,
  228. fastboot_data_len, 0);
  229. sequence_number++;
  230. } else if (header.seq == sequence_number - 1) {
  231. /* Retransmit last sent packet */
  232. fastboot_send(header, fastboot_data,
  233. fastboot_data_len, 1);
  234. }
  235. break;
  236. default:
  237. pr_err("ID %d not implemented.\n", header.id);
  238. header.id = FASTBOOT_ERROR;
  239. fastboot_send(header, fastboot_data, 0, 0);
  240. break;
  241. }
  242. }
  243. void fastboot_udp_start_server(void)
  244. {
  245. printf("Using %s device\n", eth_get_name());
  246. printf("Listening for fastboot command on %pI4\n", &net_ip);
  247. fastboot_our_port = CONFIG_UDP_FUNCTION_FASTBOOT_PORT;
  248. if (IS_ENABLED(CONFIG_FASTBOOT_FLASH))
  249. fastboot_set_progress_callback(fastboot_timed_send_info);
  250. net_set_udp_handler(fastboot_handler);
  251. /* zero out server ether in case the server ip has changed */
  252. memset(net_server_ethaddr, 0, 6);
  253. }