164 lines
3.1 KiB
C
164 lines
3.1 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
|
|
#include "file_src.h"
|
|
#include "messages.h"
|
|
|
|
#define BLOCK_SIZE 2048
|
|
|
|
struct local_file_data {
|
|
int fd; /* the file descriptor, once the file is opened */
|
|
off_t size; /* file size */
|
|
off_t bytes_read; /* bytes already read from file */
|
|
int error;
|
|
char *path; /* path of the file on local filesystem */
|
|
};
|
|
|
|
static
|
|
int lf_open(struct iso_file_src *src)
|
|
{
|
|
struct local_file_data *data;
|
|
assert(src);
|
|
|
|
data = (struct local_file_data*) src->data;
|
|
|
|
assert(data->fd == -1);
|
|
|
|
data->fd = open(data->path, O_RDONLY);
|
|
data->bytes_read = (off_t) 0;
|
|
data->error = 0;
|
|
return (data->fd != -1 ? 1 : 0);
|
|
}
|
|
|
|
static
|
|
void lf_close(struct iso_file_src *src)
|
|
{
|
|
struct local_file_data *data;
|
|
assert(src);
|
|
|
|
data = (struct local_file_data*) src->data;
|
|
assert(data->fd != -1);
|
|
|
|
close(data->fd);
|
|
data->fd = -1;
|
|
}
|
|
|
|
static
|
|
int lf_read_block(struct iso_file_src *src, unsigned char *buffer)
|
|
{
|
|
ssize_t bytes;
|
|
struct local_file_data *data;
|
|
assert(src);
|
|
assert(buffer);
|
|
|
|
data = (struct local_file_data*) src->data;
|
|
assert(data->fd != -1);
|
|
|
|
if (data->bytes_read >= data->size) {
|
|
return 0;
|
|
}
|
|
|
|
if (data->error) {
|
|
memset(buffer, 0, BLOCK_SIZE);
|
|
data->bytes_read += BLOCK_SIZE;
|
|
return -2;
|
|
}
|
|
|
|
bytes = 0;
|
|
|
|
do {
|
|
ssize_t result;
|
|
result = read(data->fd, buffer + bytes, BLOCK_SIZE - bytes);
|
|
if (result < 0) {
|
|
char msg[PATH_MAX + 32];
|
|
sprintf(msg, "Problem reading from %s", data->path);
|
|
iso_msg_sorry(LIBISO_CANT_READ_FILE, msg);
|
|
|
|
/* fill buffer with 0s and return */
|
|
memset(buffer + bytes, 0, BLOCK_SIZE - bytes);
|
|
data->bytes_read += BLOCK_SIZE;
|
|
return -1;
|
|
}
|
|
if (!result)
|
|
break;
|
|
bytes += result;
|
|
} while (bytes < BLOCK_SIZE);
|
|
|
|
if (bytes < BLOCK_SIZE) {
|
|
/* eof */
|
|
memset(buffer + bytes, 0, BLOCK_SIZE - bytes);
|
|
}
|
|
|
|
data->bytes_read += (off_t) bytes;
|
|
if (data->bytes_read >= data->size) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static
|
|
off_t lf_get_size(struct iso_file_src *src)
|
|
{
|
|
struct local_file_data *data;
|
|
assert(src);
|
|
|
|
data = (struct local_file_data*) src->data;
|
|
return data->size;
|
|
}
|
|
|
|
static
|
|
void lf_free_data(struct iso_file_src *src)
|
|
{
|
|
free(src->data);
|
|
}
|
|
|
|
struct iso_file_src*
|
|
iso_file_src_from_path(const char *path)
|
|
{
|
|
struct stat info;
|
|
struct iso_file_src *src;
|
|
struct local_file_data *data;
|
|
|
|
assert(path);
|
|
|
|
if (lstat(path, &info) < 0) {
|
|
iso_msg_fatal(LIBISO_FILE_DOESNT_EXIST, "File doesn't exist");
|
|
return NULL;
|
|
}
|
|
if (access(path, R_OK) < 0) {
|
|
iso_msg_fatal(LIBISO_FILE_NO_READ_ACCESS, "No read access");
|
|
return NULL;
|
|
}
|
|
|
|
data = malloc(sizeof(struct local_file_data));
|
|
if (!data)
|
|
return NULL;
|
|
|
|
src = malloc(sizeof(struct iso_file_src));
|
|
if (!src) {
|
|
free(data);
|
|
return NULL;
|
|
}
|
|
|
|
data->fd = -1;
|
|
data->path = strdup(path);
|
|
data->size = info.st_size;
|
|
|
|
src->open = lf_open;
|
|
src->close = lf_close;
|
|
src->read_block = lf_read_block;
|
|
src->get_size = lf_get_size;
|
|
src->free_data = lf_free_data;
|
|
|
|
src->data = data;
|
|
return src;
|
|
}
|