flash.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793
  1. /*
  2. * Copyright (C) 2019-2020 Alibaba Group Holding Limited
  3. */
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <stdio.h>
  7. #include <unistd.h>
  8. #include <sys/types.h>
  9. #include <sys/stat.h>
  10. #include <sys/ioctl.h>
  11. #include <sys/statvfs.h>
  12. #include <linux/fs.h>
  13. #include <fcntl.h>
  14. #include <errno.h>
  15. #include <aos/kernel.h>
  16. #include <aos/kv.h>
  17. #include <yoc/netio.h>
  18. #include <yoc/fota.h>
  19. #include <ulog/ulog.h>
  20. #include <mtd/ubi-user.h>
  21. #include <mtd/mtd-user.h>
  22. #include "imagef.h"
  23. #define TAG "fota"
  24. struct partition_info_t {
  25. char img_name[IMG_NAME_MAX_LEN];
  26. char char_name[DEV_NAME_MAX_LEN + 4]; // for uboot name(/dev/mmcblk0boot0) length + 4
  27. char dev_name[DEV_NAME_MAX_LEN + 4];
  28. size_t size;
  29. int ab;
  30. };
  31. static struct partition_info_t g_partition_info_ubi[] = {
  32. {IMG_NAME_UBOOT, "/dev/mtd1", "/dev/mtdblock1", ( 4 * 1024 * 1024), 1},
  33. {IMG_NAME_KERNEL, "", "/dev/ubi0_5", (10 * 1024 * 1024), 1},
  34. {IMG_NAME_KERNEL, "", "/dev/ubi0_6", (10 * 1024 * 1024), 2},
  35. {IMG_NAME_ROOTFS, "", "/dev/ubi0_7", (60 * 1024 * 1024), 1},
  36. {IMG_NAME_ROOTFS, "", "/dev/ubi0_8", (60 * 1024 * 1024), 2},
  37. {"", "", "", 0, 0},
  38. };
  39. static struct partition_info_t g_partition_info_ext4_uboot[] = {
  40. {IMG_NAME_UBOOT, "/dev/mmcblk0boot0", "/dev/mmcblk0boot0", ( 4 * 1024 * 1024), 1},
  41. };
  42. static struct partition_info_t *g_partition_info;
  43. // data: if return 0, need free *data
  44. static int get_emmc_valid_partition_info(struct partition_info_t **data)
  45. {
  46. FILE *fp;
  47. char buf[60];
  48. char part_name[10];
  49. char *p;
  50. struct partition_info_t *out_data;
  51. int all;
  52. int nums;
  53. int i;
  54. int len;
  55. int cnt;
  56. int tmp;
  57. int tmp2;
  58. fp = popen("cd /sys/block/mmcblk0/ && ls mmcblk0p*/uevent", "r");
  59. if (fp == NULL) {
  60. LOGE(TAG, "popen error.");
  61. return -1;
  62. }
  63. all = 0;
  64. while (fgets(buf, sizeof(buf), fp)) {
  65. all++;
  66. }
  67. pclose(fp);
  68. for (i = 0, nums = 0; i < all; i++) {
  69. snprintf(buf, sizeof(buf), "/sys/block/mmcblk0/mmcblk0p%d/uevent", i + 1);
  70. fp = fopen(buf, "r");
  71. if (fp == NULL) {
  72. LOGE(TAG, "popen %s error.", buf);
  73. return -1;
  74. }
  75. while (fgets(buf, sizeof(buf), fp)) {
  76. p = strstr(buf, "PARTNAME=");
  77. if (p) {
  78. if (sscanf(p, "PARTNAME=%[^\n]", part_name) == 1) {
  79. len = strlen(part_name);
  80. if (len <= 0) {
  81. LOGE(TAG, "part_name analysis error:%s", p);
  82. pclose(fp);
  83. return -1;
  84. }
  85. if (part_name[len - 1] == 'B') {
  86. part_name[len - 1] = 0;
  87. }
  88. if (check_partition_exists(part_name)) {
  89. nums++;
  90. }
  91. break;
  92. }
  93. }
  94. }
  95. pclose(fp);
  96. }
  97. if (nums == 0) {
  98. LOGE(TAG, "get part error.");
  99. return -1;
  100. }
  101. tmp2 = sizeof(g_partition_info_ext4_uboot) / sizeof(g_partition_info_ext4_uboot[0]);
  102. out_data = aos_malloc(sizeof(struct partition_info_t) * (nums + tmp2 + 1));
  103. if (out_data == NULL) {
  104. LOGE(TAG, "struct partition_info_t aos_malloc error.");
  105. return -1;
  106. }
  107. memcpy(out_data, g_partition_info_ext4_uboot, sizeof(*out_data) * tmp2);
  108. for (i = 0, cnt = 0; i < all; i++) {
  109. snprintf(buf, sizeof(buf), "/sys/block/mmcblk0/mmcblk0p%d/uevent", i + 1);
  110. fp = fopen(buf, "r");
  111. if (fp == NULL) {
  112. LOGE(TAG, "popen %s error.", buf);
  113. goto err;
  114. }
  115. while (fgets(buf, sizeof(buf), fp)) {
  116. p = strstr(buf, "PARTNAME=");
  117. if (p) {
  118. if (sscanf(p, "PARTNAME=%[^\n]", part_name) == 1) {
  119. len = strlen(part_name);
  120. if (len <= 0) {
  121. LOGE(TAG, "part_name analysis error:%s", p);
  122. pclose(fp);
  123. goto err;
  124. }
  125. if (part_name[len - 1] == 'B') {
  126. part_name[len - 1] = 0;
  127. tmp = 2;
  128. } else {
  129. tmp = 1;
  130. }
  131. if (check_partition_exists(part_name)) {
  132. snprintf(out_data[cnt + tmp2].img_name, sizeof(out_data[0].img_name), "%s", read_partition_img_name(part_name));
  133. snprintf(out_data[cnt + tmp2].dev_name, sizeof(out_data[0].dev_name), "/dev/mmcblk0p%d", i + 1);
  134. out_data[cnt + tmp2].ab = tmp;
  135. out_data[cnt + tmp2].size = 1;
  136. cnt++;
  137. }
  138. break;
  139. }
  140. }
  141. }
  142. pclose(fp);
  143. }
  144. if (cnt != nums) {
  145. LOGE(TAG, "get part error.");
  146. goto err;
  147. }
  148. out_data[cnt + tmp2].size = 0;
  149. *data = out_data;
  150. return 0;
  151. err:
  152. aos_free(out_data);
  153. return -1;
  154. }
  155. static int get_partition_info(const char *img_name, size_t img_size, size_t *out_size,
  156. unsigned long *fp, int *fd, char *out_dev_name, char *out_img_path)
  157. {
  158. int i;
  159. int rootfsab, kernelab;
  160. int is_uboot;
  161. *out_size = 0;
  162. *fd = -1;
  163. *fp = 0;
  164. is_uboot = 0;
  165. if (strcmp(img_name, IMG_NAME_UBOOT) == 0) {
  166. is_uboot = 1;
  167. }
  168. kernelab = check_kernel_partition();
  169. if (kernelab == 1) {
  170. kernelab = 2;
  171. } else {
  172. kernelab = 1;
  173. }
  174. rootfsab = check_rootfs_partition();
  175. if (rootfsab == 1) {
  176. rootfsab = 2;
  177. } else {
  178. rootfsab = 1;
  179. }
  180. LOGD(TAG, "kernelab:%d, rootfsab:%d", kernelab, rootfsab);
  181. i = 0;
  182. while(1) {
  183. if (strcmp(img_name, IMG_NAME_DIFF) == 0) {
  184. int ffd;
  185. struct statvfs vfs;
  186. if (statvfs("/", &vfs) < 0) {
  187. return -1;
  188. }
  189. *out_size = vfs.f_bavail * vfs.f_bsize;
  190. if (img_size >= *out_size) {
  191. LOGE(TAG, "the package[%d] is larger than disk space[%d].", img_size, *out_size);
  192. return -1;
  193. }
  194. ffd = open("/"IMG_NAME_DIFF, O_CREAT | O_RDWR | O_SYNC, 0666);
  195. if (ffd < 0) {
  196. LOGE(TAG, "open diff temp file failed.");
  197. return -1;
  198. }
  199. *fd = ffd;
  200. return 0;
  201. }
  202. if (g_partition_info[i].size == 0) {
  203. break;
  204. }
  205. if (strcmp(img_name, g_partition_info[i].img_name) == 0) {
  206. if (is_uboot == 1) {
  207. LOGD(TAG, "got uboot devname: %s", g_partition_info[i].dev_name);
  208. char *namepath = strdup_img_path(img_name);
  209. if (namepath == NULL) {
  210. return -ENOMEM;
  211. }
  212. strncpy(out_img_path, namepath, IMG_PATH_MAX_LEN);
  213. out_img_path[IMG_PATH_MAX_LEN - 1] = 0;
  214. int ffd;
  215. ffd = open(namepath, O_CREAT | O_RDWR | O_SYNC, 0666);
  216. aos_free(namepath);
  217. if (ffd < 0) {
  218. LOGE(TAG, "open uboot temp file failed.");
  219. return -1;
  220. }
  221. *fd = ffd;
  222. LOGD(TAG, "@@@[%d].*fp:0x%08x", i, *fp);
  223. memcpy(out_dev_name, g_partition_info[i].dev_name, sizeof(g_partition_info[i].dev_name));
  224. // Open and size the device
  225. size_t memsize;
  226. if (FILE_SYSTEM_IS_UBI()) {
  227. mtd_info_t meminfo;
  228. if ((ffd = open(g_partition_info[i].char_name, O_RDONLY)) < 0) {
  229. LOGE(TAG, "Open device %s failed.", g_partition_info[i].char_name);
  230. return -1;
  231. }
  232. if (ioctl(ffd, MEMGETINFO, &meminfo) != 0) {
  233. LOGE(TAG, "ioctl(MEMGETINFO) error,[fd:%d][errno:%d]", ffd, errno);
  234. close(ffd);
  235. return -1;
  236. }
  237. close(ffd);
  238. memsize = meminfo.size;
  239. }
  240. if (FILE_SYSTEM_IS_EXT4()) {
  241. if ((ffd = open(g_partition_info[i].char_name, O_RDONLY)) < 0) {
  242. LOGE(TAG, "Open device %s failed.", g_partition_info[i].char_name);
  243. return -1;
  244. }
  245. if (ioctl(ffd, BLKGETSIZE64, &memsize) != 0) {
  246. LOGE(TAG, "ioctl(BLKGETSIZE64) error,[fd:%d][errno:%d]", ffd, errno);
  247. close(ffd);
  248. return -1;
  249. }
  250. close(ffd);
  251. }
  252. g_partition_info[i].size = memsize;
  253. *out_size = g_partition_info[i].size;
  254. LOGD(TAG, "partition size:%d", *out_size);
  255. return 0;
  256. } else {
  257. int ret;
  258. long long image_size = img_size;
  259. if ((strcmp(img_name, IMG_NAME_KERNEL) == 0 && g_partition_info[i].ab == kernelab)
  260. || (strcmp(img_name, IMG_NAME_ROOTFS) == 0 && g_partition_info[i].ab == rootfsab)
  261. || (strcmp(img_name, g_partition_info[i].img_name) == 0 && g_partition_info[i].ab == check_partition_ab(img_name))) {
  262. LOGD(TAG, "got devname: %s", g_partition_info[i].dev_name);
  263. LOGD(TAG, "img_size: %d", img_size);
  264. int ffd = open(g_partition_info[i].dev_name, O_RDWR | O_SYNC);
  265. if (ffd < 0) {
  266. LOGE(TAG, "open image: %s, [%s]file failed.[errno:%d]", img_name, g_partition_info[i].dev_name, errno);
  267. return -1;
  268. }
  269. size_t bytes;
  270. if (FILE_SYSTEM_IS_UBI()) {
  271. long long bytes2;
  272. extern int get_ubi_info(const char *ubi_name, long long *bytes2);
  273. if (get_ubi_info(g_partition_info[i].dev_name, &bytes2)) {
  274. LOGE(TAG, "get %s length error.", g_partition_info[i].dev_name);
  275. close(ffd);
  276. return -1;
  277. }
  278. bytes = bytes2;
  279. }
  280. if (FILE_SYSTEM_IS_EXT4()) {
  281. if (ioctl(ffd, BLKGETSIZE64, &bytes) != 0) {
  282. LOGE(TAG, "ioctl(BLKGETSIZE64) error,[fd:%d][errno:%d]", ffd, errno);
  283. close(ffd);
  284. return -1;
  285. }
  286. }
  287. g_partition_info[i].size = (int)bytes;
  288. LOGD(TAG, "the %s bytes:%d", g_partition_info[i].dev_name, bytes);
  289. if (image_size > bytes) {
  290. LOGE(TAG, "the image_size[%d] is larger than partition_size[%d].", image_size, bytes);
  291. close(ffd);
  292. return -1;
  293. }
  294. if (FILE_SYSTEM_IS_UBI()) {
  295. ret = ioctl(ffd, UBI_IOCVOLUP, &image_size);
  296. if (ret < 0) {
  297. LOGE(TAG, "UBI_IOCVOLUP failed, ffd:%d,[%s][ret:%d][errno:%d].", ffd, g_partition_info[i].dev_name, ret, errno);
  298. close(ffd);
  299. return -1;
  300. }
  301. }
  302. *fd = ffd;
  303. LOGD(TAG, "###[%d].*fd:%d, img_size:%d, image_size:%d", i, *fd, img_size, image_size);
  304. *out_size = g_partition_info[i].size;
  305. memcpy(out_dev_name, g_partition_info[i].dev_name, sizeof(g_partition_info[i].dev_name));
  306. LOGD(TAG, "partition size:%d", *out_size);
  307. return 0;
  308. }
  309. }
  310. }
  311. i++;
  312. }
  313. return -1;
  314. }
  315. static int set_img_info(netio_t *io, uint8_t *buffer)
  316. {
  317. download_img_info_t *priv = (download_img_info_t *)io->private;
  318. pack_header_v2_t *header = (pack_header_v2_t *)buffer;
  319. pack_header_imginfo_v2_t *imginfo = header->image_info;
  320. LOGD(TAG, "come to set image info.");
  321. if (header->magic != PACK_HEAD_MAGIC) {
  322. LOGE(TAG, "the image header is wrong.");
  323. return -1;
  324. }
  325. if (header->image_count > IMG_MAX_COUNT) {
  326. LOGE(TAG, "the image count is overflow.");
  327. return -1;
  328. }
  329. priv->image_count = header->image_count;
  330. priv->head_size = header->head_size;
  331. priv->digest_type = header->digest_type;
  332. priv->signature_type = header->signature_type;
  333. memcpy(priv->md5sum, header->md5sum, sizeof(priv->md5sum));
  334. memcpy(priv->signature, header->signature, sizeof(priv->signature));
  335. LOGD(TAG, "image count is :%d", header->image_count);
  336. for (int i = 0; i < header->image_count; i++) {
  337. LOGD(TAG, "-------> %s", imginfo->img_name);
  338. LOGD(TAG, "offset:%d", imginfo->offset);
  339. LOGD(TAG, "size:%d", imginfo->size);
  340. memcpy(priv->img_info[i].img_name, imginfo->img_name, IMG_NAME_MAX_LEN);
  341. priv->img_info[i].img_offset = imginfo->offset;
  342. priv->img_info[i].img_size = imginfo->size;
  343. priv->img_info[i].fp = NULL;
  344. priv->img_info[i].fd = -1;
  345. unsigned long ffp;
  346. int ret = get_partition_info(priv->img_info[i].img_name, priv->img_info[i].img_size,
  347. &priv->img_info[i].partition_size, &ffp, &priv->img_info[i].fd,
  348. priv->img_info[i].dev_name, priv->img_info[i].img_path);
  349. if (ret < 0) {
  350. LOGE(TAG, "get partition info error.");
  351. return -1;
  352. }
  353. priv->img_info[i].fp = (FILE *)ffp;
  354. LOGD(TAG, "@@@priv->img_info[%d].fp:0x%08x, fd:%d", i, priv->img_info[i].fp, priv->img_info[i].fd);
  355. imginfo++;
  356. }
  357. return 0;
  358. }
  359. static int get_img_index(netio_t *io, size_t cur_offset)
  360. {
  361. int i;
  362. size_t offsets[IMG_MAX_COUNT + 1];
  363. download_img_info_t *priv = (download_img_info_t *)io->private;
  364. LOGD(TAG, "%s, cur_offset: %d", __func__, cur_offset);
  365. if (cur_offset == 0) {
  366. return 0;
  367. }
  368. for (i = 0; i < IMG_MAX_COUNT + 1; i++) {
  369. offsets[i] = ~0;
  370. }
  371. for (i = 0; i < priv->image_count; i++) {
  372. offsets[i] = priv->img_info[i].img_offset;
  373. LOGD(TAG, "offsets[%d]: %d", i, offsets[i]);
  374. }
  375. for (i = 0; i < priv->image_count; i++) {
  376. LOGD(TAG, "offsets[%d]: %d, offsets[%d]: %d", i, offsets[i], i+1, offsets[i+1]);
  377. if(cur_offset >= offsets[i] && cur_offset < offsets[i+1]) {
  378. LOGD(TAG, "Range Num: %d", i);
  379. return i;
  380. }
  381. }
  382. LOGE(TAG, "get img index error.");
  383. return -1;
  384. }
  385. static size_t get_img_length(netio_t *io)
  386. {
  387. int i;
  388. size_t length;
  389. download_img_info_t *priv = (download_img_info_t *)io->private;
  390. for (i = 0, length = priv->head_size; i < priv->image_count; i++) {
  391. length += priv->img_info[i].img_size;
  392. }
  393. return length;
  394. }
  395. static int flash_open(netio_t *io, const char *path)
  396. {
  397. io->block_size = CONFIG_FOTA_BUFFER_SIZE;
  398. io->private = aos_zalloc(sizeof(download_img_info_t));
  399. if (io->private == NULL) {
  400. return -ENOMEM;
  401. }
  402. if (FILE_SYSTEM_IS_EXT4()) {
  403. if (get_emmc_valid_partition_info(&g_partition_info) < 0) {
  404. aos_free(io->private);
  405. return -1;
  406. }
  407. } else if (FILE_SYSTEM_IS_UBI()) {
  408. g_partition_info = g_partition_info_ubi;
  409. } else {
  410. aos_free(io->private);
  411. return -1;
  412. }
  413. return 0;
  414. }
  415. static int flash_close(netio_t *io)
  416. {
  417. int i;
  418. int ret = 0;
  419. size_t total_size;
  420. download_img_info_t *priv = (download_img_info_t *)io->private;
  421. if (FILE_SYSTEM_IS_EXT4()) {
  422. aos_free(g_partition_info);
  423. }
  424. // save to file first
  425. FILE *fp = fopen(IMGINFOFILE, "wb+");
  426. if (!fp) {
  427. LOGE(TAG, "open %s file failed.", IMGINFOFILE);
  428. ret = -1;
  429. goto out;
  430. }
  431. if (fwrite(priv, 1, sizeof(download_img_info_t), fp) < 0) {
  432. ret = -1;
  433. goto out;
  434. }
  435. fsync(fileno(fp));
  436. total_size = priv->head_size;
  437. for (i = 0; i < priv->image_count; i++) {
  438. total_size += priv->img_info[i].img_size;
  439. }
  440. LOGD(TAG, "flash close, total_size:%d, io->offset:%d", total_size, io->offset);
  441. if (io->offset == total_size && io->offset != 0) {
  442. LOGD(TAG, "come to close file");
  443. for (i = 0; i < priv->image_count; i++) {
  444. if (priv->img_info[i].fp) {
  445. fclose(priv->img_info[i].fp);
  446. LOGD(TAG, "close 0x%08x", priv->img_info[i].fp);
  447. }
  448. if (priv->img_info[i].fd > 0) {
  449. close(priv->img_info[i].fd);
  450. LOGD(TAG, "close %d", priv->img_info[i].fd);
  451. }
  452. }
  453. } else {
  454. for (i = 0; i < priv->image_count; i++) {
  455. if (priv->img_info[i].fp) {
  456. LOGD(TAG, "no need to close 0x%08x", priv->img_info[i].fp);
  457. }
  458. if (priv->img_info[i].fd > 0) {
  459. LOGD(TAG, "no need to close %d", priv->img_info[i].fd);
  460. }
  461. }
  462. }
  463. out:
  464. if (fp) fclose(fp);
  465. if (io->private) {
  466. aos_free(io->private);
  467. io->private = NULL;
  468. }
  469. return ret;
  470. }
  471. static int flash_read(netio_t *io, uint8_t *buffer, int length, int timeoutms)
  472. {
  473. return 0;
  474. }
  475. static int _file_write(netio_t *io, int idx, uint8_t *buffer, int length)
  476. {
  477. int ret = -1;
  478. FILE *fp;
  479. int fd;
  480. download_img_info_t *priv = (download_img_info_t *)io->private;
  481. fp = priv->img_info[idx].fp;
  482. fd = priv->img_info[idx].fd;
  483. LOGD(TAG, "_file write fp: 0x%08x, fd: %d", fp, fd);
  484. if (fp) {
  485. ret = fwrite(buffer, sizeof(uint8_t), length, fp);
  486. }
  487. if (fd >= 0) {
  488. ret = write(fd, buffer, length);
  489. }
  490. if (ret < 0) {
  491. LOGE(TAG, "[%s, %d]write %d bytes failed, [fp:0x%08x, fd:%d], ret:%d, errno:%d",
  492. __func__, __LINE__, length, fp, fd, ret, errno);
  493. return -1;
  494. }
  495. if (fp) {
  496. fflush(fp);
  497. fsync(fileno(fp));
  498. }
  499. if (fd >= 0) {
  500. fsync(fd);
  501. }
  502. return ret;
  503. }
  504. static int download_img_info_init(netio_t *io, uint8_t *buffer, int length, int buffer_save)
  505. {
  506. int headsize = 0;
  507. pack_header_v2_t *header;
  508. header = (pack_header_v2_t *)buffer;
  509. download_img_info_t *priv = (download_img_info_t *)io->private;
  510. if (length < sizeof(pack_header_v2_t)) {
  511. LOGE(TAG, "the first size %d is less than %d", length, sizeof(pack_header_v2_t));
  512. return -1;
  513. }
  514. if (buffer_save) {
  515. FILE *headerfp = fopen(IMGHEADERPATH, "wb+");
  516. if (!headerfp) {
  517. LOGE(TAG, "create %s file failed.", IMGHEADERPATH);
  518. return -1;
  519. }
  520. if (fwrite(buffer, 1, sizeof(pack_header_v2_t), headerfp) < 0) {
  521. LOGE(TAG, "write %s failed.", IMGHEADERPATH);
  522. fclose(headerfp);
  523. return -1;
  524. }
  525. fsync(fileno(headerfp));
  526. fclose(headerfp);
  527. }
  528. LOGD(TAG, "head_version:%d, head_size:%d, checksum:0x%08x, count:%d, digest:%d, signature:%d",
  529. header->head_version, header->head_size, header->head_checksum, header->image_count,
  530. header->digest_type, header->signature_type);
  531. headsize = header->head_size;
  532. uint8_t *tempbuf = aos_zalloc(headsize);
  533. if (!tempbuf) {
  534. return -ENOMEM;
  535. }
  536. memcpy(tempbuf, buffer, headsize);
  537. ((pack_header_v2_t *)tempbuf)->head_checksum = 0;
  538. memset(((pack_header_v2_t *)tempbuf)->signature, 0, sizeof(((pack_header_v2_t *)tempbuf)->signature));
  539. uint32_t cksum = get_checksum((uint8_t *)tempbuf, headsize);
  540. aos_free(tempbuf);
  541. if (cksum != header->head_checksum) {
  542. LOGE(TAG, "the header checksum error.[0x%08x, 0x%08x]", header->head_checksum, cksum);
  543. return -1;
  544. }
  545. FILE *imginfofp = fopen(IMGINFOFILE, "wb+");
  546. if (!imginfofp) {
  547. LOGE(TAG, "create %s file failed.", IMGINFOFILE);
  548. return -1;
  549. }
  550. if (set_img_info(io, buffer) < 0) {
  551. LOGE(TAG, "set imageinfo failed.");
  552. return -1;
  553. }
  554. if (fwrite(priv, 1, sizeof(download_img_info_t), imginfofp) < 0) {
  555. LOGE(TAG, "write %s file failed.", IMGINFOFILE);
  556. fclose(imginfofp);
  557. return -1;
  558. }
  559. fsync(fileno(imginfofp));
  560. fclose(imginfofp);
  561. return 0;
  562. }
  563. static int download_img_info_init_from_file(netio_t *io)
  564. {
  565. int ret;
  566. int fd;
  567. uint8_t *buffer;
  568. uint64_t length;
  569. fd = open(IMGHEADERPATH, O_RDONLY);
  570. if (fd < 0) {
  571. return -1;
  572. }
  573. buffer = NULL;
  574. length = lseek(fd, 0, SEEK_END);
  575. if (length <= 0) {
  576. ret = -1;
  577. goto out;
  578. }
  579. buffer = aos_zalloc(sizeof(download_img_info_t));
  580. if (buffer == NULL) {
  581. ret = -ENOMEM;
  582. goto out;
  583. }
  584. lseek(fd, 0, SEEK_SET);
  585. if (read(fd, buffer, length) != length) {
  586. ret = -1;
  587. goto out;
  588. }
  589. close(fd);
  590. fd = -1;
  591. ret = download_img_info_init(io, buffer, length, 0);
  592. if (ret < 0) {
  593. ret = -1;
  594. goto out;
  595. }
  596. ret = 0;
  597. out:
  598. if (fd >= 0) {
  599. close(fd);
  600. }
  601. if (buffer) {
  602. aos_free(buffer);
  603. }
  604. return ret;
  605. }
  606. static int flash_write(netio_t *io, uint8_t *buffer, int length, int timeoutms)
  607. {
  608. int headsize = 0;
  609. pack_header_v2_t *header;
  610. download_img_info_t *priv = (download_img_info_t *)io->private;
  611. header = (pack_header_v2_t *)buffer;
  612. LOGD(TAG, "flash write, total: %d offset: %d len: %d", io->size, io->offset, length);
  613. if (io->offset == 0) {
  614. if (header->magic == PACK_HEAD_MAGIC) {
  615. LOGD(TAG, "i am the pack image.");
  616. int ret = download_img_info_init(io, buffer, length, 1);
  617. if (ret < 0) {
  618. return ret;
  619. }
  620. headsize = header->head_size;
  621. LOGD(TAG, "parse packed image ok.");
  622. } else {
  623. LOGE(TAG, "the image is not a pack image.");
  624. return -1;
  625. }
  626. }
  627. int idx = get_img_index(io, io->offset);
  628. if (idx < 0) {
  629. LOGE(TAG, "flash write error.");
  630. return -1;
  631. }
  632. LOGD(TAG, "idx:%d, priv->img_info[%d].img_offset:%d", idx, idx, priv->img_info[idx].img_offset);
  633. if (priv->img_info[idx].partition_size - (io->offset - priv->img_info[idx].img_offset) < length) {
  634. length = priv->img_info[idx].partition_size - (io->offset - priv->img_info[idx].img_offset);
  635. }
  636. int real_to_write_len = length - headsize;
  637. if (priv->img_info[idx].write_size + real_to_write_len > priv->img_info[idx].img_size) {
  638. int leftsize = priv->img_info[idx].img_size - priv->img_info[idx].write_size;
  639. if (_file_write(io, idx, &buffer[headsize], leftsize) < 0) {
  640. LOGE(TAG, "write leftsize %d bytes failed", leftsize);
  641. return -1;
  642. }
  643. LOGD(TAG, "write leftsize %d bytes ok", leftsize);
  644. priv->img_info[idx].write_size += leftsize;
  645. int remainsize = real_to_write_len - leftsize;
  646. if (priv->img_info[idx + 1].fp || priv->img_info[idx + 1].fd >= 0) {
  647. if (_file_write(io, idx + 1, &buffer[headsize + leftsize], remainsize) < 0) {
  648. LOGE(TAG, "write remainsize %d bytes failed", remainsize);
  649. return -1;
  650. }
  651. LOGD(TAG, "write remainsize %d bytes ok", remainsize);
  652. priv->img_info[idx + 1].write_size += remainsize;
  653. }
  654. } else {
  655. if (_file_write(io, idx, &buffer[headsize], real_to_write_len) < 0) {
  656. LOGE(TAG, "write real_to_write_len %d bytes failed", real_to_write_len);
  657. return -1;
  658. }
  659. LOGD(TAG, "write real_to_write_len %d bytes ok", real_to_write_len);
  660. priv->img_info[idx].write_size += real_to_write_len;
  661. }
  662. io->offset += length;
  663. return length;
  664. }
  665. static int flash_seek(netio_t *io, size_t offset, int whence)
  666. {
  667. int idx;
  668. download_img_info_t *priv = (download_img_info_t *)io->private;
  669. LOGD(TAG, "flash seek %d", offset);
  670. if (FILE_SYSTEM_IS_EXT4()) {
  671. if (offset && priv->image_count <= 0) {
  672. if (download_img_info_init_from_file(io) < 0) {
  673. return -1;
  674. }
  675. if (whence == SEEK_SET && offset >= get_img_length(io)) {
  676. LOGE(TAG, "seek offset error.");
  677. return -1;
  678. }
  679. }
  680. idx = get_img_index(io, offset);
  681. if (idx < 0) {
  682. LOGE(TAG, "flash seek error.");
  683. return -1;
  684. }
  685. switch (whence) {
  686. case SEEK_SET:
  687. io->offset = offset;
  688. if (priv->img_info[idx].fp)
  689. fseek(priv->img_info[idx].fp, (long)offset - priv->img_info[idx].img_offset, 0);
  690. if (priv->img_info[idx].fd >= 0)
  691. lseek(priv->img_info[idx].fd, (long)offset - priv->img_info[idx].img_offset, 0);
  692. priv->img_info[idx].write_size = offset - priv->img_info[idx].img_offset;
  693. return 0;
  694. }
  695. return -1;
  696. }
  697. #ifdef UBI_NOT_SUPPORT_INTERRUPTED_UPDATE
  698. int ret = 0;
  699. FILE *fp = NULL;
  700. // because of UBI not support seek.
  701. io->offset = offset;
  702. if (offset != 0) {
  703. fp = fopen(IMGINFOFILE, "rb+");
  704. if (fp) {
  705. if (fread(priv, 1, sizeof(download_img_info_t), fp) < sizeof(download_img_info_t)) {
  706. LOGE(TAG, "read %s failed.", IMGINFOFILE);
  707. ret = -1;
  708. goto out;
  709. }
  710. } else {
  711. LOGE(TAG, "download some data, but there is no %s file found.", IMGINFOFILE);
  712. if (aos_kv_setint(KV_FOTA_OFFSET, 0) < 0) {
  713. ret = -1;
  714. goto out;
  715. }
  716. }
  717. }
  718. out:
  719. if (fp) fclose(fp);
  720. return ret;
  721. #else
  722. idx = get_img_index(io, offset);
  723. if (idx < 0) {
  724. LOGE(TAG, "flash seek error.");
  725. return -1;
  726. }
  727. switch (whence) {
  728. case SEEK_SET:
  729. io->offset = offset;
  730. if (priv->img_info[idx].fp)
  731. fseek(priv->img_info[idx].fp, (long)offset - priv->img_info[idx].img_offset, 0);
  732. if (priv->img_info[idx].fd >= 0)
  733. lseek(priv->img_info[idx].fd, (long)offset - priv->img_info[idx].img_offset, 0);
  734. priv->img_info[idx].write_size = offset - priv->img_info[idx].img_offset;
  735. return 0;
  736. }
  737. #endif
  738. return -1;
  739. }
  740. const netio_cls_t flash2 = {
  741. .name = "flash2",
  742. .open = flash_open,
  743. .close = flash_close,
  744. .write = flash_write,
  745. .read = flash_read,
  746. .seek = flash_seek,
  747. };
  748. int netio_register_flash2(void)
  749. {
  750. return netio_register(&flash2);
  751. }