}
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
-void PrintHelp(char *buffer)
+int PrintError(char *buffer, const char *message, int buf_size)
{
- strcat(buffer, "\nLZMA Utility " MY_VERSION_COPYRIGHT_DATE "\n"
- "\nUsage: lzma <e|d> inputFile outputFile\n"
- " e: encode file\n"
- " d: decode file\n");
-}
-
-int PrintError(char *buffer, const char *message)
-{
- strcat(buffer, "\nError: ");
- strcat(buffer, message);
- strcat(buffer, "\n");
+ snprintf(buffer + strlen(buffer), buf_size - strlen(buffer),
+ "\nError: %s\n", message);
return 1;
}
-int PrintErrorNumber(char *buffer, SRes val)
+int PrintErrorNumber(char *buffer, SRes val, int buf_size)
{
- sprintf(buffer + strlen(buffer), "\nError code: %x\n", (unsigned)val);
+ snprintf(buffer + strlen(buffer), buf_size - strlen(buffer),
+ "\nError code: %x\n", (unsigned)val);
return 1;
}
-int PrintUserError(char *buffer)
+int PrintUserError(char *buffer, int buf_size)
{
- return PrintError(buffer, "Incorrect command");
+ return PrintError(buffer, "Incorrect command", buf_size);
}
#define IN_BUF_SIZE (1 << 16)
return res;
}
-int main2(int numArgs, const char *args[], char *rs)
+int main2(int numArgs, const char *args[], char *rs, int rs_size)
{
CFileSeqInStream inStream;
CFileOutStream outStream;
size_t t4 = sizeof(UInt32);
size_t t8 = sizeof(UInt64);
if (t4 != 4 || t8 != 8)
- return PrintError(rs, "Incorrect UInt32 or UInt64");
+ return PrintError(rs, "Incorrect UInt32 or UInt64", rs_size);
if (InFile_Open(&inStream.file, "temp_patch") != 0)
- return PrintError(rs, "Can not open input file");
+ return PrintError(rs, "Can not open input file", rs_size);
if (OutFile_Open(&outStream.file, args[3]) != 0)
- return PrintError(rs, "Can not open output file");
+ return PrintError(rs, "Can not open output file", rs_size);
UInt64 fileSize;
if (res != SZ_OK) {
if (res == SZ_ERROR_MEM)
- return PrintError(rs, kCantAllocateMessage);
+ return PrintError(rs, kCantAllocateMessage, rs_size);
else if (res == SZ_ERROR_DATA)
- return PrintError(rs, kDataErrorMessage);
+ return PrintError(rs, kDataErrorMessage, rs_size);
else if (res == SZ_ERROR_WRITE)
- return PrintError(rs, kCantWriteMessage);
+ return PrintError(rs, kCantWriteMessage, rs_size);
else if (res == SZ_ERROR_READ)
- return PrintError(rs, kCantReadMessage);
- return PrintErrorNumber(rs, res);
+ return PrintError(rs, kCantReadMessage, rs_size);
+ return PrintErrorNumber(rs, res, rs_size);
}
return 0;
}
if (ret != 0)
err(1, "bsdiff fails to create delta within timelimit");
#endif
- int res = main2(numArgs, args, rs);
+ int res = main2(numArgs, args, rs, sizeof(rs));
remove("temp_patch");
fputs(rs, stdout);
return res;
const char *kCantAllocateMessage = "Can not allocate memory";
const char *kDataErrorMessage = "Data error";
-void PrintHelp(char *buffer)
+int PrintError(char *buffer, const char *message, int buf_size)
{
- strcat(buffer, "\nLZMA Utility " MY_VERSION_COPYRIGHT_DATE "\n"
- "\nUsage: lzma <e|d> inputFile outputFile\n"
- " e: encode file\n"
- " d: decode file\n");
-}
-
-int PrintError(char *buffer, const char *message)
-{
- strcat(buffer, "\nError: ");
- strcat(buffer, message);
- strcat(buffer, "\n");
+ snprintf(buffer + strlen(buffer), buf_size - strlen(buffer),
+ "\nError: %s\n", message);
return 1;
}
-int PrintErrorNumber(char *buffer, SRes val)
+int PrintErrorNumber(char *buffer, SRes val, int buf_size)
{
- sprintf(buffer + strlen(buffer), "\nError code: %x\n", (unsigned)val);
+ snprintf(buffer + strlen(buffer), buf_size - strlen(buffer),
+ "\nError code: %x\n", (unsigned)val);
return 1;
}
-int PrintUserError(char *buffer)
+int PrintUserError(char *buffer, int buf_size)
{
- return PrintError(buffer, "Incorrect command");
+ return PrintError(buffer, "Incorrect command", buf_size);
}
-int main2(int numArgs, const char *args[], char *rs)
+int main2(int numArgs, const char *args[], char *rs, int rs_size)
{
CFileSeqInStream inStream;
CFileOutStream outStream;
size_t t4 = sizeof(UInt32);
size_t t8 = sizeof(UInt64);
if (t4 != 4 || t8 != 8)
- return PrintError(rs, "Incorrect UInt32 or UInt64");
+ return PrintError(rs, "Incorrect UInt32 or UInt64", rs_size);
if (InFile_Open(&inStream.file, args[3]) != 0)
- return PrintError(rs, "Can not open input file");
- else if (encodeMode)
- PrintUserError(rs);
+ return PrintError(rs, "Can not open input file", rs_size);
if (encodeMode) {
UInt64 fileSize;
if (apply_patch(args[1], buf_res, &new_data, &new_size) != 0) {
if (new_data){
free(new_data);
- free(buf_res);
}
return 1;
}
free(new_data);
free(buf_res);
if (res == SZ_ERROR_MEM)
- return PrintError(rs, kCantAllocateMessage);
+ return PrintError(rs, kCantAllocateMessage, rs_size);
else if (res == SZ_ERROR_DATA)
- return PrintError(rs, kDataErrorMessage);
+ return PrintError(rs, kDataErrorMessage, rs_size);
else if (res == SZ_ERROR_WRITE)
- return PrintError(rs, kCantWriteMessage);
+ return PrintError(rs, kCantWriteMessage, rs_size);
else if (res == SZ_ERROR_READ)
- return PrintError(rs, kCantReadMessage);
- return PrintErrorNumber(rs, res);
+ return PrintError(rs, kCantReadMessage, rs_size);
+ return PrintErrorNumber(rs, res, rs_size);
}
free(new_data);
free(buf_res);
char rs[800] = { 0 };
if (numArgs != 4)
errx(1,"ss_bspatch Version 1.0\nUsage: ss_bspatch oldfile newfile patchfile\n");
- int res = main2(numArgs, args, rs);
+ int res = main2(numArgs, args, rs, sizeof(rs));
fputs(rs, stdout);
return res;
}
ISeqOutStream outStream;
unsigned char *buf_res = NULL;
unsigned char *new_data = NULL;
+ char buf[256];
ssize_t new_size = 0;
int result = E_SS_FAILURE;
result = (sink(new_data, new_size, token) < new_size) ? E_SS_FAILURE : S_SS_SUCCESS;
if (result != S_SS_SUCCESS) {
- LOGE("short write of output: %d (%s)\n", errno, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("short write of output: %d (%s)\n", errno, buf);
goto Cleanup;
}
va_list list;
va_start(list, aFormat);
- vsprintf(temp, aFormat, list);
+ vsnprintf(temp, sizeof(temp), aFormat, list);
va_end(list);
LOGL(LOG_SSENGINE, "%s", temp);
unsigned long bpuaStatus;
};
-void SS_unicode_to_char(const char *src, char *dest);
+void SS_unicode_to_char(const char *src, char *dest, int size);
* limitations under the License.
*/
-#define _XOPEN_SOURCE 500
+#define _XOPEN_SOURCE 600
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
}
-void SS_unicode_to_char(const char *src, char *dest)
+void SS_unicode_to_char(const char *src, char *dest, int size)
{
if (src == NULL) {
return;
}
- strcpy(dest, src);
+ strncpy(dest, src, size);
}
-void SS_char_to_unicode(const char *src, char *dest)
+void SS_char_to_unicode(const char *src, char *dest, int size)
{
if (src == NULL) {
return;
}
- strcpy(dest, src);
+ strncpy(dest, src, size);
}
long SS_recursive_folder_creater(const char *path, const mode_t mode)
return -1;
}
- SS_unicode_to_char((const char *)strFromPath, (char *)path1);
- SS_unicode_to_char((const char *)strToPath, (char *)path2);
+ SS_unicode_to_char((const char *)strFromPath, (char *)path1, MAX_PATH - 1);
+ SS_unicode_to_char((const char *)strToPath, (char *)path2, MAX_PATH - 1);
//LOGL(LOG_SSENGINE, "%s -> %s \n", path1, path2);
char path[MAX_PATH] = { '\0' };
int ret = 0;
- SS_unicode_to_char((const char *)strPath, (char *)path);
+ SS_unicode_to_char((const char *)strPath, (char *)path, MAX_PATH - 1);
//LOGL(LOG_SSENGINE, "%s\n", path);
ret = unlink(path);
if (ret == 0)
int ret = 0;
char path[MAX_PATH] = { '\0' };
- SS_unicode_to_char((const char *)strPath, (char *)path);
+ SS_unicode_to_char((const char *)strPath, (char *)path, MAX_PATH - 1);
//LOGL(LOG_SSENGINE, "%s\n", path);
ret = rmdir(path);
if ((ret == 0)
int ret = 0;
char path[MAX_PATH] = { '\0' };
- SS_unicode_to_char((const char *)strPath, (char *)path);
+ SS_unicode_to_char((const char *)strPath, (char *)path, MAX_PATH - 1);
mode = S_IRUSR /*Read by owner */ |
S_IWUSR /*Write by owner */ |
S_IXUSR /*Execute by owner */ |
mode_t mode;
char path[MAX_PATH] = { '\0' };
- SS_unicode_to_char((const char *)strPath, (char *)path);
+ SS_unicode_to_char((const char *)strPath, (char *)path, MAX_PATH - 1);
mode = SS_get_mode(wFlag);
//LOGL(LOG_SSENGINE, "Path:%s wFlag:%d Mode:%d\n", path, wFlag, mode);
dir[i + 1] = '\0';
SS_char_to_unicode((const char *)dir,
- (char *)dirShort);
+ (char *)dirShort, MAX_PATH - 1);
if (SS_CreateFolder(pbUserData, dirShort)) {
LOGE(" Fail create folder, Leave SS_OpenFile\n");
return -1; //should never happen
}
- SS_unicode_to_char(strFromPath, (char *)path1);
- SS_unicode_to_char(strToPath, (char *)path2);
+ SS_unicode_to_char(strFromPath, (char *)path1, MAX_PATH - 1);
+ SS_unicode_to_char(strToPath, (char *)path2, MAX_PATH - 1);
LOGL(LOG_INFO, "entered path1:%s | path2:%s\n", path1, path2);
ret = stat(path1, &sbuf);
//enumFileType fileType = FT_REGULAR_FILE;
- SS_unicode_to_char((const char *)pLinkName, (char *)path);
+ SS_unicode_to_char((const char *)pLinkName, (char *)path, MAX_PATH - 1);
ret = unlink(path);
if (ret < 0 && errno != ENOENT) {
char refpath[MAX_PATH] = { '\0' };
- SS_unicode_to_char((const char *)pLinkName, (char *)path);
- SS_unicode_to_char((const char *)pReferenceFileName, (char *)refpath);
+ SS_unicode_to_char((const char *)pLinkName, (char *)path, MAX_PATH - 1);
+ SS_unicode_to_char((const char *)pReferenceFileName, (char *)refpath, MAX_PATH - 1);
ret = readlink(path, linkedpath, MAX_PATH);
if (ret < 0) {
//enumFileType fileType = FT_SYMBOLIC_LINK;
struct stat sbuf;
- SS_unicode_to_char((const char *)pLinkName, (char *)sympath);
- SS_unicode_to_char((const char *)pReferenceFileName, (char *)refpath);
+ SS_unicode_to_char((const char *)pLinkName, (char *)sympath, MAX_PATH - 1);
+ SS_unicode_to_char((const char *)pReferenceFileName, (char *)refpath, MAX_PATH - 1);
ret = symlink(refpath, sympath);
if (ret != 0) {
struct stat sbuf;
//LOGL(LOG_SSENGINE, "\n");
- SS_unicode_to_char((const char *)pLinkName, (char *)path);
+ SS_unicode_to_char((const char *)pLinkName, (char *)path, MAX_PATH - 1);
ret = lstat(path, &sbuf);
if (ret < 0) {
static char tmpSmackAttribs[512];
char *tp;
char *endstr;
+ char *saveptr;
char *smack_value, *psmack;
uid_t setUserID = 0;
gid_t setGroupID = 0;
return S_SS_SUCCESS;
}
- SS_unicode_to_char((const char *)ui16pFilePath, (char *)setFilePath);
+ SS_unicode_to_char((const char *)ui16pFilePath, (char *)setFilePath, MAX_PATH - 1);
ret = lstat(setFilePath, &sbuf);
if (ret < 0) {
memset(tmpAttribs, 0x0, sizeof(tmpAttribs));
memcpy(tmpAttribs, ui8pAttribs, (size_t) ui32AttribSize-1);
smack_attr_pos = tmpAttribs;
- tp = strtok(tmpAttribs, attrDelim);
+ tp = strtok_r(tmpAttribs, attrDelim, &saveptr);
// Get FileMode
if (tp != NULL) {
smack_attr_pos += strlen(tp);
smack_attr_pos++;
setFileMode = strtol(tp, &endstr, 8);
- tp = strtok(NULL, attrDelim);
+ tp = strtok_r(NULL, attrDelim, &saveptr);
}
// Get UserID
if (tp != NULL) {
smack_attr_pos += strlen(tp);
smack_attr_pos++;
setUserID = (uid_t) strtol(tp, &endstr, 10);
- tp = strtok(NULL, attrDelim);
+ tp = strtok_r(NULL, attrDelim, &saveptr);
}
// Get GroupID
if (tp != NULL) {
if(psmack) {
memset(tmpSmackAttribs, 0x0, sizeof(tmpSmackAttribs));
memcpy(tmpSmackAttribs, psmack, strlen(psmack));
- smack_value = strtok(tmpSmackAttribs, "\"");
+ smack_value = strtok_r(tmpSmackAttribs, "\"", &saveptr);
if (smack_value) {
- smack_value = strtok(NULL, "\"");
+ smack_value = strtok_r(NULL, "\"", &saveptr);
//LOGL(LOG_SSENGINE, "[SMACK_LABEL_ACCESS] smack_value=%s\n", smack_value);
if(smack_value) {
ret = smack_lsetlabel(setFilePath, smack_value, SMACK_LABEL_ACCESS);
if(psmack) {
memset(tmpSmackAttribs, 0x0, sizeof(tmpSmackAttribs));
memcpy(tmpSmackAttribs, psmack, strlen(psmack));
- smack_value = strtok(tmpSmackAttribs, "\"");
+ smack_value = strtok_r(tmpSmackAttribs, "\"", &saveptr);
if (smack_value) {
- smack_value = strtok(NULL, "\"");
+ smack_value = strtok_r(NULL, "\"", &saveptr);
//LOGL(LOG_SSENGINE, "[SMACK_LABEL_EXEC] smack_value=%s\n", smack_value);
if(smack_value) {
ret = smack_lsetlabel(setFilePath, smack_value, SMACK_LABEL_EXEC);
if(psmack) {
memset(tmpSmackAttribs, 0x0, sizeof(tmpSmackAttribs));
memcpy(tmpSmackAttribs, psmack, strlen(psmack));
- smack_value = strtok(tmpSmackAttribs, "\"");
+ smack_value = strtok_r(tmpSmackAttribs, "\"", &saveptr);
if (smack_value) {
- smack_value = strtok(NULL, "\"");
+ smack_value = strtok_r(NULL, "\"", &saveptr);
//LOGL(LOG_SSENGINE, "[SMACK_LABEL_MMAP] smack_value=%s\n", smack_value);
if(smack_value) {
ret = smack_lsetlabel(setFilePath, smack_value, SMACK_LABEL_MMAP);
if(psmack) {
memset(tmpSmackAttribs, 0x0, sizeof(tmpSmackAttribs));
memcpy(tmpSmackAttribs, psmack, strlen(psmack));
- smack_value = strtok(tmpSmackAttribs, "\"");
+ smack_value = strtok_r(tmpSmackAttribs, "\"", &saveptr);
if (smack_value) {
- smack_value = strtok(NULL, "\"");
+ smack_value = strtok_r(NULL, "\"", &saveptr);
//LOGL(LOG_SSENGINE, "[SMACK_LABEL_TRANSMUTE] smack_value=%s\n", smack_value);
if(smack_value) {
if (strcasecmp(smack_value, "TRUE")==0) {
}
if (feature_support_capability) {
+ char buf[256];
if (has_cap) {
if (setxattr(setFilePath, "security.capability", (void*)cap_raw, cap_len, 0) < 0) {
- LOGL(LOG_SSENGINE, "cap setxattr() failed: %s\n", strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGL(LOG_SSENGINE, "cap setxattr() failed: %s\n", buf);
}
}
if (has_acl) {
if (setxattr(setFilePath, "system.posix_acl_access", (void*)acl_raw, acl_len, 0) < 0) {
- LOGL(LOG_SSENGINE, "Acl setxattr() failed: %s\n", strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGL(LOG_SSENGINE, "Acl setxattr() failed: %s\n", buf);
}
//LOG("Acl setxattr() :")asfd
}
int result = 0;
char path[MAX_PATH] = { '\0' };
- SS_unicode_to_char(partition_name, (char *)path);
+ SS_unicode_to_char(partition_name, (char *)path, MAX_PATH - 1);
//LOGL(LOG_SSENGINE, "Enter %s path=%s\n", __func__, path);
struct statfs vfs;
ssize_t ss_fileSink(unsigned char *data, ssize_t len, void *token)
{
int ss_fd = *(int *)token;
+ char buf[256];
ssize_t done = 0;
ssize_t wrote;
while (done < (ssize_t) len) {
if (wrote <= 0) {
if (errno == EINTR || errno == EAGAIN)
continue; // try again
- LOGE("error writing %d bytes: %s\n", (int)(len - done), strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("error writing %d bytes: %s\n", (int)(len - done), buf);
return done;
}
done += wrote;
size_t read = 0;
FILE *dev = NULL;
int i;
+ char buf[256];
dev = fopen(filename, "rb");
if (dev == NULL) {
- LOGE("failed to open partition \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to open partition \"%s\": %s\n", filename, buf);
return -1;
}
int SS_LoadFile(const char *filename, FileInfo * file)
{
+ char buf[256];
file->data = NULL;
//LOGL(LOG_SSENGINE,"SS_LoadFile --- [File name %s]\n",filename);
if (stat(filename, &file->st) != 0) {
- LOGE("failed to stat \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to stat \"%s\": %s\n", filename, buf);
return -1;
}
file->size = file->st.st_size;
file->data = SS_Malloc(file->size);
if (!file->data) {
- LOGE("failed to allocate memory for \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to allocate memory for \"%s\": %s\n", filename, buf);
return -1;
}
FILE *f = fopen(filename, "rb");
if (f == NULL) {
- LOGE("failed to open \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to open \"%s\": %s\n", filename, buf);
SS_Free(file->data);
file->data = NULL;
return -1;
char *outname = NULL;
int backupsrc = -1;
int result = 0;
+ char buf[256];
FileInfo source_file;
uint8_t source_sha1[SHA_DIGEST_SIZE] = { 0, };
if (SS_LoadFile(SS_BACKUP_SOURCE, &source_file) == 0) {
if (memcmp(source_file.sha1, source_sha1, SHA_DIGEST_SIZE) == 0) {
if (SS_CopyFile(NULL, SS_BACKUP_SOURCE, source_filename) != S_SS_SUCCESS) {
- LOGE("copy of backup to \"%s\" failed: %s\n", source_filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("copy of backup to \"%s\" failed: %s\n", source_filename, buf);
SS_SetUpgradeState(E_SS_FSUPDATEFAILED);
if (source_file.data)
SS_Free(source_file.data);
outname = (char *)SS_Malloc(strlen(target_filename) + 10);
if (outname == NULL)
return -1;
- strcpy(outname, target_filename);
- strcat(outname, ".patch");
+ snprintf(outname, strlen(target_filename) + 10,
+ "%s.patch", target_filename);
output = open(outname, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (output < 0) {
*dir_path = '/';
output = open(outname, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (output < 0) {
- LOGE("failed to open output file %s: %s\n", outname, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to open output file %s: %s\n", outname, buf);
SS_Free(outname);
return E_SS_FAILURE;
}
LOGE("applying patch failed; retrying\n");
SS_Free(outname);//wgid: 20739
}
- if (outname != NULL) {
- unlink(outname);
- }
} else {
// succeeded; no need to retry
break;
// Finally, rename the .patch file to replace the target file.
#ifdef ENHANCED_BSDIFF
if (SS_rename1(outname, target_filename) != 0) {
- LOGE("rename of .patch to \"%s\" failed: %s\n", target_filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("rename of .patch to \"%s\" failed: %s\n", target_filename, buf);
SS_SetUpgradeState(E_SS_FSUPDATEFAILED);
if (outname != NULL) {
SS_Free(outname);
}
#else
if (rename(outname, target_filename) != 0) {
- LOGE("rename of .patch to \"%s\" failed: %s\n", target_filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("rename of .patch to \"%s\" failed: %s\n", target_filename, buf);
SS_SetUpgradeState(E_SS_FSUPDATEFAILED);
if (outname != NULL) {
SS_Free(outname);
int use_backup_img = -1;
FILE *fp = NULL, *wp = NULL, *kp = NULL;
int i = 0, j = 0, file_len = 0;
- char *magic = NULL, *file_name = NULL, *buf = NULL, a = '0';
+ char *magic = NULL, *file_name = NULL, *tok_buf = NULL, *buf = NULL, a = '0';
+ char *saveptr;
+ char err_buf[256];
char cmd[1024] = { 0, };
char source_filename[MAX_FILE_PATH] = { 0, };
char part_filename[MAX_FILE_PATH] = { 0, };
ssize_t bytes_read = fread(buf, 1, SS_KERNEL_DELTA_HEADER, fp);
if (bytes_read != SS_KERNEL_DELTA_HEADER)
LOGL(LOG_SSENGINE, "short read of \"%s\" (%ld bytes of %ld)\n", SS_PATCHFILE_SOURCE, (long)bytes_read, (long)SS_KERNEL_DELTA_HEADER);
- magic = strtok(buf, ":");
+ magic = strtok_r(buf, ":", &saveptr);
LOGL(LOG_SSENGINE, "magic: %s\n", magic);
- file_num = atoi(strtok(NULL, ":"));
+ tok_buf = strtok_r(NULL, ":", &saveptr);
+ if (tok_buf)
+ file_num = atoi(tok_buf);
//adjust offset to start of data section before proceeding
fseek(fp, SS_KERNEL_DELTA_HEADER, SEEK_SET);
while (file_num-- > 0) {
- file_name = strtok(NULL, ":");
- file_len = atoi(strtok(NULL, ":"));
+ file_name = strtok_r(NULL, ":", &saveptr);
+ tok_buf = strtok_r(NULL, ":", &saveptr);
+ if (tok_buf)
+ file_len = atoi(tok_buf);
j = file_len;
snprintf(source_filename, sizeof(source_filename) - 1, "%s/%s_unpacked/%s", SS_KERNEL_WORKSPACE, SS_KERNEL_NAME,
file_name);
result = E_SS_FAILURE;
goto Cleanup;
}
- strcpy(outname, source_filename);
- strcat(outname, ".patch");
+ snprintf(outname, strlen(source_filename) + 10, "%s.patch",
+ source_filename);
output = open(outname, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (output < 0) {
- LOGE("failed to open output file %s: %s\n", outname, strerror(errno));
- SS_Free(outname);
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ LOGE("failed to open output file %s: %s\n", outname, err_buf);
result = E_SS_FAILURE;
goto Cleanup;
}
LOGE("fatal error %s\n", source_filename);
goto Cleanup;
}
- if (strcmp(file_name, "piggy") == 0) {
+ if (file_name && strcmp(file_name, "piggy") == 0) {
snprintf(cmd, sizeof(cmd) - 1,
"%s/gzip -n -9 -c %s/%s/%s > %s/%s/%s.gz",
SS_KERNEL_WORKSPACE, SS_KERNEL_WORKSPACE, SS_KERNEL_UNPACK_DIR, file_name,
fseek(wp, SEEK_SET, SEEK_SET);
while (j-- > 0) {
a = fgetc(wp);
- if(a != EOF)//wgid: 4428
+ if(a != EOF)
fputc(a, kp);
else
break;
int backupsrc = -1;
int use_backup_img = -1;
int fd = -1;
+ char buf[256];
if (ParseSha1(ua_dataSS->update_cfg->target_sha1, target_sha1) != 0) {
LOGE("failed to parse tgt-sha1 \"%s\"\n", ua_dataSS->update_cfg->target_sha1);
return E_SS_FAILURE;
} else if (ua_dataSS->update_cfg->update_type == EXTRA && ua_dataSS->update_data->ua_temp_path) {
fd = open(ua_dataSS->update_data->ua_temp_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
if (fd < 0) {
- LOGE("failed to open %s for write: %s\n", ua_dataSS->update_data->ua_temp_path, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to open %s for write: %s\n", ua_dataSS->update_data->ua_temp_path, buf);
SS_SetUpgradeState(E_SS_IMGRECOVERYWRITEFAILED);
result = E_SS_FAILURE;
goto Cleanup;
FILE *fp = NULL;
int ulResult = S_SS_SUCCESS;
int chunk = 20*1024*1024;
+ char buf[256];
fp = fopen(filename, "rb");
if (fp == NULL) {
- LOGE("failed to open \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to open \"%s\": %s\n", filename, buf);
ulResult = E_SS_FAILURE;
goto Cleanup;
}
file->data = SS_Malloc(chunk);
if (!file->data) {
- LOGE("failed to allocate memory for \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to allocate memory for \"%s\": %s\n", filename, buf);
ulResult = E_SS_FAILURE;
goto Cleanup;
}
char * delta_size = NULL;
char *signature = NULL;
char * sha1trg = NULL;
+ char *saveptr;
uint8_t target_sha1[SHA_DIGEST_SIZE] = { 0, };
char cmd[512] = { 0, };
+ char buf[256];
int udelta_size = 0;
int ulResult = S_SS_SUCCESS;
if (stat(filename, &file.st) != 0) {
- LOGE("failed to stat \"%s\": %s\n", filename, strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("failed to stat \"%s\": %s\n", filename, buf);
return -1;
}
fclose(fp);
fp = NULL;
- signature = strtok(line, SS_TOEKN_COLON);
- delta_size = strtok(NULL, SS_TOEKN_COLON);
- sha1trg = strtok(NULL, SS_TOEKN_COLON);
+ signature = strtok_r(line, SS_TOEKN_COLON, &saveptr);
+ delta_size = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ sha1trg = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
if (signature && sha1trg && delta_size) {
udelta_size = atoi(delta_size);
+ if (udelta_size < 0)
+ LOGE("Invalid udelta_size %d (%s)\n", udelta_size, delta_size);
LOGL(LOG_SSENGINE, "delta_size %d sha1trg %s\n", udelta_size, sha1trg);
}
else {
temp_name = (char *)SS_Malloc(strlen(new_file_name) + 10);
if (temp_name == NULL)
return E_SS_FAILURE;
- strcpy(temp_name, new_file_name);
- strcat(temp_name, ".temp");
+ snprintf(temp_name, strlen(new_file_name) + 10, "%s.temp", new_file_name);
result = rename(new_file_name, temp_name);
if (result != 0)
goto Cleanup;
char *FileData = NULL;
int data_size = -1;
char *line = NULL;
+ char *saveptr;
+ char buf[256];
struct details *refer_copy = NULL;
FILE *filename_bkup = NULL;
}
filename_bkup = fopen(SS_PATCHLIST_BKUPLOC, "wb+");
if (filename_bkup == NULL) {
- LOGE("Failed to create BACKUP file Error:[%s]\n", strerror(errno));
+ strerror_r(errno, buf, sizeof(buf));
+ LOGE("Failed to create BACKUP file Error:[%s]\n", buf);
SS_SetUpgradeState(E_SS_FSFAILEDTOBACKUPPATCHINFO);
ret = 0;
goto cleanup;
if (line) {
LOGL(LOG_SSENGINE, "SS_FSGetDeltaCount() last line %s \n", line);
- token = strtok(&line[SS_FSCOUNT_MAGIG_KEYLEN], SS_TOKEN_SPACE);
+ token = strtok_r(&line[SS_FSCOUNT_MAGIG_KEYLEN], SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->diffs = atoi(token);
else {
ret = 0;
goto cleanup;
}
- token = strtok(NULL, SS_TOKEN_SPACE);
+ token = strtok_r(NULL, SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->moves = atoi(token);
else {
goto cleanup;
}
- token = strtok(NULL, SS_TOKEN_SPACE);
+ token = strtok_r(NULL, SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->news = atoi(token);
else {
goto cleanup;
}
- token = strtok(NULL, SS_TOKEN_SPACE);
+ token = strtok_r(NULL, SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->deletes = atoi(token);
else {
goto cleanup;
}
- token = strtok(NULL, SS_TOKEN_SPACE);
+ token = strtok_r(NULL, SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->symdiffs = atoi(token);
else {
goto cleanup;
}
- token = strtok(NULL, SS_TOKEN_SPACE);
+ token = strtok_r(NULL, SS_TOKEN_SPACE, &saveptr);
if (token)
refer_copy->symnews = atoi(token);
else {
char *sha1trg = NULL;
char *change_type = NULL;
char *file_type = NULL;
+ char *saveptr;
uint32_t ulPatchCount = 0, del_type = DELETES;
fs_params *fs_diffhead = NULL;
fs_params *fs_difftail = NULL;
}
//LOGL(LOG_SSENGINE, "DIFF LINE:[%d] [%s] \n",i+1,line);
- change_type = strtok(line, SS_TOEKN_COLON);
- file_type = strtok(NULL, SS_TOEKN_COLON);
+ change_type = strtok_r(line, SS_TOEKN_COLON, &saveptr);
+ file_type = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
- if (strcmp(change_type, SS_STRING_MOVE) == 0) { // && strcmp(file_type,"TPK") == 0){
- source_name = strtok(NULL, SS_TOEKN_COLON);
- target_name = strtok(NULL, SS_TOEKN_COLON);
- sha1src = strtok(NULL, SS_TOKEN_NEWLINE);
+ if (change_type && strcmp(change_type, SS_STRING_MOVE) == 0) { // && strcmp(file_type,"TPK") == 0){
+ source_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ target_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ sha1src = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
//LOGL(LOG_SSENGINE, "%s Index [%d]\n", SS_STRING_MOVE, i);
if (!source_name || !target_name || !sha1src) {
if (retval == E_SS_FAILURE) // ONLY test purpose, should enable this
goto CleanUp;
SS_UpdateUIProgress(ua_dataSS, ulPatchCount, 0);
- } else if (strcmp(change_type, SS_STRING_DIFF) == 0) { // && strcmp(file_type,"TPK") == 0){
- source_name = strtok(NULL, SS_TOEKN_COLON);
- target_name = strtok(NULL, SS_TOEKN_COLON);
- sha1src = strtok(NULL, SS_TOEKN_COLON);
- sha1trg = strtok(NULL, SS_TOEKN_COLON);
- patch_name = strtok(NULL, SS_TOKEN_NEWLINE);
+ } else if (change_type && strcmp(change_type, SS_STRING_DIFF) == 0) { // && strcmp(file_type,"TPK") == 0){
+ source_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ target_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ sha1src = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ sha1trg = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ patch_name = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
//LOGL(LOG_SSENGINE, "%s Index [%d]\n", SS_STRING_DIFF, i);
- if (strlen(patch_name) <= SS_MAX_NAMELENSUPPORTED) {
+ if (patch_name && (strlen(patch_name) <= SS_MAX_NAMELENSUPPORTED)) {
retval =
SS_AppendNode(ua_dataSS->update_data->ua_delta_path, &fs_diffhead, &fs_difftail,
source_name, target_name, patch_name, sha1src, sha1trg, DIFFS,
break;
}
- change_type = strtok(line, SS_TOEKN_COLON);
- file_type = strtok(NULL, SS_TOEKN_COLON);
+ change_type = strtok_r(line, SS_TOEKN_COLON, &saveptr);
+ file_type = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
- if (strcmp(file_type, SS_STRING_REG) == 0) {
- source_name = strtok(NULL, SS_TOEKN_COLON);
- sha1src = strtok(NULL, SS_TOKEN_NEWLINE);
+ if (file_type && strcmp(file_type, SS_STRING_REG) == 0) {
+ source_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ sha1src = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
del_type = DELETES;
- } else if (strcmp(file_type, SS_STRING_SYM) == 0) {
- source_name = strtok(NULL, SS_TOKEN_NEWLINE);
+ } else if (file_type && strcmp(file_type, SS_STRING_SYM) == 0) {
+ source_name = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
sha1src = string_na;
del_type = DELETES;
- } else if (strcmp(file_type, SS_STRING_END) == 0) {
- source_name = strtok(NULL, SS_TOKEN_NEWLINE);
+ } else if (file_type && strcmp(file_type, SS_STRING_END) == 0) {
+ source_name = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
sha1src = string_na;
del_type = DELETE_END;
}
}
//LOGL(LOG_SSENGINE, "SYMDIFF LINE:[%d] [%s] \n",i+1,line);
- change_type = strtok(line, SS_TOEKN_COLON);
- file_type = strtok(NULL, SS_TOEKN_COLON);
+ change_type = strtok_r(line, SS_TOEKN_COLON, &saveptr);
+ file_type = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
- if (strcmp(change_type, SS_STRING_SYM) == 0 && strcmp(file_type, SS_STRING_DIFF) == 0) { // && strcmp(file_type,"TPK") == 0){
- source_name = strtok(NULL, SS_TOEKN_COLON);
- target_name = strtok(NULL, SS_TOEKN_COLON);
- patch_name = strtok(NULL, SS_TOKEN_NEWLINE);
+ if ((change_type && file_type) &&
+ strcmp(change_type, SS_STRING_SYM) == 0 && strcmp(file_type, SS_STRING_DIFF) == 0) { // && strcmp(file_type,"TPK") == 0){
+ source_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ target_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ patch_name = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
//LOGL(LOG_SSENGINE, "%s %s Index [%d]\n", SS_STRING_SYM, SS_STRING_DIFF, i);
if (!source_name || !target_name || !patch_name) {
}
//LOGL(LOG_SSENGINE, "SYMNEWS LINE:[%d] [%s] \n",i+1,line);
- change_type = strtok(line, SS_TOEKN_COLON);
- file_type = strtok(NULL, SS_TOEKN_COLON);
+ change_type = strtok_r(line, SS_TOEKN_COLON, &saveptr);
+ file_type = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
- if (strcmp(change_type, SS_STRING_SYM) == 0 && strcmp(file_type, SS_STRING_NEW) == 0) {
- source_name = strtok(NULL, SS_TOEKN_COLON);
- patch_name = strtok(NULL, SS_TOKEN_NEWLINE);
+ if ((change_type && file_type) &&
+ (strcmp(change_type, SS_STRING_SYM) == 0 && strcmp(file_type, SS_STRING_NEW) == 0)) {
+ source_name = strtok_r(NULL, SS_TOEKN_COLON, &saveptr);
+ patch_name = strtok_r(NULL, SS_TOKEN_NEWLINE, &saveptr);
//LOGL(LOG_SSENGINE, "%s %s Index [%d]\n", SS_STRING_SYM, SS_STRING_NEW, i);
if (!source_name || !patch_name) {
}
while (pline) {
- pfilePath = strtok(pline, "\"");
+ pfilePath = strtok_r(pline, "\"", &psaveptr);
if (pfilePath && strcmp(pfilePath, SS_FWSLASH) == 0) {
LOGE("\n skip root: it is RO");
continue;
}
- pfiletype = strtok(NULL, SS_TOKEN_SPACE);
- attributSize = strtok(NULL, SS_TOKEN_SPACE);
- pattribs = strtok(NULL, SS_TOKEN_NEWLINE);
+ pfiletype = strtok_r(NULL, SS_TOKEN_SPACE, &psaveptr);
+ attributSize = strtok_r(NULL, SS_TOKEN_SPACE, &psaveptr);
+ pattribs = strtok_r(NULL, SS_TOKEN_NEWLINE, &psaveptr);
LOG("\nSS_FSSetAttributes [%s][%s][%s]", pfiletype, attributSize, pattribs);
if (pattribs && pfilePath && pfiletype) {
ulAttribSize = strlen(pattribs);
va_list list;
va_start(list, format_str);
- vsprintf(log_str, format_str, list);
+ vsnprintf(log_str, sizeof(log_str), format_str, list);
va_end(list);
len = strlen(log_str);
}
/* get file name and file size */
- memcpy(name, header, sizeof(name) - 1);//wgid: 24572
+ memcpy(name, header, sizeof(name) - 1);
memcpy(size_oct, header + TAR_ITEM_SIZE_POSITION, sizeof(size_oct));
size_dec = strtoul(size_oct, NULL, TAR_SIZE_OF_ITEM_SIZE);
if (size_dec > MAX_ITEM_SIZE) {
}
/* get file name and file size */
- memcpy(name, header, sizeof(name) - 1);//wgid: 24573
+ memcpy(name, header, sizeof(name) - 1);
memcpy(size_oct, header + TAR_ITEM_SIZE_POSITION, sizeof(size_oct));
size_dec = strtoul(size_oct, NULL, TAR_SIZE_OF_ITEM_SIZE);
if (size_dec > MAX_ITEM_SIZE) {
}
/* get file name and file size */
- memcpy(name, header, sizeof(name) - 1);//wgid: 24574
+ memcpy(name, header, sizeof(name) - 1);
memcpy(size_oct, header + TAR_ITEM_SIZE_POSITION, sizeof(size_oct));
size_dec = strtoul(size_oct, NULL, TAR_SIZE_OF_ITEM_SIZE);
if (size_dec > MAX_ITEM_SIZE) {
memset(name, 0, sizeof(name));
strncpy(name, buff + 157, 100); //157, target link name will be present
memset(dirPath, 0, sizeof(dirPath));
- sprintf(dirPath, "%s/%s", path, fullname + folderpathlen);
+ snprintf(dirPath, sizeof(dirPath), "%s/%s", path, fullname + folderpathlen);
LOG(" Creating Symlink [%s][%s]\n", name, dirPath);
ret = symlink(name, dirPath); // use ss_link
if (ret < 0)
if (strncmp(fullname, item, folderpathlen) == 0) {
//LOG(" Extracting dir %s\n", fullname);
memset(dirPath, 0, sizeof(dirPath));
- sprintf(dirPath, "%s/%s", path, fullname + folderpathlen);
+ snprintf(dirPath, sizeof(dirPath), "%s/%s", path, fullname + folderpathlen);
create_dir(dirPath, parseoct(fullname + 100, 8));
}
memset(name, 0, sizeof(name));
memset(dirPath, 0, sizeof(dirPath));
strncpy(name, buff, 100);
- strcat(name, buff + PREFIX_INDICATOR_BYTE);
- sprintf(dirPath, "%s/%s", path, name + folderpathlen);
+ snprintf(name + strlen(name), sizeof(name) - strlen(name),
+ "%s", buff + PREFIX_INDICATOR_BYTE);
+ snprintf(dirPath, sizeof(dirPath), "%s/%s", path, name + folderpathlen);
LOG(" File Name is longer than 100 bytes -Remaining Str [%s]\n Full Str[%s]", dirPath);
} else {
//LOG(" Extracting file %s\n", fullname);
memset(dirPath, 0, sizeof(dirPath));
- sprintf(dirPath, "%s/%s", path, fullname + folderpathlen);
+ snprintf(dirPath, sizeof(dirPath), "%s/%s", path, fullname + folderpathlen);
f = create_file(dirPath, parseoct(fullname + 100, 8));
}
}
ssize_t rdcnt = 0;
ssize_t writeCount = 0;
char *buf = NULL;
+ char err_buf[256];
int fd2;
if (gTarFd > 0)
writeCount = write(fd2, buf, rdcnt);
if (writeCount != rdcnt) {
LOG("writeCount write fail(%s from %s).\n", item, tar);
- LOG("Oh dear, something went wrong with read()! %s\n", strerror(errno));
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ LOG("Oh dear, something went wrong with read()! %s\n", err_buf);
close(fd);
close(fd2);
SS_Free(buf);
ssize_t rdcnt = 0;
ssize_t writeCount = 0;
char *buf = NULL;
+ char err_buf[256];
int fd2;
data_size = tar_get_item_size(tar, item);
data_offset = tar_get_item_offset(tar, item);
writeCount = write(fd2, buf, rdcnt);
if (writeCount != rdcnt) {
LOG("writeCount write fail(%s from %s).\n", item, tar);
- LOG("Oh dear, something went wrong with read()! %s\n", strerror(errno));
+ strerror_r(errno, err_buf, sizeof(err_buf));
+ LOG("Oh dear, something went wrong with read()! %s\n", err_buf);
close(fd);
close(fd2);
SS_Free(buf);
projects / platform / core / system / libtota.git / commitdiff