From 9af4f1bd4402c789850f471ad572a7436e50062e Mon Sep 17 00:00:00 2001 From: Lailouezzz Date: Wed, 1 Jan 2020 21:25:48 +0100 Subject: [PATCH] No 100% working but get is implemented, casio_read modified (size_t to size_t *) --- include/libcasio/error.h | 3 +- include/libcasio/stream.h | 4 +- lib/errors.c | 3 +- lib/file/file.h | 9 +- lib/link/seven/dataflow.c | 2 +- lib/link/seven/datastream.c | 19 ++- lib/link/seven/receive.c | 5 +- lib/link/seven/scsi.c | 30 ++--- lib/link/seven_fs/list.c | 2 +- lib/link/seven_fs/open.c | 181 ++++++++++++++++++++++++++- lib/link/seven_fs/seven_fs.h | 6 + lib/link/seven_fs/topath.c | 4 +- lib/mcsfile/mcsfile.h | 19 ++- lib/stream/builtin/csum32.c | 5 +- lib/stream/builtin/file.c | 3 +- lib/stream/builtin/libusb/libusb.h | 2 +- lib/stream/builtin/libusb/read.c | 3 +- lib/stream/builtin/limited.c | 6 +- lib/stream/builtin/memory.c | 3 +- lib/stream/builtin/streams/read.c | 3 +- lib/stream/builtin/streams/streams.h | 2 +- lib/stream/read.c | 16 ++- lib/stream/seek.c | 2 +- src/p7/main.c | 53 ++++++-- src/p7os/procs/fxremote_flash.c | 2 +- 25 files changed, 321 insertions(+), 66 deletions(-) diff --git a/include/libcasio/error.h b/include/libcasio/error.h index f100da7..289dbf3 100644 --- a/include/libcasio/error.h +++ b/include/libcasio/error.h @@ -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. */ diff --git a/include/libcasio/stream.h b/include/libcasio/stream.h index 5a94c05..ec2cd4e 100644 --- a/include/libcasio/stream.h +++ b/include/libcasio/stream.h @@ -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)); diff --git a/lib/errors.c b/lib/errors.c index 928f696..c58a0da 100644 --- a/lib/errors.c +++ b/lib/errors.c @@ -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, diff --git a/lib/file/file.h b/lib/file/file.h index f818d3d..5cd24fc 100644 --- a/lib/file/file.h +++ b/lib/file/file.h @@ -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. */ diff --git a/lib/link/seven/dataflow.c b/lib/link/seven/dataflow.c index 3286976..1c31da1 100644 --- a/lib/link/seven/dataflow.c +++ b/lib/link/seven/dataflow.c @@ -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; diff --git a/lib/link/seven/datastream.c b/lib/link/seven/datastream.c index 2ffc850..456baff 100644 --- a/lib/link/seven/datastream.c +++ b/lib/link/seven/datastream.c @@ -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 */ diff --git a/lib/link/seven/receive.c b/lib/link/seven/receive.c index 109bf19..ce0a111 100644 --- a/lib/link/seven/receive.c +++ b/lib/link/seven/receive.c @@ -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) { diff --git a/lib/link/seven/scsi.c b/lib/link/seven/scsi.c index fd3dfff..cc79567 100644 --- a/lib/link/seven/scsi.c +++ b/lib/link/seven/scsi.c @@ -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); } diff --git a/lib/link/seven_fs/list.c b/lib/link/seven_fs/list.c index cc56876..fed50be 100644 --- a/lib/link/seven_fs/list.c +++ b/lib/link/seven_fs/list.c @@ -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); diff --git a/lib/link/seven_fs/open.c b/lib/link/seven_fs/open.c index f4bb649..6a82ab0 100644 --- a/lib/link/seven_fs/open.c +++ b/lib/link/seven_fs/open.c @@ -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 +} diff --git a/lib/link/seven_fs/seven_fs.h b/lib/link/seven_fs/seven_fs.h index f11e001..0b2f7f7 100644 --- a/lib/link/seven_fs/seven_fs.h +++ b/lib/link/seven_fs/seven_fs.h @@ -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 */ diff --git a/lib/link/seven_fs/topath.c b/lib/link/seven_fs/topath.c index 826eedd..59e4498 100644 --- a/lib/link/seven_fs/topath.c +++ b/lib/link/seven_fs/topath.c @@ -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. */ diff --git a/lib/mcsfile/mcsfile.h b/lib/mcsfile/mcsfile.h index 336751f..ee61550 100644 --- a/lib/mcsfile/mcsfile.h +++ b/lib/mcsfile/mcsfile.h @@ -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. */ diff --git a/lib/stream/builtin/csum32.c b/lib/stream/builtin/csum32.c index a071582..3169f28 100644 --- a/lib/stream/builtin/csum32.c +++ b/lib/stream/builtin/csum32.c @@ -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. */ diff --git a/lib/stream/builtin/file.c b/lib/stream/builtin/file.c index 50c9188..90fc051 100644 --- a/lib/stream/builtin/file.c +++ b/lib/stream/builtin/file.c @@ -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. */ diff --git a/lib/stream/builtin/libusb/libusb.h b/lib/stream/builtin/libusb/libusb.h index b3cad60..b2dea05 100644 --- a/lib/stream/builtin/libusb/libusb.h +++ b/lib/stream/builtin/libusb/libusb.h @@ -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)); diff --git a/lib/stream/builtin/libusb/read.c b/lib/stream/builtin/libusb/read.c index 34d727f..e8badeb 100644 --- a/lib/stream/builtin/libusb/read.c +++ b/lib/stream/builtin/libusb/read.c @@ -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. */ diff --git a/lib/stream/builtin/limited.c b/lib/stream/builtin/limited.c index 6b847bf..5b6a244 100644 --- a/lib/stream/builtin/limited.c +++ b/lib/stream/builtin/limited.c @@ -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); } diff --git a/lib/stream/builtin/memory.c b/lib/stream/builtin/memory.c index ea4936c..0fd8b5a 100644 --- a/lib/stream/builtin/memory.c +++ b/lib/stream/builtin/memory.c @@ -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); diff --git a/lib/stream/builtin/streams/read.c b/lib/stream/builtin/streams/read.c index 74e86e0..d3cf63a 100644 --- a/lib/stream/builtin/streams/read.c +++ b/lib/stream/builtin/streams/read.c @@ -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. */ diff --git a/lib/stream/builtin/streams/streams.h b/lib/stream/builtin/streams/streams.h index d04b078..d1e71eb 100644 --- a/lib/stream/builtin/streams/streams.h +++ b/lib/stream/builtin/streams/streams.h @@ -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)); diff --git a/lib/stream/read.c b/lib/stream/read.c index 42b5fd6..3a70350 100644 --- a/lib/stream/read.c +++ b/lib/stream/read.c @@ -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); diff --git a/lib/stream/seek.c b/lib/stream/seek.c index 376221c..419e53f 100644 --- a/lib/stream/seek.c +++ b/lib/stream/seek.c @@ -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; diff --git a/src/p7/main.c b/src/p7/main.c index 1185b27..b87943c 100644 --- a/src/p7/main.c +++ b/src/p7/main.c @@ -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))) diff --git a/src/p7os/procs/fxremote_flash.c b/src/p7os/procs/fxremote_flash.c index 2eac84c..7d53bb0 100644 --- a/src/p7os/procs/fxremote_flash.c +++ b/src/p7os/procs/fxremote_flash.c @@ -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); }