2018-11-03 08:06:01 +01:00
|
|
|
/* file.cpp - Contains all files related utilities
|
2017-10-11 20:57:18 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2017-11-15 14:00:52 +01:00
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2017-11-27 08:37:28 +01:00
|
|
|
#include <libgen.h>
|
2017-10-11 20:57:18 +02:00
|
|
|
#include <sys/sendfile.h>
|
2017-11-05 22:41:03 +01:00
|
|
|
#include <sys/mman.h>
|
2017-11-19 20:40:37 +01:00
|
|
|
#include <linux/fs.h>
|
2017-10-14 15:10:22 +02:00
|
|
|
|
2018-06-03 08:43:03 +02:00
|
|
|
#include "magisk.h"
|
2017-10-11 20:57:18 +02:00
|
|
|
#include "utils.h"
|
2018-09-27 06:09:59 +02:00
|
|
|
#include "selinux.h"
|
2017-10-11 20:57:18 +02:00
|
|
|
|
2018-11-03 08:06:01 +01:00
|
|
|
const char **excl_list = nullptr;
|
2017-10-11 20:57:18 +02:00
|
|
|
|
|
|
|
static int is_excl(const char *name) {
|
2017-12-06 20:21:13 +01:00
|
|
|
if (excl_list)
|
|
|
|
for (int i = 0; excl_list[i]; ++i)
|
|
|
|
if (strcmp(name, excl_list[i]) == 0)
|
|
|
|
return 1;
|
2017-10-11 20:57:18 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-27 06:09:59 +02:00
|
|
|
int fd_getpath(int fd, char *path, size_t size) {
|
2017-10-14 15:10:22 +02:00
|
|
|
snprintf(path, size, "/proc/self/fd/%d", fd);
|
2018-09-27 06:09:59 +02:00
|
|
|
return xreadlink(path, path, size) == -1;
|
2018-07-12 23:41:29 +02:00
|
|
|
}
|
|
|
|
|
2018-09-27 06:09:59 +02:00
|
|
|
int fd_getpathat(int dirfd, const char *name, char *path, size_t size) {
|
|
|
|
if (fd_getpath(dirfd, path, size))
|
|
|
|
return 1;
|
|
|
|
snprintf(path, size, "%s/%s", path, name);
|
|
|
|
return 0;
|
2017-10-14 15:10:22 +02:00
|
|
|
}
|
|
|
|
|
2018-01-10 20:06:20 +01:00
|
|
|
int mkdirs(const char *pathname, mode_t mode) {
|
2017-10-11 20:57:18 +02:00
|
|
|
char *path = strdup(pathname), *p;
|
|
|
|
errno = 0;
|
|
|
|
for (p = path + 1; *p; ++p) {
|
|
|
|
if (*p == '/') {
|
|
|
|
*p = '\0';
|
|
|
|
if (mkdir(path, mode) == -1) {
|
|
|
|
if (errno != EEXIST)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*p = '/';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mkdir(path, mode) == -1) {
|
|
|
|
if (errno != EEXIST)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
free(path);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-06 20:21:13 +01:00
|
|
|
void in_order_walk(int dirfd, void (*callback)(int, struct dirent*)) {
|
2017-10-11 20:57:18 +02:00
|
|
|
struct dirent *entry;
|
|
|
|
int newfd;
|
2017-12-15 19:02:17 +01:00
|
|
|
DIR *dir = fdopendir(dirfd);
|
2018-11-03 08:06:01 +01:00
|
|
|
if (dir == nullptr) return;
|
2017-10-11 20:57:18 +02:00
|
|
|
|
2017-10-13 18:08:12 +02:00
|
|
|
while ((entry = xreaddir(dir))) {
|
2017-10-11 20:57:18 +02:00
|
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
|
|
|
|
continue;
|
|
|
|
if (is_excl(entry->d_name))
|
|
|
|
continue;
|
2017-12-06 20:21:13 +01:00
|
|
|
if (entry->d_type == DT_DIR) {
|
2017-10-13 18:08:12 +02:00
|
|
|
newfd = xopenat(dirfd, entry->d_name, O_RDONLY | O_CLOEXEC);
|
2017-12-06 20:21:13 +01:00
|
|
|
in_order_walk(newfd, callback);
|
2017-10-11 20:57:18 +02:00
|
|
|
close(newfd);
|
|
|
|
}
|
2017-12-06 20:21:13 +01:00
|
|
|
callback(dirfd, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rm_cb(int dirfd, struct dirent *entry) {
|
|
|
|
switch (entry->d_type) {
|
|
|
|
case DT_DIR:
|
|
|
|
unlinkat(dirfd, entry->d_name, AT_REMOVEDIR);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
unlinkat(dirfd, entry->d_name, 0);
|
|
|
|
break;
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-06 20:21:13 +01:00
|
|
|
void rm_rf(const char *path) {
|
2017-12-15 19:02:17 +01:00
|
|
|
int fd = open(path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
|
|
|
|
if (fd >= 0) {
|
|
|
|
frm_rf(fd);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
remove(path);
|
2017-12-06 20:21:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void frm_rf(int dirfd) {
|
|
|
|
in_order_walk(dirfd, rm_cb);
|
|
|
|
}
|
|
|
|
|
2017-10-11 20:57:18 +02:00
|
|
|
/* This will only on the same file system */
|
|
|
|
void mv_f(const char *source, const char *destination) {
|
|
|
|
struct stat st;
|
|
|
|
xlstat(source, &st);
|
|
|
|
int src, dest;
|
|
|
|
struct file_attr a;
|
|
|
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2018-01-10 20:06:20 +01:00
|
|
|
xmkdirs(destination, st.st_mode & 0777);
|
2017-10-11 20:57:18 +02:00
|
|
|
src = xopen(source, O_RDONLY | O_CLOEXEC);
|
|
|
|
dest = xopen(destination, O_RDONLY | O_CLOEXEC);
|
|
|
|
fclone_attr(src, dest);
|
|
|
|
mv_dir(src, dest);
|
|
|
|
close(src);
|
|
|
|
close(dest);
|
|
|
|
} else{
|
|
|
|
getattr(source, &a);
|
2017-10-13 18:08:12 +02:00
|
|
|
xrename(source, destination);
|
2017-10-11 20:57:18 +02:00
|
|
|
setattr(destination, &a);
|
|
|
|
}
|
|
|
|
rmdir(source);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This will only on the same file system */
|
|
|
|
void mv_dir(int src, int dest) {
|
|
|
|
struct dirent *entry;
|
|
|
|
DIR *dir;
|
|
|
|
int newsrc, newdest;
|
|
|
|
struct file_attr a;
|
|
|
|
|
2017-10-13 18:08:12 +02:00
|
|
|
dir = xfdopendir(src);
|
|
|
|
while ((entry = xreaddir(dir))) {
|
2017-10-11 20:57:18 +02:00
|
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
|
|
|
|
continue;
|
|
|
|
if (is_excl(entry->d_name))
|
|
|
|
continue;
|
|
|
|
getattrat(src, entry->d_name, &a);
|
|
|
|
switch (entry->d_type) {
|
|
|
|
case DT_DIR:
|
2017-10-13 18:08:12 +02:00
|
|
|
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
|
|
|
|
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
|
|
|
|
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
|
2017-10-11 20:57:18 +02:00
|
|
|
fsetattr(newdest, &a);
|
|
|
|
mv_dir(newsrc, newdest);
|
|
|
|
close(newsrc);
|
|
|
|
close(newdest);
|
|
|
|
unlinkat(src, entry->d_name, AT_REMOVEDIR);
|
|
|
|
break;
|
|
|
|
case DT_LNK:
|
|
|
|
case DT_REG:
|
|
|
|
renameat(src, entry->d_name, dest, entry->d_name);
|
|
|
|
setattrat(dest, entry->d_name, &a);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cp_afc(const char *source, const char *destination) {
|
|
|
|
int src, dest;
|
|
|
|
struct file_attr a;
|
|
|
|
getattr(source, &a);
|
|
|
|
|
|
|
|
if (S_ISDIR(a.st.st_mode)) {
|
2018-01-10 20:06:20 +01:00
|
|
|
xmkdirs(destination, a.st.st_mode & 0777);
|
2017-10-11 20:57:18 +02:00
|
|
|
src = xopen(source, O_RDONLY | O_CLOEXEC);
|
|
|
|
dest = xopen(destination, O_RDONLY | O_CLOEXEC);
|
|
|
|
clone_dir(src, dest);
|
|
|
|
close(src);
|
|
|
|
close(dest);
|
|
|
|
} else{
|
|
|
|
unlink(destination);
|
|
|
|
if (S_ISREG(a.st.st_mode)) {
|
|
|
|
src = xopen(source, O_RDONLY);
|
|
|
|
dest = xopen(destination, O_WRONLY | O_CREAT | O_TRUNC);
|
2018-11-03 08:06:01 +01:00
|
|
|
xsendfile(dest, src, nullptr, a.st.st_size);
|
2017-10-11 20:57:18 +02:00
|
|
|
close(src);
|
|
|
|
close(dest);
|
|
|
|
} else if (S_ISLNK(a.st.st_mode)) {
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
xreadlink(source, buf, sizeof(buf));
|
|
|
|
xsymlink(buf, destination);
|
|
|
|
}
|
|
|
|
}
|
2018-06-16 19:25:27 +02:00
|
|
|
setattr(destination, &a);
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void clone_dir(int src, int dest) {
|
|
|
|
struct dirent *entry;
|
|
|
|
DIR *dir;
|
|
|
|
int srcfd, destfd, newsrc, newdest;
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
struct file_attr a;
|
|
|
|
|
2017-10-13 18:08:12 +02:00
|
|
|
dir = xfdopendir(src);
|
|
|
|
while ((entry = xreaddir(dir))) {
|
2017-10-11 20:57:18 +02:00
|
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
|
|
|
|
continue;
|
|
|
|
if (is_excl(entry->d_name))
|
|
|
|
continue;
|
|
|
|
getattrat(src, entry->d_name, &a);
|
|
|
|
switch (entry->d_type) {
|
|
|
|
case DT_DIR:
|
2017-10-13 18:08:12 +02:00
|
|
|
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
|
2017-10-11 20:57:18 +02:00
|
|
|
setattrat(dest, entry->d_name, &a);
|
2017-10-13 18:08:12 +02:00
|
|
|
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
|
|
|
|
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
|
2017-10-11 20:57:18 +02:00
|
|
|
clone_dir(newsrc, newdest);
|
|
|
|
close(newsrc);
|
|
|
|
close(newdest);
|
|
|
|
break;
|
|
|
|
case DT_REG:
|
2017-10-13 18:08:12 +02:00
|
|
|
destfd = xopenat(dest, entry->d_name, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC);
|
|
|
|
srcfd = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
|
|
|
|
xsendfile(destfd, srcfd, 0, a.st.st_size);
|
2017-10-11 20:57:18 +02:00
|
|
|
fsetattr(destfd, &a);
|
|
|
|
close(destfd);
|
|
|
|
close(srcfd);
|
|
|
|
break;
|
|
|
|
case DT_LNK:
|
2017-10-13 18:08:12 +02:00
|
|
|
xreadlinkat(src, entry->d_name, buf, sizeof(buf));
|
2018-07-12 23:41:29 +02:00
|
|
|
xsymlinkat(buf, dest, entry->d_name);
|
2017-10-11 20:57:18 +02:00
|
|
|
setattrat(dest, entry->d_name, &a);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-01 20:22:38 +01:00
|
|
|
void link_dir(int src, int dest) {
|
|
|
|
struct dirent *entry;
|
|
|
|
DIR *dir;
|
|
|
|
int newsrc, newdest;
|
|
|
|
struct file_attr a;
|
|
|
|
|
|
|
|
dir = xfdopendir(src);
|
|
|
|
while ((entry = xreaddir(dir))) {
|
|
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
|
|
|
|
continue;
|
|
|
|
if (is_excl(entry->d_name))
|
|
|
|
continue;
|
|
|
|
if (entry->d_type == DT_DIR) {
|
|
|
|
getattrat(src, entry->d_name, &a);
|
|
|
|
xmkdirat(dest, entry->d_name, a.st.st_mode & 0777);
|
|
|
|
setattrat(dest, entry->d_name, &a);
|
|
|
|
newsrc = xopenat(src, entry->d_name, O_RDONLY | O_CLOEXEC);
|
|
|
|
newdest = xopenat(dest, entry->d_name, O_RDONLY | O_CLOEXEC);
|
|
|
|
link_dir(newsrc, newdest);
|
|
|
|
close(newsrc);
|
|
|
|
close(newdest);
|
|
|
|
} else {
|
2018-07-12 23:41:29 +02:00
|
|
|
xlinkat(src, entry->d_name, dest, entry->d_name, 0);
|
2018-02-01 20:22:38 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-11 20:57:18 +02:00
|
|
|
int getattr(const char *path, struct file_attr *a) {
|
2017-10-14 15:10:22 +02:00
|
|
|
if (xlstat(path, &a->st) == -1)
|
2017-10-11 20:57:18 +02:00
|
|
|
return -1;
|
2018-09-27 06:09:59 +02:00
|
|
|
char *con;
|
2017-10-14 15:10:22 +02:00
|
|
|
if (lgetfilecon(path, &con) == -1)
|
|
|
|
return -1;
|
|
|
|
strcpy(a->con, con);
|
|
|
|
freecon(con);
|
|
|
|
return 0;
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int getattrat(int dirfd, const char *pathname, struct file_attr *a) {
|
2018-07-12 23:41:29 +02:00
|
|
|
char path[PATH_MAX];
|
|
|
|
fd_getpathat(dirfd, pathname, path, sizeof(path));
|
|
|
|
return getattr(path, a);
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int fgetattr(int fd, struct file_attr *a) {
|
2017-10-14 15:10:22 +02:00
|
|
|
char path[PATH_MAX];
|
|
|
|
fd_getpath(fd, path, sizeof(path));
|
|
|
|
return getattr(path, a);
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int setattr(const char *path, struct file_attr *a) {
|
2017-10-14 15:10:22 +02:00
|
|
|
if (chmod(path, a->st.st_mode & 0777) < 0)
|
2017-10-11 20:57:18 +02:00
|
|
|
return -1;
|
2017-10-14 15:10:22 +02:00
|
|
|
if (chown(path, a->st.st_uid, a->st.st_gid) < 0)
|
|
|
|
return -1;
|
|
|
|
if (strlen(a->con) && lsetfilecon(path, a->con) < 0)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int setattrat(int dirfd, const char *pathname, struct file_attr *a) {
|
2018-07-12 23:41:29 +02:00
|
|
|
char path[PATH_MAX];
|
|
|
|
fd_getpathat(dirfd, pathname, path, sizeof(path));
|
|
|
|
return setattr(path, a);
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int fsetattr(int fd, struct file_attr *a) {
|
2017-10-14 15:10:22 +02:00
|
|
|
char path[PATH_MAX];
|
|
|
|
fd_getpath(fd, path, sizeof(path));
|
|
|
|
return setattr(path, a);
|
2017-10-11 20:57:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void clone_attr(const char *source, const char *target) {
|
|
|
|
struct file_attr a;
|
|
|
|
getattr(source, &a);
|
|
|
|
setattr(target, &a);
|
|
|
|
}
|
|
|
|
|
|
|
|
void fclone_attr(const int sourcefd, const int targetfd) {
|
|
|
|
struct file_attr a;
|
|
|
|
fgetattr(sourcefd, &a);
|
|
|
|
fsetattr(targetfd, &a);
|
|
|
|
}
|
2017-10-11 21:39:39 +02:00
|
|
|
|
2018-08-09 12:13:07 +02:00
|
|
|
static void _mmap(int rw, const char *filename, void **buf, size_t *size) {
|
2017-11-19 20:40:37 +01:00
|
|
|
struct stat st;
|
2018-04-14 21:18:18 +02:00
|
|
|
int fd = xopen(filename, (rw ? O_RDWR : O_RDONLY) | O_CLOEXEC);
|
2017-12-06 05:51:16 +01:00
|
|
|
fstat(fd, &st);
|
2017-11-19 20:40:37 +01:00
|
|
|
if (S_ISBLK(st.st_mode))
|
|
|
|
ioctl(fd, BLKGETSIZE64, size);
|
|
|
|
else
|
|
|
|
*size = st.st_size;
|
2018-11-03 08:06:01 +01:00
|
|
|
*buf = *size > 0 ? xmmap(nullptr, *size, PROT_READ | (rw ? PROT_WRITE : 0), MAP_SHARED, fd, 0) : nullptr;
|
2017-11-09 18:51:41 +01:00
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
2018-08-09 12:13:07 +02:00
|
|
|
void mmap_ro(const char *filename, void **buf, size_t *size) {
|
|
|
|
_mmap(0, filename, buf, size);
|
2017-11-19 20:40:37 +01:00
|
|
|
}
|
|
|
|
|
2018-08-09 12:13:07 +02:00
|
|
|
void mmap_rw(const char *filename, void **buf, size_t *size) {
|
|
|
|
_mmap(1, filename, buf, size);
|
2017-11-09 18:51:41 +01:00
|
|
|
}
|
|
|
|
|
2017-12-06 20:21:13 +01:00
|
|
|
void fd_full_read(int fd, void **buf, size_t *size) {
|
|
|
|
*size = lseek(fd, 0, SEEK_END);
|
|
|
|
lseek(fd, 0, SEEK_SET);
|
2018-02-05 04:34:31 +01:00
|
|
|
*buf = xmalloc(*size + 1);
|
2017-12-06 20:21:13 +01:00
|
|
|
xxread(fd, *buf, *size);
|
2018-02-05 04:34:31 +01:00
|
|
|
((char *) *buf)[*size] = '\0';
|
2017-12-06 20:21:13 +01:00
|
|
|
}
|
|
|
|
|
2017-12-06 18:30:48 +01:00
|
|
|
void full_read(const char *filename, void **buf, size_t *size) {
|
2018-04-14 21:18:18 +02:00
|
|
|
int fd = xopen(filename, O_RDONLY | O_CLOEXEC);
|
2017-12-06 18:30:48 +01:00
|
|
|
if (fd < 0) {
|
2018-11-03 08:06:01 +01:00
|
|
|
*buf = nullptr;
|
2017-12-06 18:30:48 +01:00
|
|
|
*size = 0;
|
|
|
|
return;
|
|
|
|
}
|
2017-12-06 20:21:13 +01:00
|
|
|
fd_full_read(fd, buf, size);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void full_read_at(int dirfd, const char *filename, void **buf, size_t *size) {
|
2018-04-14 21:18:18 +02:00
|
|
|
int fd = xopenat(dirfd, filename, O_RDONLY | O_CLOEXEC);
|
2017-12-06 20:21:13 +01:00
|
|
|
if (fd < 0) {
|
2018-11-03 08:06:01 +01:00
|
|
|
*buf = nullptr;
|
2017-12-06 20:21:13 +01:00
|
|
|
*size = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
fd_full_read(fd, buf, size);
|
2017-12-06 18:30:48 +01:00
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void stream_full_read(int fd, void **buf, size_t *size) {
|
2017-11-10 13:25:41 +01:00
|
|
|
size_t cap = 1 << 20;
|
|
|
|
uint8_t tmp[1 << 20];
|
|
|
|
*buf = xmalloc(cap);
|
|
|
|
ssize_t read;
|
|
|
|
*size = 0;
|
|
|
|
while (1) {
|
|
|
|
read = xread(fd, tmp, sizeof(tmp));
|
|
|
|
if (read <= 0)
|
|
|
|
break;
|
|
|
|
if (*size + read > cap) {
|
|
|
|
cap *= 2;
|
|
|
|
*buf = realloc(*buf, cap);
|
|
|
|
}
|
2018-11-03 08:06:01 +01:00
|
|
|
memcpy((uint8_t *) *buf + *size, tmp, read);
|
2017-11-10 13:25:41 +01:00
|
|
|
*size += read;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-09 18:51:41 +01:00
|
|
|
void write_zero(int fd, size_t size) {
|
|
|
|
size_t pos = lseek(fd, 0, SEEK_CUR);
|
|
|
|
ftruncate(fd, pos + size);
|
|
|
|
lseek(fd, pos + size, SEEK_SET);
|
|
|
|
}
|
2018-11-03 08:06:01 +01:00
|
|
|
|
2018-11-08 11:03:59 +01:00
|
|
|
int file_to_vector(const char *filename, Vector<CharArray> &arr) {
|
2018-11-03 08:06:01 +01:00
|
|
|
if (access(filename, R_OK) != 0)
|
|
|
|
return 1;
|
|
|
|
char *line = nullptr;
|
|
|
|
size_t len = 0;
|
|
|
|
ssize_t read;
|
|
|
|
|
2018-11-24 03:15:44 +01:00
|
|
|
FILE *fp = xfopen(filename, "re");
|
2018-11-03 08:06:01 +01:00
|
|
|
if (fp == nullptr)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
while ((read = getline(&line, &len, fp)) != -1) {
|
|
|
|
// Remove end newline
|
|
|
|
if (line[read - 1] == '\n')
|
|
|
|
line[read - 1] = '\0';
|
|
|
|
arr.push_back(line);
|
|
|
|
}
|
|
|
|
fclose(fp);
|
2018-11-07 08:10:38 +01:00
|
|
|
free(line);
|
2018-11-03 08:06:01 +01:00
|
|
|
return 0;
|
|
|
|
}
|