static int fs_format(int cidx) {
s32_t r;
struct mount_info *m = &s_fsm;
_u32 fsc_size = FS_CONTAINER_SIZE(FS_SIZE);
dprintf(("formatting %d s=%u, cs=%d\n", cidx, FS_SIZE, (int) fsc_size));
m->cidx = cidx;
r = fs_create_container(cidx, FS_SIZE);
if (r < 0) goto out;
m->fh = r;
m->valid = m->rw = m->formatting = 1;
/* Touch a byte at the end to open a "hole". */
r = sl_FsWrite(m->fh, fsc_size - 1, (_u8 *) "\xff", 1);
dprintf(("write 1 @ %d %d\n", (int) (fsc_size - 1), (int) r));
if (r != 1) goto out_close;
/* There must be a mount attempt before format. It'll fail and that's ok. */
r = fs_mount_spiffs(m, FS_SIZE, FS_BLOCK_SIZE, FS_PAGE_SIZE);
dprintf(("mount: %d\n", (int) r));
r = SPIFFS_format(&m->fs);
dprintf(("format: %d\n", (int) r));
if (r != SPIFFS_OK) goto out_close;
m->seq = INITIAL_SEQ;
r = fs_write_meta(m);
out_close:
sl_FsClose(m->fh, NULL, NULL, 0);
out:
m->fh = -1;
m->valid = m->formatting = m->rw = 0;
return r;
}
//*****************************************************************************
//! Load the proper image based on the information from the boot info
//! and launch it.
//*****************************************************************************
static void bootmgr_image_loader(sBootInfo_t *psBootInfo) {
_i32 fhandle;
_u8 *image;
// search for the active image
switch (psBootInfo->ActiveImg) {
case IMG_ACT_UPDATE1:
image = (unsigned char *)IMG_UPDATE1;
break;
case IMG_ACT_UPDATE2:
image = (unsigned char *)IMG_UPDATE2;
break;
default:
image = (unsigned char *)IMG_FACTORY;
break;
}
// do we have a new image that needs to be verified?
if ((psBootInfo->ActiveImg != IMG_ACT_FACTORY) && (psBootInfo->Status == IMG_STATUS_CHECK)) {
if (!bootmgr_verify(image)) {
// verification failed, delete the broken file
sl_FsDel(image, 0);
// switch to the previous image
psBootInfo->ActiveImg = psBootInfo->PrevImg;
psBootInfo->PrevImg = IMG_ACT_FACTORY;
}
// in any case, change the status to "READY"
psBootInfo->Status = IMG_STATUS_READY;
// write the new boot info
if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle)) {
sl_FsWrite(fhandle, 0, (unsigned char *)psBootInfo, sizeof(sBootInfo_t));
// close the file
sl_FsClose(fhandle, 0, 0, 0);
}
}
// this one might modify the boot info hence it MUST be called after
// bootmgr_verify! (so that the changes are not saved to flash)
wait_for_safe_boot(psBootInfo);
// select the active image again, since it might have changed
switch (psBootInfo->ActiveImg) {
case IMG_ACT_UPDATE1:
image = (unsigned char *)IMG_UPDATE1;
break;
case IMG_ACT_UPDATE2:
image = (unsigned char *)IMG_UPDATE2;
break;
default:
image = (unsigned char *)IMG_FACTORY;
break;
}
bootmgr_load_and_execute(image);
}
void ensureCertificateFile(const unsigned char *certificate, unsigned int certificateLen) {
long certificateFile = -1;
short status = sl_FsOpen((unsigned char *)SSL_CA_CERT_FILE_NAME, FS_MODE_OPEN_READ, NULL, &certificateFile);
if (status < 0) {
#ifdef SSL_DEBUG
DEBUG_PRINT("[Parse] Creating certificate file\r\n");
#endif /* SSL_DEBUG */
sl_FsClose(certificateFile, 0, 0, 0);
certificateFile = -1;
status = sl_FsOpen((unsigned char *)SSL_CA_CERT_FILE_NAME,
FS_MODE_OPEN_CREATE(65536, _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE),
NULL, &certificateFile);
if (status < 0) {
#ifdef SSL_DEBUG
DEBUG_PRINT("[Parse] Error creating certificate file: %d\r\n", status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* SSL_DEBUG */
return;
}
sl_FsClose(certificateFile, 0, 0, 0);
certificateFile = -1;
status = sl_FsOpen((unsigned char *)SSL_CA_CERT_FILE_NAME, FS_MODE_OPEN_WRITE, NULL, &certificateFile);
if (status < 0) {
#ifdef SSL_DEBUG
DEBUG_PRINT("[Parse] Error creating certificate file: %d\r\n", status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* SSL_DEBUG */
sl_FsClose(certificateFile, 0, 0, 0);
return;
}
status = sl_FsWrite(certificateFile, 0, (unsigned char*)certificate, certificateLen);
if (status < 0) {
#ifdef SSL_DEBUG
DEBUG_PRINT("[Parse] Error creating certificate file: %d\r\n", status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* SSL_DEBUG */
}
}
sl_FsClose(certificateFile, 0, 0, 0);
}
bool updater_write (uint8_t *buf, uint32_t len) {
bool result = false;
sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
if (len == sl_FsWrite(updater_data.fhandle, updater_data.foffset, buf, len)) {
updater_data.foffset += len;
result = true;
}
sl_LockObjUnlock (&wlan_LockObj);
return result;
}
void updater_finnish (void) {
_i32 fhandle;
if (updater_data.fhandle > 0) {
sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER);
// close the file being updated
sl_FsClose(updater_data.fhandle, NULL, NULL, 0);
#ifdef WIPY
// if we still have an image pending for verification, leave the boot info as it is
if (!strncmp(IMG_PREFIX, updater_data.path, strlen(IMG_PREFIX)) && sBootInfo.Status != IMG_STATUS_CHECK) {
#else
if (!strncmp(IMG_PREFIX, updater_data.path, strlen(IMG_PREFIX))) {
#endif
#ifdef DEBUG
if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_READ, NULL, &fhandle)) {
ASSERT (sizeof(sBootInfo_t) == sl_FsRead(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t)));
sl_FsClose(fhandle, 0, 0, 0);
#endif
// open the boot info file for writing
ASSERT (sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle) == 0);
#ifdef DEBUG
}
else {
// the boot info file doesn't exist yet
_u32 BootInfoCreateFlag = _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE | _FS_FILE_PUBLIC_READ;
ASSERT (sl_FsOpen ((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_CREATE((2 * sizeof(sBootInfo_t)),
BootInfoCreateFlag), NULL, &fhandle) == 0);
}
#endif
// save the new boot info
#ifdef WIPY
sBootInfo.PrevImg = sBootInfo.ActiveImg;
if (sBootInfo.ActiveImg == IMG_ACT_UPDATE1) {
sBootInfo.ActiveImg = IMG_ACT_UPDATE2;
} else {
sBootInfo.ActiveImg = IMG_ACT_UPDATE1;
}
// the launchxl doesn't have enough flash space for 2 user updates
#else
sBootInfo.PrevImg = IMG_ACT_FACTORY;
sBootInfo.ActiveImg = IMG_ACT_UPDATE1;
#endif
sBootInfo.Status = IMG_STATUS_CHECK;
ASSERT (sizeof(sBootInfo_t) == sl_FsWrite(fhandle, 0, (unsigned char *)&sBootInfo, sizeof(sBootInfo_t)));
sl_FsClose(fhandle, 0, 0, 0);
}
sl_LockObjUnlock (&wlan_LockObj);
updater_data.fhandle = -1;
}
sl_LockObjUnlock (&updater_LockObj);
}
ssize_t fs_slfs_write(int fd, const void *buf, size_t count) {
struct sl_fd_info *fi = &s_sl_fds[fd];
if (fi->fh <= 0) return set_errno(EBADF);
_i32 r = sl_FsWrite(fi->fh, fi->pos, (_u8 *) buf, count);
DBG(("sl_FsWrite(%d, %d, %d) = %d", (int) fi->fh, (int) fi->pos, (int) count,
(int) r));
if (r >= 0) {
fi->pos += r;
return r;
}
return set_errno(sl_fs_to_errno(r));
}
static s32_t failfs_write(spiffs *fs, u32_t addr, u32_t size, u8_t *src) {
struct mount_info *m = (struct mount_info *) fs->user_data;
_i32 r;
DBG(("failfs_write %d @ %d, cidx %d # %llu, fh %d, valid %d, rw %d",
(int) size, (int) addr, m->cidx, m->seq, (int) m->fh, m->valid, m->rw));
if (!m->valid) return SPIFFS_ERR_NOT_WRITABLE;
if (!m->rw) {
/* Remount rw. */
if (fs_switch_container(m, 0, 0) != 0) return SPIFFS_ERR_NOT_WRITABLE;
}
r = sl_FsWrite(m->fh, addr, src, size);
DBG(("write %d", (int) r));
m->last_write = mg_time();
return (r == size) ? SPIFFS_OK : SPIFFS_ERR_NOT_WRITABLE;
}
static s32_t failfs_write(u32_t addr, u32_t size, u8_t *src) {
struct mount_info *m = &s_fsm;
_i32 r;
dprintf(("failfs_write %d @ %d, cidx %d # %llu, fh %d, valid %d, rw %d\n",
(int) size, (int) addr, m->cidx, m->seq, (int) m->fh, m->valid,
m->rw));
if (!m->valid) return SPIFFS_ERR_NOT_WRITABLE;
if (!m->rw) {
/* Remount rw. */
if (fs_switch_container(m, 0, 0) != 0) return SPIFFS_ERR_NOT_WRITABLE;
}
r = sl_FsWrite(m->fh, addr, src, size);
dprintf(("write %d\n", (int) r));
return (r == size) ? SPIFFS_OK : SPIFFS_ERR_NOT_WRITABLE;
}
static _i32 fs_write_meta(struct mount_info *m) {
int r;
_u32 offset;
union fs_meta meta;
memset(&meta, 0xff, sizeof(meta));
meta.info.seq = m->seq;
meta.info.fs_size = m->fs.cfg.phys_size;
meta.info.fs_block_size = m->fs.cfg.log_block_size;
meta.info.fs_page_size = m->fs.cfg.log_page_size;
offset = FS_CONTAINER_SIZE(meta.info.fs_size) - sizeof(meta);
r = sl_FsWrite(m->fh, offset, (_u8 *) &meta, sizeof(meta));
dprintf(("write meta %llu @ %d: %d\n", m->seq, (int) offset, (int) r));
if (r == sizeof(meta)) r = 0;
return r;
}
static _i32 _WriteBootInfo(sBootInfo_t *psBootInfo)
{
_i32 lFileHandle;
_u32 ulToken;
_i32 status = -1;
if( 0 == sl_FsOpen((_u8 *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, &ulToken, &lFileHandle) )
{
if( 0 < sl_FsWrite(lFileHandle, 0, (_u8 *)psBootInfo, sizeof(sBootInfo_t)) )
{
Report("WriteBootInfo: ucActiveImg=%d, ulImgStatus=0x%x\n\r", psBootInfo->ucActiveImg, psBootInfo->ulImgStatus);
status = 0;
}
sl_FsClose(lFileHandle, 0, 0, 0);
}
return status;
}
_i32 fs_write_meta(_i32 fh, _u64 seq, _u32 fs_size, _u32 fs_block_size,
_u32 fs_page_size, _u32 fs_erase_size) {
int r;
_u32 offset;
union fs_container_meta meta;
memset(&meta, 0xff, sizeof(meta));
meta.info.seq = seq;
meta.info.fs_size = fs_size;
meta.info.fs_block_size = fs_block_size;
meta.info.fs_page_size = fs_page_size;
meta.info.fs_erase_size = fs_erase_size;
offset = FS_CONTAINER_SIZE(meta.info.fs_size) - sizeof(meta);
r = sl_FsWrite(fh, offset, (_u8 *) &meta, sizeof(meta));
DBG(("write meta %llu @ %d: %d", seq, (int) offset, (int) r));
if (r == sizeof(meta)) r = 0;
return r;
}
//*****************************************************************************
//! Load the proper image based on information from boot info and executes it.
//*****************************************************************************
static void bootmgr_image_loader(sBootInfo_t *psBootInfo) {
_i32 fhandle;
if (safe_mode_boot()) {
_u32 count = 0;
while ((BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS * count++) < BOOTMGR_SAFE_MODE_ENTER_MS) {
// toogle the led
MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, ~MAP_GPIOPinRead(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN));
UtilsDelay(UTILS_DELAY_US_TO_COUNT(BOOTMGR_SAFE_MODE_ENTER_TOOGLE_MS * 1000));
}
psBootInfo->ActiveImg = IMG_ACT_FACTORY;
// turn the led off
MAP_GPIOPinWrite(MICROPY_SYS_LED_PORT, MICROPY_SYS_LED_PORT_PIN, 0);
// request a safe boot to the application
PRCMRequestSafeBoot();
}
// do we have a new update image that needs to be verified?
else if ((psBootInfo->ActiveImg == IMG_ACT_UPDATE) && (psBootInfo->Status == IMG_STATUS_CHECK)) {
if (!bootmgr_verify()) {
// delete the corrupted file
sl_FsDel((_u8 *)IMG_UPDATE, 0);
// switch to the factory image
psBootInfo->ActiveImg = IMG_ACT_FACTORY;
}
// in any case, set the status as "READY"
psBootInfo->Status = IMG_STATUS_READY;
// write the new boot info
if (!sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE, NULL, &fhandle)) {
sl_FsWrite(fhandle, 0, (unsigned char *)psBootInfo, sizeof(sBootInfo_t));
// close the file
sl_FsClose(fhandle, 0, 0, 0);
}
}
// now boot the active image
if (IMG_ACT_UPDATE == psBootInfo->ActiveImg) {
bootmgr_load_and_execute((unsigned char *)IMG_UPDATE);
}
else {
bootmgr_load_and_execute((unsigned char *)IMG_FACTORY);
}
}
size_t SLFS::write(const uint8_t *buffer, size_t len)
{
if (!filehandle) {
retval = SLFS_LIB_ERR_FILE_NOT_OPEN;
return 0;
}
if (!is_write) {
retval = SLFS_LIB_ERR_FILE_OPEN_FOR_READ;
return 0;
}
if (offset > filesize)
return 0;
retval = sl_FsWrite(filehandle, offset, (unsigned char *)buffer, len);
if (retval < 0) {
return 0;
}
offset += retval;
return retval;
}
size_t SLFS::write(uint8_t c)
{
if (!filehandle) {
retval = SLFS_LIB_ERR_FILE_NOT_OPEN;
return 0;
}
if (!is_write) {
retval = SLFS_LIB_ERR_FILE_OPEN_FOR_READ;
return 0;
}
if (offset > filesize)
return 0;
retval = sl_FsWrite(filehandle, offset, &c, 1);
if (retval < 1) {
return 0;
}
offset++;
return 1;
}
//*****************************************************************************
//
//! This funtion includes the following steps:
//! -open a user file for writing
//! -write "Old MacDonalds" child song 37 times to get just below a 64KB file
//! -close the user file
//!
//! /param[out] ulToken : file token
//! /param[out] lFileHandle : file handle
//!
//! /return 0:Success, -ve: failure
//
//*****************************************************************************
long WriteFileToDevice(unsigned long *ulToken, long *lFileHandle)
{
long lRetVal = -1;
int iLoopCnt = 0;
//
// create a user file
//
lRetVal = sl_FsOpen((unsigned char *)USER_FILE_NAME,
FS_MODE_OPEN_CREATE(65536, \
_FS_FILE_OPEN_FLAG_COMMIT|_FS_FILE_PUBLIC_WRITE),
ulToken,
lFileHandle);
if(lRetVal < 0)
{
//
// File may already be created
//
lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
}
else
{
//
// close the user file
//
lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0);
if (SL_RET_CODE_OK != lRetVal)
{
ASSERT_ON_ERROR(FILE_CLOSE_ERROR);
}
}
//
// open a user file for writing
//
lRetVal = sl_FsOpen((unsigned char *)USER_FILE_NAME,
FS_MODE_OPEN_WRITE,
ulToken,
lFileHandle);
if(lRetVal < 0)
{
lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0);
ASSERT_ON_ERROR(FILE_OPEN_WRITE_FAILED);
}
//
// write "Old MacDonalds" child song as many times to get just below a 64KB file
//
for (iLoopCnt = 0;
iLoopCnt < (SL_MAX_FILE_SIZE / sizeof(gaucOldMacDonald));
iLoopCnt++)
{
lRetVal = sl_FsWrite(*lFileHandle,
(unsigned int)(iLoopCnt * sizeof(gaucOldMacDonald)),
(unsigned char *)gaucOldMacDonald, sizeof(gaucOldMacDonald));
if (lRetVal < 0)
{
lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0);
ASSERT_ON_ERROR(FILE_WRITE_FAILED);
}
}
//
// close the user file
//
lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0);
if (SL_RET_CODE_OK != lRetVal)
{
ASSERT_ON_ERROR(FILE_CLOSE_ERROR);
}
return SUCCESS;
}
static _i32 fs_switch_container(struct mount_info *m, _u32 mask_begin,
_u32 mask_len) {
int r;
int new_cidx = m->cidx ^ 1;
_i32 old_fh = m->fh, new_fh;
_u8 *buf;
_u32 offset, len, buf_size;
dprintf(("switch %d -> %d\n", m->cidx, new_cidx));
if (old_fh < 0) {
r = sl_FsOpen(container_fname(m->cidx), FS_MODE_OPEN_READ, NULL, &old_fh);
dprintf(("fopen %d\n", r));
if (r < 0) {
r = SPIFFS_ERR_NOT_READABLE;
goto out_close_old;
}
}
new_fh = fs_create_container(new_cidx, m->fs.cfg.phys_size);
if (new_fh < 0) {
r = new_fh;
goto out_close_old;
}
buf_size = 8192;
buf = get_buf(&buf_size);
if (buf == NULL) {
r = SPIFFS_ERR_INTERNAL;
goto out_close_new;
}
for (offset = 0; offset < m->fs.cfg.phys_size;) {
len = buf_size;
if (offset == mask_begin) {
offset = mask_begin + mask_len;
} else if (offset + len > mask_begin && offset < mask_begin + mask_len) {
len = mask_begin - offset;
}
if (offset + len > m->fs.cfg.phys_size) {
len = m->fs.cfg.phys_size - offset;
}
dprintf(("copy %d @ %d\n", (int) len, (int) offset));
if (len > 0) {
r = sl_FsRead(old_fh, offset, buf, len);
if (r != len) {
r = SPIFFS_ERR_NOT_READABLE;
goto out_free;
}
r = sl_FsWrite(new_fh, offset, buf, len);
if (r != len) {
r = SPIFFS_ERR_NOT_WRITABLE;
goto out_free;
}
offset += len;
}
}
m->seq--;
m->cidx = new_cidx;
m->fh = new_fh;
new_fh = -1;
m->rw = 1;
r = fs_write_meta(m);
out_free:
free(buf);
out_close_new:
if (new_fh > 0) sl_FsClose(new_fh, NULL, NULL, 0);
out_close_old:
sl_FsClose(old_fh, NULL, NULL, 0);
dprintf(("switch: %d\n", r));
return r;
}
int GetFileFromServer(const int socket, const char* filename, const char* filenameInFlash) {
int transfer_len = 0;
long retVal = 0;
long fileHandle = -1;
unsigned long Token = 0, bytesReceived = 0;
unsigned char *pBuff = 0;
unsigned long file_size = 0;
unsigned char buffer[MAX_BUFF_SIZE + 1];
UART_PRINT("Start downloading the file %s\r\n", filename);
memset(buffer, 0, sizeof(buffer));
// Puts together the HTTP GET string.
strcpy((char *) buffer, PREFIX_BUFFER);
strcat((char *) buffer, filename);
strcat((char *) buffer, POST_BUFFER);
// Send the HTTP GET string to the opened TCP/IP socket.
transfer_len = sl_Send(socket, buffer, strlen((const char *) buffer), 0);
if (transfer_len < 0) {
// error
UART_PRINT("Socket Send Error\r\n");
return -1;
}
memset(buffer, 0, sizeof(buffer));
// get the reply from the server in buffer.
transfer_len = sl_Recv(socket, buffer, MAX_BUFF_SIZE, 0);
if (transfer_len > 0) {
// Check for 404 return code
if (strstr((const char *) buffer, HTTP_FILE_NOT_FOUND) != 0) {
UART_PRINT("File not found, check the file and try again\r\n");
return -1;
}
// if not "200 OK" return error
if (strstr((const char *) buffer, HTTP_STATUS_OK) == 0) {
UART_PRINT("Error during downloading the file\r\n");
return -1;
}
// check if content length is transfered with headers
pBuff = (unsigned char *) strstr((const char *) buffer, HTTP_CONTENT_LENGTH);
if (pBuff != 0) {
pBuff += strlen(HTTP_CONTENT_LENGTH);
while (*pBuff != 0x0d)
pBuff++;
unsigned long multiplicant = 1;
pBuff--;
while (*pBuff != ' ') {
file_size += (*pBuff - '0') * multiplicant;
multiplicant *= 10;
pBuff--;
}
if (file_size == 0) {
UART_PRINT("\nContent Length not detected.\r\n");
return -1;
}
UART_PRINT("Content Length %d\r\n", file_size);
} else {
UART_PRINT("\nContent Length not detected.\r\n");
return -1;
}
// "\r\n\r\n" marks the end of headers
pBuff = (unsigned char *) strstr((const char *) buffer, HTTP_END_OF_HEADER);
if (pBuff == 0) {
UART_PRINT("Invalid response\r\n");
return -1;
}
// Increment by 4 to skip "\r\n\r\n"
pBuff += 4;
// Adjust buffer data length for header size
transfer_len -= (pBuff - buffer);
}
// Delete eventually existing temporary file
sl_FsDel((unsigned char *) filenameInFlash, Token);
// Create a temporary file to save the downloaded file
// open a user file for writing
retVal = sl_FsOpen((unsigned char *) filenameInFlash, FS_MODE_OPEN_WRITE, &Token, &fileHandle);
if (retVal < 0) {
// File Doesn't exit create a new of file_size KB file
retVal = sl_FsOpen((unsigned char *) filenameInFlash, FS_MODE_OPEN_CREATE(file_size, _FS_FILE_PUBLIC_WRITE), &Token, &fileHandle);
if (retVal < 0) {
UART_PRINT("Error during opening the temporary file\r\n");
return -1;
}
}
while (bytesReceived < file_size) {
retVal = sl_FsWrite(fileHandle, bytesReceived, (unsigned char *) pBuff, transfer_len);
if (retVal < 0) {
retVal = sl_FsClose(fileHandle, 0, 0, 0);
retVal = sl_FsDel((unsigned char *) filenameInFlash, Token);
UART_PRINT("Error during writing the file\r\n");
return -1;
}
bytesReceived += transfer_len;
if (bytesReceived == file_size) break;
memset(buffer, 0, sizeof(buffer));
transfer_len = sl_Recv(socket, buffer, MAX_BUFF_SIZE, 0);
pBuff = buffer;
}
// Close the opened file
retVal = sl_FsClose(fileHandle, 0, 0, 0);
if (bytesReceived != file_size) {
UART_PRINT("Error While File Download\r\n");
retVal = sl_FsDel((unsigned char *) filenameInFlash, Token);
return -1;
} else {
UART_PRINT("\nDownloading File Completed\r\n");
}
return 0;
}
short saveConfig() {
long status = 0;
long configFile = -1;
UART_PRINT("[Blink] Saving configuration\r\n");
status = sl_FsOpen((unsigned char *) CONFIG_FILENAME,
FS_MODE_OPEN_CREATE(65536, _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE),
NULL, &configFile);
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
return status;
}
sl_FsClose(configFile, 0, 0, 0);
configFile = -1;
status = sl_FsOpen((unsigned char *) CONFIG_FILENAME, FS_MODE_OPEN_WRITE, NULL, &configFile);
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
UART_PRINT("[Blink] Application Id : %s\r\n", g_ApplicationID);
long readOffset = 0;
status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_ApplicationID, sizeof(g_ApplicationID));
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
UART_PRINT("[Blink] Client key : %s\r\n", g_ClientKey);
readOffset = readOffset + status;
status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_ClientKey, sizeof(g_ClientKey));
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
UART_PRINT("[Blink] Installation Id : %s\r\n", g_InstallationID);
readOffset = readOffset + status;
status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_InstallationID, sizeof(g_InstallationID));
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
UART_PRINT("[Blink] Session token : %s\r\n", g_SessionToken);
readOffset = readOffset + status;
status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_SessionToken, sizeof(g_SessionToken));
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
UART_PRINT("[Blink] Device name : %s\r\n", g_DeviceName);
readOffset = readOffset + status;
status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_DeviceName, sizeof(g_DeviceName));
if (status < 0) {
ERR_PRINT(status);
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n");
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
sl_FsClose(configFile, 0, 0, 0);
return status;
}
static _i32 fs_switch_container(struct mount_info *m, _u32 mask_begin,
_u32 mask_len) {
int r;
int new_cidx = m->cidx ^ 1;
_i32 old_fh = m->fh, new_fh;
_u8 *buf;
_u32 offset, len, buf_size;
LOG(LL_DEBUG, ("%s %d -> %d", m->cpfx, m->cidx, new_cidx));
if (old_fh > 0 && m->rw) {
/*
* During the switch the destination container will be unusable.
* If switching from a writeable container (likely in response to an erase),
* close the old container first to make it safe and reopen for reading.
*/
fs_close_container(m);
old_fh = -1;
}
if (old_fh < 0) {
_u8 fname[MAX_FS_CONTAINER_FNAME_LEN];
fs_container_fname(m->cpfx, m->cidx, fname);
r = sl_FsOpen(fname, FS_MODE_OPEN_READ, NULL, &old_fh);
DBG(("fopen %s %d", m->cpfx, r));
if (r < 0) {
r = SPIFFS_ERR_NOT_READABLE;
goto out_close_old;
}
}
miot_wdt_feed();
new_fh = fs_create_container(m->cpfx, new_cidx, m->fs.cfg.phys_size);
if (new_fh < 0) {
r = new_fh;
goto out_close_old;
}
buf_size = 1024;
buf = get_buf(&buf_size);
if (buf == NULL) {
r = SPIFFS_ERR_INTERNAL;
goto out_close_new;
}
for (offset = 0; offset < m->fs.cfg.phys_size;) {
len = buf_size;
if (offset == mask_begin) {
offset = mask_begin + mask_len;
} else if (offset + len > mask_begin && offset < mask_begin + mask_len) {
len = mask_begin - offset;
}
if (offset + len > m->fs.cfg.phys_size) {
len = m->fs.cfg.phys_size - offset;
}
DBG(("copy %d @ %d", (int) len, (int) offset));
if (len > 0) {
r = sl_FsRead(old_fh, offset, buf, len);
if (r != len) {
r = SPIFFS_ERR_NOT_READABLE;
goto out_free;
}
r = sl_FsWrite(new_fh, offset, buf, len);
if (r != len) {
r = SPIFFS_ERR_NOT_WRITABLE;
goto out_free;
}
offset += len;
}
}
m->seq--;
m->cidx = new_cidx;
m->fh = new_fh;
new_fh = -1;
m->rw = 1;
r = fs_write_mount_meta(m);
m->last_write = mg_time();
out_free:
free(buf);
out_close_new:
if (new_fh > 0) sl_FsClose(new_fh, NULL, NULL, 0);
out_close_old:
sl_FsClose(old_fh, NULL, NULL, 0);
LOG((r == 0 ? LL_DEBUG : LL_ERROR), ("%d", r));
return r;
}
//****************************************************************************
//
//! \internal
//!
//! Set the factory image as the new boot image
//!
//! return None
//
//****************************************************************************
static int FactoryResetTask(void *pvParameters)
{
sBootInfo_t sBootInfo;
long lFileHandle;
unsigned long ulToken;
static unsigned char ucTaskOwnState = FACTORY_RST_STATE_WAIT_BTN;
switch(ucTaskOwnState)
{
case FACTORY_RST_STATE_WAIT_BTN:
//
// Wait for button press
//
TaskSyncObjWait(&g_FactResetSyncObj);
//
// Switch to RUN state
//
ucTaskOwnState = FACTORY_RST_STATE_RUN;
//
// Break
//
break;
case FACTORY_RST_STATE_RUN:
//
// Read the boot Info
//
if( 0 == sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_READ,
&ulToken, &lFileHandle) )
{
if( 0 > sl_FsRead(lFileHandle, 0, (unsigned char *)&sBootInfo,
sizeof(sBootInfo_t)) )
{
return TASK_RET_DONE;
}
sl_FsClose(lFileHandle, 0, 0, 0);
}
//
// Set the factory default
//
sBootInfo.ucActiveImg = IMG_ACT_FACTORY;
sBootInfo.ulImgStatus = IMG_STATUS_NOTEST;
//
// Save the new configuration
//
if( 0 == sl_FsOpen((unsigned char *)IMG_BOOT_INFO, FS_MODE_OPEN_WRITE,
&ulToken, &lFileHandle) )
{
sl_FsWrite(lFileHandle, 0, (unsigned char *)&sBootInfo,
sizeof(sBootInfo_t));
sl_FsClose(lFileHandle, 0, 0, 0);
}
//
// Force reboot
//
g_ulSysState = SYS_STATE_REBOOT;
//
// Return done.
//
return TASK_RET_DONE;
}
return TASK_RET_IN_PROG;
}
short saveClientState(ParseClientInternal *parseClient) {
#ifdef CLIENT_DEBUG
DEBUG_PRINT("[Parse] Saving client state\r\n");
#endif /* CLIENT_DEBUG */
snprintf(clientStateFileName, CLIENT_STATE_FILENAME_LEN, CLIENT_STATE_FILENAME, parseClient->applicationId);
long clientStateFile = -1;
sl_FsDel((unsigned char *)clientStateFileName, 0);
short status = sl_FsOpen((unsigned char *)clientStateFileName,
FS_MODE_OPEN_CREATE(65536, _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE),
NULL, &clientStateFile);
if (status < 0) {
#ifdef CLIENT_DEBUG
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* CLIENT_DEBUG */
return status;
}
sl_FsClose(clientStateFile, 0, 0, 0);
clientStateFile = -1;
status = sl_FsOpen((unsigned char *)clientStateFileName, FS_MODE_OPEN_WRITE, NULL, &clientStateFile);
if (status < 0) {
#ifdef CLIENT_DEBUG
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* CLIENT_DEBUG */
sl_FsClose(clientStateFile, 0, 0, 0);
return status;
}
#ifdef CLIENT_DEBUG
DEBUG_PRINT("[Parse] Installation Id: %s\r\n", parseClient->installationId);
#endif /* CLIENT_DEBUG */
long writeOffset = 0;
status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->installationId, sizeof(parseClient->installationId));
if (status < 0) {
#ifdef CLIENT_DEBUG
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* CLIENT_DEBUG */
sl_FsClose(clientStateFile, 0, 0, 0);
return status;
}
#ifdef CLIENT_DEBUG
DEBUG_PRINT("[Parse] Session token: %s\r\n", parseClient->sessionToken);
#endif /* CLIENT_DEBUG */
writeOffset = writeOffset + status;
status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->sessionToken, sizeof(parseClient->sessionToken));
if (status < 0) {
#ifdef CLIENT_DEBUG
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* CLIENT_DEBUG */
sl_FsClose(clientStateFile, 0, 0, 0);
return status;
}
#ifdef CLIENT_DEBUG
DEBUG_PRINT("[Parse] Last push hash: %s\r\n", parseClient->lastPushHash);
#endif /* CLIENT_DEBUG */
writeOffset = writeOffset + status;
status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->lastPushHash, sizeof(parseClient->lastPushHash));
if (status < 0) {
#ifdef CLIENT_DEBUG
if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) {
DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n");
}
#endif /* CLIENT_DEBUG */
sl_FsClose(clientStateFile, 0, 0, 0);
return status;
}
sl_FsClose(clientStateFile, 0, 0, 0);
return status;
}
_i32 sl_extlib_FlcWriteFile(_i32 fileHandle, _i32 offset, _u8 *buf, _i32 len)
{
return sl_FsWrite(fileHandle, (_u32)(offset), (_u8 *)buf, len);
}
//****************************************************************************
//
//! \brief Obtain the file from the server
//!
//! This function requests the file from the server and save it on serial flash.
//! To request a different file for different user needs to modify the
//! PREFIX_BUFFER macros.
//!
//! \param[in] cli - Instance of the HTTP connection
//!
//! \return 0 for success and negative for error
//
//****************************************************************************
static int GetData(HTTPCli_Handle cli)
{
long lRetVal = 0;
long fileHandle = -1;
unsigned long Token = 0;
int id;
int len=0;
bool moreFlag = 0;
HTTPCli_Field fields[3] = {
{HTTPCli_FIELD_NAME_HOST, HOST_NAME},
{HTTPCli_FIELD_NAME_ACCEPT, "text/html, application/xhtml+xml, */*"},
{NULL, NULL}
};
const char *ids[4] = {
HTTPCli_FIELD_NAME_CONTENT_LENGTH,
HTTPCli_FIELD_NAME_TRANSFER_ENCODING,
HTTPCli_FIELD_NAME_CONNECTION,
NULL
};
UART_PRINT("Start downloading the file\r\n");
// Set request fields
HTTPCli_setRequestFields(cli, fields);
memset(g_buff, 0, sizeof(g_buff));
// Make HTTP 1.1 GET request
lRetVal = HTTPCli_sendRequest(cli, HTTPCli_METHOD_GET, PREFIX_BUFFER, 0);
if (lRetVal < 0)
{
// error
ASSERT_ON_ERROR(TCP_SEND_ERROR);
}
// Test getResponseStatus: handle
lRetVal = HTTPCli_getResponseStatus(cli);
if (lRetVal != 200)
{
FlushHTTPResponse(cli);
if(lRetVal == 404)
{
ASSERT_ON_ERROR(FILE_NOT_FOUND_ERROR);
}
ASSERT_ON_ERROR(INVALID_SERVER_RESPONSE);
}
HTTPCli_setResponseFields(cli, ids);
// Read response headers
while ((id = HTTPCli_getResponseField(cli, (char *)g_buff, sizeof(g_buff), &moreFlag))
!= HTTPCli_FIELD_ID_END)
{
if(id == 0)
{
UART_PRINT("Content length: %s\n\r", g_buff);
}
else if(id == 1)
{
if(!strncmp((const char *)g_buff, "chunked", sizeof("chunked")))
{
UART_PRINT("Chunked transfer encoding\n\r");
}
}
else if(id == 2)
{
if(!strncmp((const char *)g_buff, "close", sizeof("close")))
{
ASSERT_ON_ERROR(FORMAT_NOT_SUPPORTED);
}
}
}
// Open file to save the downloaded file
lRetVal = sl_FsOpen((_u8 *)FILE_NAME, FS_MODE_OPEN_WRITE, &Token, &fileHandle);
if(lRetVal < 0)
{
// File Doesn't exit create a new of 40 KB file
lRetVal = sl_FsOpen((unsigned char *)FILE_NAME, \
FS_MODE_OPEN_CREATE(SIZE_40K, \
_FS_FILE_OPEN_FLAG_COMMIT|_FS_FILE_PUBLIC_WRITE),
&Token, &fileHandle);
ASSERT_ON_ERROR(lRetVal);
}
while(1)
{
len = HTTPCli_readResponseBody(cli, (char *)g_buff, sizeof(g_buff) - 1, &moreFlag);
if(len < 0)
{
// Close file without saving
lRetVal = sl_FsClose(fileHandle, 0, (unsigned char*) "A", 1);
return lRetVal;
}
lRetVal = sl_FsWrite(fileHandle, bytesReceived,
(unsigned char *)g_buff, len);
if(lRetVal < len)
{
UART_PRINT("Failed during writing the file, Error-code: %d\r\n", \
FILE_WRITE_ERROR);
// Close file without saving
lRetVal = sl_FsClose(fileHandle, 0, (unsigned char*) "A", 1);
return lRetVal;
}
bytesReceived +=len;
if ((len - 2) >= 0 && g_buff[len - 2] == '\r' && g_buff [len - 1] == '\n'){
break;
}
if(!moreFlag)
{
break;
}
}
//
// If user file has checksum which can be used to verify the temporary
// file then file should be verified
// In case of invalid file (FILE_NAME) should be closed without saving to
// recover the previous version of file
//
// Save and close file
UART_PRINT("Total bytes received: %d\n\r", bytesReceived);
lRetVal = sl_FsClose(fileHandle, 0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
return SUCCESS;
}
static void TFTPTask(void *pvParameters)
{
SlSecParams_t secParams;
unsigned char *pucFileBuffer = NULL; // Data read or to be written
unsigned long uiFileSize;
const char *FileRead = "readFromServer.txt"; // File to be read using TFTP. Change string to filename
const char *FileWrite = "writeToServer.txt"; // File to be written using TFTP. Change string to filename.
long pFileHandle; // Pointer to file handle
SlFsFileInfo_t pFsFileInfo;
long lRetVal = -1;
unsigned short uiTftpErrCode;
//get wifi information
// get_wifi_info(ap_ssid, secPrams);
// Configuring security parameters for the AP
secParams.Key = (_i8*)SSID_KEY;
secParams.KeyLen = 30;
secParams.Type = SL_SEC_TYPE_WPA_WPA2;
lRetVal = Network_IF_InitDriver(ROLE_STA);
// Connecting to WLAN AP - Set with static parameters defined at the top
// After this call we will be connected and have IP address
lRetVal = Network_IF_ConnectAP((char*)SSID,secParams);
UART_PRINT("Connecting to TFTP server %d.%d.%d.%d\n\r",\
SL_IPV4_BYTE(TFTP_IP, 3),SL_IPV4_BYTE(TFTP_IP, 2),
SL_IPV4_BYTE(TFTP_IP, 1),SL_IPV4_BYTE(TFTP_IP, 0));
if(TFTP_READ)
{
uiFileSize = FILE_SIZE_MAX;
pucFileBuffer = new unsigned char[uiFileSize];
if(NULL == pucFileBuffer)
{
UART_PRINT("Can't Allocate Resources\r\n");
LOOP_FOREVER();
}
memset(pucFileBuffer,'\0',uiFileSize);
lRetVal = sl_TftpRecv(TFTP_IP, FileRead, (char *)pucFileBuffer,\
&uiFileSize, &uiTftpErrCode );
UART_PRINT("file read is %s\n", pucFileBuffer);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo);
if(lRetVal < 0 )
lRetVal = sl_FsOpen((unsigned char *)FileRead,\
FS_MODE_OPEN_CREATE(FILE_SIZE_MAX,_FS_FILE_OPEN_FLAG_COMMIT|\
_FS_FILE_PUBLIC_WRITE), NULL,&pFileHandle);
else
lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_WRITE, \
NULL,&pFileHandle);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsWrite(pFileHandle,0, pucFileBuffer, uiFileSize);
if(lRetVal < 0)
{
free(pucFileBuffer);
lRetVal = sl_FsClose(pFileHandle,0,0,0);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UART_PRINT("TFTP Read Successful \r\n");
lRetVal = sl_FsClose(pFileHandle,0,0,0);
}
if(TFTP_WRITE)
{
/* open same file which has been written with the server's file content */
lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_READ, \
NULL,&pFileHandle);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo);
if(lRetVal < 0)
{
lRetVal = sl_FsClose(pFileHandle,0,0,0);
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
uiFileSize = (&pFsFileInfo)->FileLen;
lRetVal = sl_FsRead(pFileHandle, 0, pucFileBuffer, uiFileSize);
if(lRetVal < 0)
{
lRetVal = sl_FsClose(pFileHandle,0,0,0);
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsClose(pFileHandle,0,0,0);
/* write to server with different file name */
lRetVal = sl_TftpSend(TFTP_IP, FileWrite,(char *) pucFileBuffer,\
&uiFileSize, &uiTftpErrCode );
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UART_PRINT("TFTP Write Successful \r\n");
}
LOOP_FOREVER();
}
static int tcmp(const struct json_token *tok, const char *str) {
struct mg_str s = {.p = tok->ptr, .len = tok->len};
return mg_vcmp(&s, str);
}
enum mgos_upd_file_action mgos_upd_file_begin(
struct mgos_upd_hal_ctx *ctx, const struct mgos_upd_file_info *fi) {
struct mg_str part_name = MG_MK_STR("");
enum mgos_upd_file_action ret = MGOS_UPDATER_SKIP_FILE;
struct find_part_info find_part_info = {fi->name, &part_name, &ctx->cur_part};
ctx->cur_part.len = part_name.len = 0;
json_walk(ctx->parts->ptr, ctx->parts->len, find_part, &find_part_info);
if (ctx->cur_part.len == 0) return ret;
/* Drop any indexes from part name, we'll add our own. */
while (1) {
char c = part_name.p[part_name.len - 1];
if (c != '.' && !(c >= '0' && c <= '9')) break;
part_name.len--;
}
struct json_token type = JSON_INVALID_TOKEN;
const char *fname = NULL;
uint32_t falloc = 0;
json_scanf(ctx->cur_part.ptr, ctx->cur_part.len,
"{load_addr:%u, falloc:%u, type: %T}", &ctx->app_load_addr,
&falloc, &type);
if (falloc == 0) falloc = fi->size;
if (tcmp(&type, "app") == 0) {
struct boot_cfg cur_cfg;
int r = read_boot_cfg(ctx->cur_boot_cfg_idx, &cur_cfg);
if (r < 0) {
ctx->status_msg = "Could not read current boot cfg";
return MGOS_UPDATER_ABORT;
}
#if CC3200_SAFE_CODE_UPDATE
/*
* When safe code update is enabled, we write code to a new file.
* Otherwise we write to the same slot we're using currently, which is
* unsafe, makes reverting code update not possible, but saves space.
*/
create_fname(
mg_mk_str_n(cur_cfg.app_image_file, strlen(cur_cfg.app_image_file) - 2),
ctx->new_boot_cfg_idx, ctx->app_image_file,
sizeof(ctx->app_image_file));
#else
{
strncpy(ctx->app_image_file, cur_cfg.app_image_file,
sizeof(ctx->app_image_file));
}
#endif
if (ctx->app_load_addr >= 0x20000000) {
fname = ctx->app_image_file;
} else {
ctx->status_msg = "Bad/missing app load_addr";
ret = MGOS_UPDATER_ABORT;
}
} else if (tcmp(&type, "fs") == 0) {
json_scanf(
ctx->cur_part.ptr, ctx->cur_part.len,
"{fs_size: %u, fs_block_size: %u, fs_page_size: %u, fs_erase_size: %u}",
&ctx->fs_size, &ctx->fs_block_size, &ctx->fs_page_size,
&ctx->fs_erase_size);
if (ctx->fs_size > 0 && ctx->fs_block_size > 0 && ctx->fs_page_size > 0 &&
ctx->fs_erase_size > 0) {
char fs_container_prefix[MAX_FS_CONTAINER_PREFIX_LEN];
create_fname(part_name, ctx->new_boot_cfg_idx, fs_container_prefix,
sizeof(fs_container_prefix));
/* Delete container 1 (if any) so that 0 is the only one. */
cc32xx_vfs_dev_slfs_container_delete_container(fs_container_prefix, 1);
cc32xx_vfs_dev_slfs_container_fname(fs_container_prefix, 0,
(_u8 *) ctx->fs_container_file);
fname = ctx->fs_container_file;
if (fi->size > ctx->fs_size) {
/* Assume meta has already been added. */
falloc = fi->size;
} else {
falloc = FS_CONTAINER_SIZE(fi->size);
}
} else {
ctx->status_msg = "Missing FS parameters";
ret = MGOS_UPDATER_ABORT;
}
}
if (fname != NULL) {
int r = prepare_to_write(ctx, fi, fname, falloc, &ctx->cur_part);
if (r < 0) {
LOG(LL_ERROR, ("err = %d", r));
ret = MGOS_UPDATER_ABORT;
} else {
ret = (r > 0 ? MGOS_UPDATER_PROCESS_FILE : MGOS_UPDATER_SKIP_FILE);
}
}
if (ret == MGOS_UPDATER_SKIP_FILE) {
DBG(("Skipping %s %.*s", fi->name, (int) part_name.len, part_name.p));
}
return ret;
}
int mgos_upd_file_data(struct mgos_upd_hal_ctx *ctx,
const struct mgos_upd_file_info *fi,
struct mg_str data) {
_i32 r = sl_FsWrite(ctx->cur_fh, fi->processed, (_u8 *) data.p, data.len);
if (r != data.len) {
ctx->status_msg = "Write failed";
r = -1;
}
return r;
}