Lailouezzz
/
libcasio
2
2
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity

No 100% working but get is implemented, casio_read modified (size_t to size_t *)

This commit is contained in:
Lailouezzz 2020-01-01 21:25:48 +01:00
parent acda498903
commit 9af4f1bd44
Signed by: Lailouezzz
GPG Key ID: 03FCE8A99EF8482C
25 changed files with 321 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/libcasio/error.h
View File

@ -63,7 +63,8 @@ typedef int casio_error_t;
# define casio_error_timeout 0x14 /* a timeout has occured. */
# define casio_error_access 0x15 /* could not access the device (perms) */
# define casio_error_noaccess 0x15 /* (alias) */
# define casio_error_eof 0x16 /* end of file */
# define casio_error_eof 0x16 /* end of file error */
# define casio_error_ieof 0x17 /* info end of file error */
/* Link errors. */

4
include/libcasio/stream.h
View File

@ -101,7 +101,7 @@ typedef int casio_stream_settm_t
OF((void *, const casio_timeouts_t *));
typedef int casio_stream_read_t
OF((void *, unsigned char *, size_t));
OF((void *, unsigned char *, size_t *));
typedef int casio_stream_write_t
OF((void *, const unsigned char *, size_t));
typedef int casio_stream_seek_t
@ -361,7 +361,7 @@ CASIO_EXTERN int CASIO_EXPORT casio_get_lasterr
CASIO_EXTERN int CASIO_EXPORT casio_read
OF((casio_stream_t *casio__stream,
void *casio__dest, size_t casio__size));
void *casio__dest, size_t *casio__psize));
CASIO_EXTERN int CASIO_EXPORT casio_write
OF((casio_stream_t *casio__stream,
const void *casio__data, size_t casio__size));

3
lib/errors.c
View File

@ -39,7 +39,8 @@ const char* CASIO_EXPORT casio_error_strings[128] = {
"a timeout has occurred",
"could not get access to the device",
"an end of file event has occured",
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
"an end of file event has occured but was manage",
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,

9
lib/file/file.h
View File

@ -28,12 +28,15 @@
/* Read from a stream. */
# define READ(CASIO__TO, CASIO__SZ) /* normal read */ { \
int READ_err = casio_read(buffer, (CASIO__TO), (CASIO__SZ)); \
size_t size = CASIO__SZ; \
int READ_err = casio_read(buffer, (CASIO__TO), &size); \
if (READ_err) return (READ_err); }
# define FREAD(CASIO__TO, CASIO__SZ) /* fail-less read */ \
err = casio_read(buffer, (CASIO__TO), (CASIO__SZ));
size_t size = CASIO__SZ; \
err = casio_read(buffer, (CASIO__TO), &size);
# define GREAD(CASIO__TO, CASIO__SZ) /* read with goto fail */ \
if ((err = casio_read(buffer, (CASIO__TO), (CASIO__SZ)))) \
size_t size = CASIO__SZ; \
if ((err = casio_read(buffer, (CASIO__TO), &size))) \
goto fail;
/* Read using size of the object. */

2
lib/link/seven/dataflow.c
View File

@ -64,7 +64,7 @@ int CASIO_EXPORT casio_seven_send_buffer(casio_link_t *handle,
/* Read the big block. */
toread = min(BUFSIZE, size);
err = casio_read(buffer, buf + 8, toread);
err = casio_read(buffer, buf + 8, &toread);
if (err) return (casio_error_noread);
size -= toread;

19
lib/link/seven/datastream.c
View File

@ -32,6 +32,7 @@ typedef struct {
casio_link_progress_t *_disp;
void *_disp_cookie;
unsigned int _id, _total;
unsigned int _totalsize; /* */
unsigned int _lastsize; /* last packet size */
/* buffer management */
@ -55,11 +56,11 @@ typedef struct {
*/
CASIO_LOCAL int casio_seven_data_read(seven_data_cookie_t *cookie,
unsigned char *data, size_t size)
unsigned char *data, size_t *psize)
{
int err; size_t tocopy;
int err; size_t tocopy; size_t size = *psize;
casio_link_t *handle = cookie->_link;
unsigned int lastsize;
unsigned int lastsize = 0;
/* Check if the stream is faulty. */
if (cookie->_faulty)
@ -78,13 +79,18 @@ CASIO_LOCAL int casio_seven_data_read(seven_data_cookie_t *cookie,
/* Check if we have already finished. */
if (cookie->_total && cookie->_id == cookie->_total)
return (casio_error_eof);
return (casio_error_ieof);
/* Receive packets. */
while (size) {
/* Send the ack and get the answer. */
err = casio_seven_send_ack(handle, 1);
if (err) goto fail;
/* If swap roles there is the end of file */
if (response.casio_seven_packet_type == casio_seven_type_swp) {
*psize = lastsize;
return (casio_error_ieof);
}
if (response.casio_seven_packet_type != casio_seven_type_data) {
msg((ll_error, "Packet wasn't a data packet, wtf?"));
err = casio_error_unknown;
@ -113,7 +119,7 @@ CASIO_LOCAL int casio_seven_data_read(seven_data_cookie_t *cookie,
lastsize = response.casio_seven_packet_data_size;
if (size >= lastsize) {
memcpy(data, response.casio_seven_packet_data, lastsize);
data += lastsize; size -= lastsize;
data += lastsize; size -= lastsize; cookie->_totalsize += lastsize;
continue;
}
@ -122,6 +128,7 @@ CASIO_LOCAL int casio_seven_data_read(seven_data_cookie_t *cookie,
memcpy(data, response.casio_seven_packet_data, size);
memcpy(&cookie->_current[size],
&response.casio_seven_packet_data[size], lastsize - size);
cookie->_totalsize += lastsize;
return (0);
}
@ -341,6 +348,7 @@ int CASIO_EXPORT casio_seven_open_data_stream(casio_stream_t **stream,
cookie->_id = 1;
cookie->_total = (unsigned int)(size / BUFSIZE) + !!cookie->_lastsize;
cookie->_lastsize = (unsigned int)(size % BUFSIZE);
cookie->_totalsize = size;
if (!cookie->_lastsize) cookie->_lastsize = BUFSIZE;
} else {
msg((ll_info, "The data stream is a read one."));
@ -350,6 +358,7 @@ int CASIO_EXPORT casio_seven_open_data_stream(casio_stream_t **stream,
cookie->_id = 0;
cookie->_total = 0;
cookie->_lastsize = 0;
cookie->_totalsize = size;
}
/* initialize the stream */

5
lib/link/seven/receive.c
View File

@ -175,9 +175,10 @@ CASIO_LOCAL const char *gettermstring(casio_seven_term_t code)
#define buffer handle->casio_link_recv_buffer
#define COMPLETE_PACKET(N) { \
size_t size##__LINE__ = (size_t)N; \
int COMP_PACKET_err = casio_read(handle->casio_link_stream, \
&buffer[received], (size_t)(N)); \
received += (N); if (COMP_PACKET_err) return (COMP_PACKET_err); }
&buffer[received], &size##__LINE__); \
received += size##__LINE__; if (COMP_PACKET_err) return (COMP_PACKET_err); }
CASIO_LOCAL int casio_seven_decode(casio_link_t *handle, int scralign)
{

30
lib/link/seven/scsi.c
View File

@ -84,23 +84,23 @@ typedef struct {
* --- */
CASIO_LOCAL int seven_scsi_read(seven_scsi_cookie_t *cookie,
unsigned char *buffer, size_t size)
unsigned char *buffer, size_t *size)
{
casio_scsi_t scsi; int err;
/* Empty what's already in the buffer. */
if (cookie->left) {
if (cookie->left >= size) {
memcpy(buffer, cookie->ptr, size);
cookie->ptr += size;
cookie->left -= size;
if (cookie->left >= *size) {
memcpy(buffer, cookie->ptr, *size);
cookie->ptr += *size;
cookie->left -= *size;
return (0);
}
memcpy(buffer, cookie->ptr, cookie->left);
buffer += cookie->left;
size -= cookie->left;
*size -= cookie->left;
reset_cookie(cookie);
}
@ -151,14 +151,14 @@ CASIO_LOCAL int seven_scsi_read(seven_scsi_cookie_t *cookie,
* We could also check that `avail < 0x10000` because we need to
* express it later, but it is imposed by the source format. */
if (avail > size && size <= cookie->size) {
if (avail > *size && *size <= cookie->size) {
to = cookie->ptr;
if (avail > cookie->size)
avail = cookie->size;
} else {
to = buffer;
if (avail > size)
avail = size;
if (avail > *size)
avail = *size;
}
/* Actually get the data. */
@ -182,16 +182,16 @@ CASIO_LOCAL int seven_scsi_read(seven_scsi_cookie_t *cookie,
if (to == buffer) {
buffer += avail;
size -= avail;
*size -= avail;
} else {
cookie->left = avail;
memcpy(buffer, cookie->ptr, size);
cookie->ptr += size;
cookie->left -= size;
size = 0;
memcpy(buffer, cookie->ptr, *size);
cookie->ptr += *size;
cookie->left -= *size;
*size = 0;
}
} while (size);
} while (*size);
return (0);
}

2
lib/link/seven_fs/list.c
View File

@ -46,7 +46,7 @@ int CASIO_EXPORT casio_sevenfs_list(sevenfs_cookie_t *cookie, sevenfs_path_t *pa
} else if (response.casio_seven_packet_type == casio_seven_type_nak
&& response.casio_seven_packet_code == casio_seven_err_other) {
msg((ll_fatal, "Invalid filesystem"));
return (casio_error_device); // FIXME : unsupported device error
return (casio_error_device);
} else if (response.casio_seven_packet_type != casio_seven_type_ack) {
msg((ll_fatal, "Didn't receive ack or known error..."));
return (casio_error_unknown);

181
lib/link/seven_fs/open.c
View File

@ -29,7 +29,7 @@ CASIO_LOCAL casio_fsfuncs_t sevenfs_callbacks = {
(casio_fs_del_t*)&casio_sevenfs_delete,
NULL,
(casio_fs_list_t*)&casio_sevenfs_list,
NULL,
(casio_fs_open_t*)&casio_sevenfs_open,
(casio_fs_optim_t*)&casio_sevenfs_optimize
};
@ -48,3 +48,182 @@ int CASIO_EXPORT casio_open_seven_fs(casio_fs_t **fs,
/* Open the filesystem. (no need for cookie allocating for now) */
return (casio_open_fs(fs, link, &sevenfs_callbacks));
}
/**
* casio_sevenfs_open_read
* Open a file in read mode
*
* @arg cookie the sevenfs cookie
* @arg path the path to th file
* @arg stream pointer to a pointer who contain the stream
*/
CASIO_LOCAL int casio_sevenfs_open_read(sevenfs_cookie_t *cookie, sevenfs_path_t *path,
casio_stream_t **stream)
{
casio_link_t *handle = cookie; int err;
char *dirname = (path->sevenfs_path_dir != 0xFF) ? &path->sevenfs_path_data[path->sevenfs_path_dir] : NULL;
char *filename = &path->sevenfs_path_data[path->sevenfs_path_file];
char *devname = &path->sevenfs_path_data[path->sevenfs_path_dev];
/* Make checks */
chk_required_filename(filename);
chk_dirname(dirname);
chk_handle(handle);
chk_active(handle);
/* Send command packet */
msg((ll_info, "Sending file transfer request"));
if ((err = casio_seven_send_cmdfls_reqfile(handle, dirname, filename, devname))) {
msg((ll_fatal, "Couldn't send file transfer request/didn't receive answer"));
return (err);
}
/* Check response packet */
if (response.casio_seven_packet_type == casio_seven_type_nak
&& response.casio_seven_packet_code == casio_seven_err_other) {
msg((ll_fatal, "Requested file doesn't exist"));
err = casio_error_notfound;
return (err);
} else if (response.casio_seven_packet_type != casio_seven_type_ack) {
msg((ll_fatal, "Didn't receive ack or known error..."));
return (casio_error_unknown);
}
/* Send swap roles */
msg((ll_info, "Sending roleswap"));
if ((err = casio_seven_send_roleswp(handle)))
{
msg((ll_fatal, "Couldn't swap roles"));
return (err);
} else if (response.casio_seven_packet_type != casio_seven_type_cmd
|| response.casio_seven_packet_code != 0x45)
{
msg((ll_fatal, "Didn't receive the excepted command"));
return (casio_error_unknown);
}
return casio_seven_open_data_stream(stream, handle, response.casio_seven_packet_filesize, NULL, NULL);
}
/**
* casio_sevenfs_open_write
* Open a file in write mode
*
* @arg cookie the sevenfs cookie
* @arg path the path to th file
* @arg size size of the file
* @arg stream pointer to a pointer who contain the stream
* @return the error (0 if okey)
*/
CASIO_LOCAL int casio_sevenfs_open_write(sevenfs_cookie_t *cookie, sevenfs_path_t *path,
casio_off_t size, casio_stream_t **stream)
{
casio_link_t *handle = cookie; int err;
char *dirname = &path->sevenfs_path_data[path->sevenfs_path_dir];
char *filename = &path->sevenfs_path_data[path->sevenfs_path_file];
char *devname = &path->sevenfs_path_data[path->sevenfs_path_dev];
/* Make checks */
chk_required_filename(filename);
chk_dirname(dirname);
chk_handle(handle);
chk_active(handle);
return (0);
}
/**
* casio_sevenfs_open:
* Open a file.
*
* @arg cookie the sevenfs cookie
* @arg path the path to the file
* @arg size size of the file if WRITE (NULL if READ)
* @arg mode the open mode
* @arg stream pointer to a pointer who contain the stream
* @return the error (0 if okey)
*/
int CASIO_EXPORT casio_sevenfs_open(sevenfs_cookie_t *cookie, sevenfs_path_t *path,
casio_off_t size, casio_openmode_t mode, casio_stream_t **stream)
{
casio_link_t *handle = cookie; int err;
char *dirname = &path->sevenfs_path_data[path->sevenfs_path_dir];
char *filename = &path->sevenfs_path_data[path->sevenfs_path_file];
char *devname = &path->sevenfs_path_data[path->sevenfs_path_dev];
/* Make checks (not really required) */
chk_required_filename(filename);
chk_dirname(dirname);
chk_handle(handle);
chk_active(handle);
if ((mode & CASIO_OPENMODE_WRITE))
{
} else if ((mode & CASIO_OPENMODE_READ))
{
return (casio_sevenfs_open_read(cookie, path, stream));
}
#if 0
/* Send command packet */
msg((ll_info, "Sending file transfer request"));
if ((err = casio_seven_send_cmdfls_reqfile(handle, dirname, filename, devname))) {
msg((ll_fatal, "Couldn't send file transfer request/didn't receive answer"));
return (err);
}
/* Check response */
if (response.casio_seven_packet_type == casio_seven_type_nak
&& response.casio_seven_packet_code == casio_seven_err_other)
{
/* If file doesn't exist and we want read : error */
if ((mode & CASIO_OPENMODE_READ)) {
msg((ll_fatal, "Requested file doesn't exist"));
return (casio_error_notfound);
}
} else if (response.casio_seven_packet_type != casio_seven_type_ack) {
msg((ll_fatal, "Didn't receive ack or known error..."));
return (casio_error_unknown);
}
/* Check what happened if it is an error packet */
if (response.casio_seven_packet_type == casio_seven_type_nak)
{
switch (response.casio_seven_packet_type)
{
/* Calc need overwrite confirmation */
case casio_seven_err_overwrite:
break;
/* Calc denie overwrite or err other */
case casio_seven_err_dont_overwrite:
case casio_seven_err_other:
msg((ll_error, "Overwrite impossible"));
err = casio_error_device;
return (err);
break;
/* Memory full */
case casio_seven_err_fullmem:
msg((ll_error, "Calc mem is full"));
err = casio_error_fullmem;
return (err);
break;
/* stfu warning */
case casio_seven_err_resend: break;
}
}
msg((ll_info, "WE CAN"));
#endif
}

6
lib/link/seven_fs/seven_fs.h
View File

@ -57,4 +57,10 @@ CASIO_EXTERN int CASIO_EXPORT casio_sevenfs_list
OF((sevenfs_cookie_t *casio__cookie, sevenfs_path_t *casio__path,
casio_fs_list_func_t *casio__callback, void *casio__cbcookie));
/* Open a stream with a casio fs file */
CASIO_EXTERN int CASIO_EXPORT casio_sevenfs_open
OF((sevenfs_cookie_t *casio__cookie, sevenfs_path_t *casio__path,
casio_off_t casio__size, casio_openmode_t casio__mode, casio_stream_t **casio__stream));
#endif /* LOCAL_LINK_SEVEN_FS_H */

4
lib/link/seven_fs/topath.c
View File

@ -53,7 +53,7 @@ int CASIO_EXPORT casio_make_sevenfs_path(sevenfs_cookie_t *cookie,
if (!node) return (casio_error_invalid);
if (node->casio_pathnode_next) {
dirsz = node->casio_pathnode_size + 1;
if (dirsz == 1 || dirsz > 9) return (casio_error_invalid);
if (dirsz == 1 || dirsz > 13) return (casio_error_invalid);
dirname = (const char*)node->casio_pathnode_name;
node = node->casio_pathnode_next;
} else {
@ -66,7 +66,7 @@ int CASIO_EXPORT casio_make_sevenfs_path(sevenfs_cookie_t *cookie,
return (casio_error_invalid);
}
filesz = node->casio_pathnode_size + 1;
if (filesz == 1 || filesz > 9) return (casio_error_invalid);
if (filesz == 1 || filesz > 13) return (casio_error_invalid);
filename = (const char*)node->casio_pathnode_name;
/* Make the node. */

19
lib/mcsfile/mcsfile.h
View File

@ -26,14 +26,21 @@
/* Read from a stream. */
/* FIXME : size_t size##__LINE__ = CASIO__SZ;
* Replace this by other thing that is more futur proof
*/
# define READ(CASIO__TO, CASIO__SZ) /* normal read */ { \
int READ_err = casio_read(buffer, (CASIO__TO), (CASIO__SZ)); \
size_t size##__LINE__ = CASIO__SZ; \
int READ_err = casio_read(buffer, (CASIO__TO), &size##__LINE__); \
if (READ_err) return (READ_err); }
# define FREAD(CASIO__TO, CASIO__SZ) /* fail-less read */ \
err = casio_read(buffer, (CASIO__TO), (CASIO__SZ));
# define GREAD(CASIO__TO, CASIO__SZ) /* read with goto fail */ \
if ((err = casio_read(buffer, (CASIO__TO), (CASIO__SZ)))) \
goto fail;
# define FREAD(CASIO__TO, CASIO__SZ) /* fail-less read */ { \
size_t size##__LINE__ = CASIO__SZ; \
err = casio_read(buffer, (CASIO__TO), &size##__LINE__); }
# define GREAD(CASIO__TO, CASIO__SZ) /* read with goto fail */ { \
size_t size##__LINE__ = CASIO__SZ; \
if ((err = casio_read(buffer, (CASIO__TO), &size##__LINE__))) \
goto fail; }
/* Read using size of the object. */

5
lib/stream/builtin/csum32.c
View File

@ -42,13 +42,14 @@ struct thecookie {
*/
CASIO_LOCAL int csum32_read(struct thecookie *cookie,
unsigned char *dest, size_t size)
unsigned char *dest, size_t *psize)
{
int err;
size_t size = *psize;
/* Make the call. */
err = casio_read(cookie->_stream, dest, size);
err = casio_read(cookie->_stream, dest, &size);
if (err) return (err);
/* Make the checksum. */

3
lib/stream/builtin/file.c
View File

@ -50,9 +50,10 @@ typedef struct {
*/
CASIO_LOCAL int casio_file_read(file_cookie_t *cookie,
unsigned char *dest, size_t size)
unsigned char *dest, size_t *psize)
{
size_t recv;
size_t size = *psize;
/* Main receiving loop. */

2
lib/stream/builtin/libusb/libusb.h
View File

@ -60,7 +60,7 @@ CASIO_EXTERN int CASIO_EXPORT casio_libusb_settm
CASIO_EXTERN int CASIO_EXPORT casio_libusb_read
OF((cookie_libusb_t *casio__cookie,
unsigned char *casio__dest, size_t casio__size));
unsigned char *casio__dest, size_t *casio__psize));
CASIO_EXTERN int CASIO_EXPORT casio_libusb_write
OF((cookie_libusb_t *casio__cookie,
const unsigned char *casio__data, size_t casio__size));

3
lib/stream/builtin/libusb/read.c
View File

@ -30,10 +30,11 @@
*/
int CASIO_EXPORT casio_libusb_read(cookie_libusb_t *cookie,
unsigned char *dest, size_t size)
unsigned char *dest, size_t *psize)
{
int libusberr;
size_t tocopy;
size_t size = *psize;
/* Transmit what's already in the buffer. */

6
lib/stream/builtin/limited.c
View File

@ -41,10 +41,10 @@ typedef struct {
*/
CASIO_LOCAL int casio_limited_read(void *vcookie, unsigned char *dest,
size_t size)
size_t *psize)
{
int err; limited_cookie_t *cookie = (void*)vcookie;
size_t left;
size_t left; size_t size = *psize;
if (size > cookie->_left) {
/* First, skip the required bytes. */
@ -60,7 +60,7 @@ CASIO_LOCAL int casio_limited_read(void *vcookie, unsigned char *dest,
return (casio_error_eof);
}
if ((err = casio_read(cookie->_stream, dest, size))) {
if ((err = casio_read(cookie->_stream, dest, &size))) {
cookie->_left = 0; /* XXX: depends on the error? */
return (err);
}

3
lib/stream/builtin/memory.c
View File

@ -38,9 +38,10 @@ typedef struct {
* @return the error code (0 if ok).
*/
CASIO_LOCAL int casio_memory_read(void *vcookie, unsigned char *dest, size_t size)
CASIO_LOCAL int casio_memory_read(void *vcookie, unsigned char *dest, size_t *psize)
{
memory_cookie_t *cookie = (void*)vcookie;
size_t size = *psize;
if (((size_t)-1 - cookie->_offset) < size) /* overflow */
return (casio_error_read);

3
lib/stream/builtin/streams/read.c
View File

@ -30,9 +30,10 @@
*/
int CASIO_EXPORT casio_streams_read(streams_cookie_t *cookie,
unsigned char *dest, size_t size)
unsigned char *dest, size_t *psize)
{
int fd = cookie->_readfd;
size_t size = *psize;
/* Transmit what's already in the buffer. */

2
lib/stream/builtin/streams/streams.h
View File

@ -53,7 +53,7 @@ CASIO_EXTERN int CASIO_EXPORT casio_streams_settm
CASIO_EXTERN int CASIO_EXPORT casio_streams_read
OF((streams_cookie_t *casio__cookie,
unsigned char *casio__dest, size_t casio__size));
unsigned char *casio__dest, size_t *casio__psize));
CASIO_EXTERN int CASIO_EXPORT casio_streams_write
OF((streams_cookie_t *casio__cookie,
const unsigned char *casio__data, size_t casio__size));

16
lib/stream/read.c
View File

@ -28,7 +28,7 @@
* @return the error code (0 if ok).
*/
int CASIO_EXPORT casio_read(casio_stream_t *stream, void *dest, size_t size)
int CASIO_EXPORT casio_read(casio_stream_t *stream, void *dest, size_t *psize)
{
int err;
@ -36,16 +36,20 @@ int CASIO_EXPORT casio_read(casio_stream_t *stream, void *dest, size_t size)
failure(~stream->casio_stream_mode & CASIO_OPENMODE_READ, casio_error_read)
/* read */
if (!size) return (0);
err = (*getcb(stream, read))(stream->casio_stream_cookie, dest, size);
if (err) {
if (!(*psize)) return (0);
if (!psize) {
size_t size = -1;
err = (*getcb(stream, read))(stream->casio_stream_cookie, dest, &size);
} else {
err = (*getcb(stream, read))(stream->casio_stream_cookie, dest, psize);
}
if (err && err != casio_error_ieof) {
msg((ll_error, "Stream reading failure: %s", casio_strerror(err)));
goto fail;
}
/* move the cursor and return */
stream->casio_stream_offset += size;
err = 0;
stream->casio_stream_offset += *psize;
fail:
stream->casio_stream_lasterr = err;
return (err);

2
lib/stream/seek.c
View File

@ -64,7 +64,7 @@ int CASIO_EXPORT casio_seek(casio_stream_t *stream, casio_off_t offset,
/* Read that much from the stream. */
if ((err = casio_read(stream, buf, rd)))
if ((err = casio_read(stream, buf, &rd)))
goto fail;
to_skip -= rd;

53
src/p7/main.c
View File

@ -250,7 +250,8 @@ int main(int ac, char **av)
/* Check according to menu */
casio_path_t path;
casio_path_t path = { 0 };
casio_stream_t *fileStream = NULL;
switch (args.menu) {
#if 0
case mn_send:
@ -277,12 +278,6 @@ int main(int ac, char **av)
args.storage, 1, args.force ? NULL : &sendfile_confirm,
args.nicedisp ? &sendfile_display : NULL);
break;
case mn_get:
err = casio_reqfile(handle, args.local,
args.dirname, args.filename,
args.storage, args.nicedisp && args.local != stdout
? &sendfile_display : NULL);
break;
case mn_copy:
err = casio_copy(handle, args.dirname, args.filename,
args.newdir, args.newname, args.storage);
@ -295,15 +290,59 @@ int main(int ac, char **av)
err = casio_reset(handle, args.storage);
break;
#endif
case mn_get:
// Initialize the path
path.casio_path_device = args.storage;
// Make the node
casio_make_pathnode(&path.casio_path_nodes, strlen(args.filename));
memcpy(path.casio_path_nodes->casio_pathnode_name, args.filename, strlen(args.filename));
// Set flags
path.casio_path_flags = casio_pathflag_rel;
// Open 7.00 fs and open file in read only
if ((err = casio_open_seven_fs(&fs, handle))
|| (err = casio_open(fs, &fileStream, &path, 0, CASIO_OPENMODE_READ)))
break;
char buffer[CASIO_SEVEN_MAX_RAWDATA_SIZE];
FILE *file = fopen(args.filename, "wb");
if(!file) {
fprintf(stderr, "Couldn't open in write mode %s", args.filename);
err = casio_error_unknown;
break;
}
size_t size;
do
{
size = sizeof(buffer);
err = casio_read(fileStream, buffer, &size);
fwrite(buffer, 1, size, file);
if(err == casio_error_ieof)
break;
} while (err == 0);
/* All good so close streams and clear error */
err = 0;
fclose(file);
casio_close(fileStream);
break;
case mn_list:
// Initialize the path
path.casio_path_device = args.storage;
casio_make_pathnode(&path.casio_path_nodes, 1);
path.casio_path_flags = casio_pathflag_rel;
// Open 7.00 fs and list
if ((err = casio_open_seven_fs(&fs, handle))
|| (err = casio_list(fs, &path, print_file_info, NULL)))
break;
break;
case mn_optimize:
if ((err = casio_open_seven_fs(&fs, handle))
|| (err = casio_optimize(fs, args.storage)))

2
src/p7os/procs/fxremote_flash.c
View File

@ -83,7 +83,7 @@ static int send_sector(casio_link_t *handle, casio_stream_t *buffer,
/* Prepare the block. */
block.destination = casio_be32toh(buf);
block.length = casio_be32toh(len);
if ((buf_err = casio_read(buffer, block.data, len))) {
if ((buf_err = casio_read(buffer, block.data, &len))) {
osdisp_interrupt(&osdisp_cookie);
return (casio_error_read);
}