cake
/
libp7
Archived
1
0
Fork 1
Code

Namespace.

This commit is contained in:
Thomas Touhey 2017-04-12 17:39:38 +02:00
parent 055a841fdb
commit 81c4f88502
43 changed files with 824 additions and 711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
include/libp7.h
View File

@ -77,17 +77,18 @@ typedef int p7_error_t;
/* Message getting macro */
extern const char *p7_error_strings[];
# define p7_strerror(N) p7_error_strings[N]
# define p7_geterror(N) p7_error_strings[N]
# define p7_strerror(P7_ARG_N) p7_error_strings[P7_ARG_N]
# define p7_geterror(P7_ARG_N) p7_error_strings[P7_ARG_N]
/* ************************************************************************** */
/* Random stuff */
/* ************************************************************************** */
/* Filename and dirname */
extern int p7_validate_filename(const char *filename);
extern int p7_validate_dirname(const char *dirname);
extern int p7_validate_filename(const char *p7_arg_filename);
extern int p7_validate_dirname(const char *p7_arg_dirname);
/* Make settings out of a string */
extern int p7_makesettings(p7_streamsettings_t *settings, const char *s);
extern int p7_makesettings(p7_streamsettings_t *p7_arg_settings,
const char *p7_arg_s);
/* ************************************************************************** */
/* Core functions */
/* ************************************************************************** */
@ -108,125 +109,137 @@ extern int p7_makesettings(p7_streamsettings_t *settings, const char *s);
# define P7_TERM p7_flag_term
/* "Normal" initialization */
extern int p7_init(p7_handle_t **handle, unsigned int flags);
extern int p7_cominit(p7_handle_t **handle, unsigned int flags,
const char *path, const p7_streamsettings_t *settings);
extern int p7_comlist(p7_list_device_t callback, void *cookie);
extern int p7_init(p7_handle_t **p7_arg_handle, unsigned int p7_arg_flags);
extern int p7_cominit(p7_handle_t **p7_arg_handle, unsigned int p7_arg_flags,
const char *p7_arg_path, const p7_streamsettings_t *p7_arg_settings);
extern int p7_comlist(p7_list_device_t *p7_arg_callback, void *p7_arg_cookie);
/* De-initialization */
extern void p7_exit(p7_handle_t *handle);
extern void p7_exit(p7_handle_t *p7_arg_handle);
/* ************************************************************************** */
/* MCS interaction */
/* ************************************************************************** */
/* List files */
extern int p7_mcs_list(p7_handle_t *handle, p7_mcslist_t callback,
void *cookie);
extern int p7_mcs_list(p7_handle_t *p7_arg_handle,
p7_mcslist_t *p7_arg_callback, void *p7_arg_cookie);
/* Send a file */
extern int p7_mcs_send(p7_handle_t *handle, g1m_mcsfile_t *file,
int overwrite, p7_confirm_t confirm, p7_disp_t disp);
extern int p7_mcs_send(p7_handle_t *p7_arg_handle, g1m_mcsfile_t *p7_arg_file,
int p7_arg_overwrite, p7_confirm_t *p7_arg_confirm, p7_disp_t *p7_arg_disp);
/* Request a file */
extern int p7_mcs_request(p7_handle_t *handle, g1m_mcsfile_t **file,
g1m_mcshead_t *head, p7_disp_t disp);
extern int p7_mcs_request(p7_handle_t *p7_arg_handle,
g1m_mcsfile_t **p7_arg_file, g1m_mcshead_t *p7_arg_head,
p7_disp_t *p7_arg_disp);
/* ************************************************************************** */
/* Storage memory interaction */
/* ************************************************************************** */
/* Send a file using buffer */
extern int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
const char *dirname, const char *filename, const char *devname,
int overwrite, p7_confirm_t confirm, p7_disp_t disp);
extern int p7_send(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname, int p7_arg_overwrite,
p7_confirm_t *p7_arg_confirm, p7_disp_t *p7_arg_disp);
/* Receive a file using buffer */
extern int p7_request(p7_handle_t *handle, const p7_buffer_t *buffer,
const char *dirname, const char *filename, const char *devname,
p7_disp_t disp);
extern int p7_request(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname, p7_disp_t *p7_arg_disp);
/* FILE version of the two previous functions */
# ifndef P7_DISABLED_FILE
extern int p7_sendfile(p7_handle_t *handle, FILE *file,
const char *dirname, const char *filename, const char *devname,
int overwrite, p7_confirm_t confirm, p7_disp_t disp);
extern int p7_reqfile(p7_handle_t *handle, FILE *file,
const char *dirname, const char *filename, const char *devname,
p7_disp_t disp);
extern int p7_sendfile(p7_handle_t *p7_arg_handle, FILE *p7_arg_file,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname, int p7_arg_overwrite,
p7_confirm_t *p7_arg_confirm, p7_disp_t *p7_arg_disp);
extern int p7_reqfile(p7_handle_t *p7_arg_handle, FILE *p7_arg_file,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname, p7_disp_t *p7_arg_disp);
# endif
/* Memory version of the send function */
extern int p7_sendmem(p7_handle_t *handle, const void *mem, size_t size,
const char *dirname, const char *filename, const char *devname,
int overwrite, p7_confirm_t confirm, p7_disp_t disp);
extern int p7_sendmem(p7_handle_t *p7_arg_handle,
const void *p7_arg_mem, size_t p7_arg_size,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname, int p7_arg_overwrite,
p7_confirm_t *p7_arg_confirm, p7_disp_t *p7_arg_disp);
/* Create a directory */
extern int p7_createdir(p7_handle_t *handle, const char *dirname,
const char *devname);
extern int p7_createdir(p7_handle_t *p7_arg_handle,
const char *p7_arg_dirname, const char *p7_arg_devname);
/* Delete distant file */
extern int p7_delete(p7_handle_t *handle,
const char *dirname, const char *filename, const char *devname);
extern int p7_delete(p7_handle_t *p7_arg_handle,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_devname);
/* Copy file on distant device */
extern int p7_copy(p7_handle_t *handle,
const char *dirname, const char *filename,
const char *newdir, const char *newname, const char *devname);
extern int p7_copy(p7_handle_t *p7_arg_handle,
const char *p7_arg_dirname, const char *p7_arg_filename,
const char *p7_arg_newdir, const char *p7_arg_newname,
const char *p7_arg_devname);
/* List files */
extern int p7_list(p7_handle_t *handle, const char *devname,
p7_list_t callback, void *cookie);
extern int p7_list(p7_handle_t *p7_arg_handle, const char *p7_arg_devname,
p7_list_t *p7_arg_callback, void *p7_arg_cookie);
/* Get the free memory amount */
extern int p7_getfreemem(p7_handle_t *handle, const char *devname,
p7uint_t *capacity);
extern int p7_getfreemem(p7_handle_t *p7_arg_handle, const char *p7_arg_devname,
p7uint_t *p7_arg_capacity);
/* Reset filesystem on a distant device */
extern int p7_reset(p7_handle_t *handle, const char *devname);
extern int p7_reset(p7_handle_t *p7_arg_handle, const char *p7_arg_devname);
/* Optimize distant device */
extern int p7_optimize(p7_handle_t *handle, const char *devname);
extern int p7_optimize(p7_handle_t *p7_arg_handle, const char *p7_arg_devname);
/* ************************************************************************** */
/* Miscallenous interactions */
/* ************************************************************************** */
/* Poke the calculator in order to keep it happy */
extern int p7_poke(p7_handle_t *handle);
extern int p7_poke(p7_handle_t *p7_arg_handle);
/* Send an update.exe */
extern int p7_sendexe(p7_handle_t *handle, const p7_buffer_t *buffer,
p7uint_t loadaddr, p7uint_t straddr, void (*disp)(p7ushort_t, p7ushort_t));
extern int p7_sendexe(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer,
p7uint_t p7_arg_loadaddr, p7uint_t p7_arg_straddr, p7_disp_t *p7_arg_disp);
/* Backup the flash ROM, bootcode and CASIOWIN entry */
extern int p7_backup_rom(p7_handle_t *handle, const p7_buffer_t *buffer,
p7_disp_t disp);
extern int p7_backup_ram(p7_handle_t *handle, const p7_buffer_t *buffer,
p7_disp_t disp);
extern int p7_backup_boot(p7_handle_t *handle, const p7_buffer_t *buffer,
p7_disp_t disp);
extern int p7_backup_casiowin_entry(p7_handle_t *handle,
p7_casiowin_entry_t *entry);
extern int p7_backup_rom(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer, p7_disp_t *p7_arg_disp);
extern int p7_backup_ram(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer, p7_disp_t *p7_arg_disp);
extern int p7_backup_boot(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer, p7_disp_t *p7_arg_disp);
extern int p7_backup_casiowin_entry(p7_handle_t *p7_arg_handle,
p7_casiowin_entry_t *p7_arg_entry);
/* set link settings */
extern int p7_setlink(p7_handle_t *handle, const p7_streamsettings_t *settings);
extern int p7_setlink(p7_handle_t *p7_arg_handle,
const p7_streamsettings_t *p7_arg_settings);
/* FILE version of the previous functions */
# ifndef P7_DISABLED_FILE
/* Send an update.exe */
extern int p7_sendexe_file(p7_handle_t *handle,
FILE *exe, p7uint_t loadaddr, p7uint_t straddr,
p7_disp_t disp);
extern int p7_backup_romfile(p7_handle_t *handle, FILE *file,
p7_disp_t disp);
extern int p7_backup_ramfile(p7_handle_t *handle, FILE *file,
p7_disp_t disp);
extern int p7_backup_bootfile(p7_handle_t *handle, FILE *file,
p7_disp_t disp);
extern int p7_sendexe_file(p7_handle_t *p7_arg_handle,
FILE *p7_arg_exe, p7uint_t p7_arg_loadaddr, p7uint_t p7_arg_straddr,
p7_disp_t *p7_arg_disp);
extern int p7_backup_romfile(p7_handle_t *p7_arg_handle, FILE *p7_arg_file,
p7_disp_t *p7_arg_disp);
extern int p7_backup_ramfile(p7_handle_t *p7_arg_handle, FILE *p7_arg_file,
p7_disp_t *p7_arg_disp);
extern int p7_backup_bootfile(p7_handle_t *p7_arg_handle, FILE *p7_arg_file,
p7_disp_t *p7_arg_disp);
# endif
/* Memory version of the previous functions */
extern int p7_sendexe_mem(p7_handle_t *handle,
const void *mem, size_t size, p7uint_t loadaddr, p7uint_t straddr,
p7_disp_t disp);
extern int p7_sendexe_mem(p7_handle_t *p7_arg_handle,
const void *p7_arg_mem, size_t p7_arg_size, p7uint_t p7_arg_loadaddr,
p7uint_t p7_arg_straddr, p7_disp_t *p7_arg_disp);
/* Display streamed screen */
extern int p7_getscreen(p7_handle_t *handle, p7_screenfunc_t callback);
extern int p7_getscreen(p7_handle_t *p7_arg_handle,
p7_screenfunc_t *p7_arg_callback);
# ifdef __cplusplus
}

18
include/libp7/buffer.h
View File

@ -36,19 +36,19 @@
* In each case, the `cookie` is sent as a first argument to your callbacks.
* Here are the prototypes your callbacks must have: */
typedef int (*p7_buffer_read_t)(void*, unsigned char*, size_t);
typedef int (*p7_buffer_write_t)(void*, const unsigned char*, size_t);
typedef int (*p7_buffer_announce_t)(void*, p7uint_t);
typedef int p7_buffer_read_t(void*, unsigned char*, size_t);
typedef int p7_buffer_write_t(void*, const unsigned char*, size_t);
typedef int p7_buffer_announce_t(void*, p7uint_t);
/* And here's the buffer structure, using everything given above: */
typedef struct {
void *cookie;
p7uint_t size;
typedef struct p7_buffer_s {
void *p7_buffer_cookie;
p7uint_t p7_buffer_size;
p7_buffer_read_t read;
p7_buffer_write_t write;
p7_buffer_announce_t announce;
p7_buffer_read_t *p7_buffer_read;
p7_buffer_write_t *p7_buffer_write;
p7_buffer_announce_t *p7_buffer_announce;
} p7_buffer_t;
#endif /* LIBP7_BUFFER_H */

6
include/libp7/internals.h
View File

@ -173,9 +173,11 @@ extern int p7_seven_decode_data(p7_handle_t *handle,
typedef struct {
p7_handle_t *p7handle;
int p7err;
p7_disp_t *disp;
p7ushort_t id, total;
p7uint_t lastsize; /* last packet size */
p7uint_t pos; /* position in current buffer */
unsigned char reserved[8]; /* for use of `send_quick_data_packet` */
unsigned char current[MAX_RAWDATA_SIZE];
} p7_seven_data_cookie_t;
@ -243,11 +245,11 @@ extern int p7_seven_send_err_resend(p7_handle_t *handle);
/* check if buffer is readable */
# define chk_bufread(B) \
if (!(B) || !(B)->read) return (p7_error_noread)
if (!(B) || !(B)->p7_buffer_read) return (p7_error_noread)
/* check if buffer is writable */
# define chk_bufwrite(B) \
if (!(B) || !(B)->write) return (p7_error_nowrite)
if (!(B) || !(B)->p7_buffer_write) return (p7_error_nowrite)
/* check if memory buffer is valid and not empty */
# define chk_mem(M) \

6
include/libp7/packetio.h
View File

@ -30,8 +30,8 @@
/* Since the handle structure is private, here are methods to extract
* things from it. */
extern const p7_stream_t *p7_get_stream(p7_handle_t *handle);
extern const p7_server_t *p7_get_info(p7_handle_t *handle);
extern const p7_packet_t *p7_get_response(p7_handle_t *handle);
extern const p7_stream_t *p7_get_stream(p7_handle_t *p7_arg_handle);
extern const p7_server_t *p7_get_info(p7_handle_t *p7_arg_handle);
extern const p7_packet_t *p7_get_response(p7_handle_t *p7_arg_handle);
#endif /* LIBP7_PACKETIO_H */

19
include/libp7/platform.h
View File

@ -34,26 +34,27 @@ extern "C" {
/* ************************************************************************** */
/* Make a libp7 stream using the standard FILE interface. */
# ifndef P7_DISABLED_FILE
extern int p7_sopen_file(p7_stream_t *stream,
FILE *readstream, FILE *writestream);
extern int p7_sopen_file(p7_stream_t *p7_arg_stream,
FILE *p7_arg_readstream, FILE *p7_arg_writestream);
# endif
/* Make a libp7 stream using the POSIX STREAMS interface. */
# if defined(__linux__)
extern int p7_sopen_streams(p7_stream_t *stream, const char *path,
int readfd, int writefd);
extern int p7_sopen_streams(p7_stream_t *p7_arg_stream, const char *p7_arg_path,
int p7_arg_readfd, int p7_arg_writefd);
# else
# define P7_DISABLED_STREAMS
# endif
/* Make a libp7 stream using libusb. */
# ifndef P7_DISABLED_LIBUSB
extern int p7_sopen_libusb(p7_stream_t *stream);
extern int p7_sopen_libusb(p7_stream_t *p7_arg_stream);
# endif
/* Make a libp7 stream using the Windows API. */
# ifdef __WINDOWS__
extern int p7_sopen_windows(p7_stream_t *stream, const char *path);
extern int p7_sopen_windows(p7_stream_t *p7_arg_stream,
const char *p7_arg_path);
# else
# define P7_DISABLED_WINDOWS
# endif
@ -71,12 +72,14 @@ extern int p7_sopen_windows(p7_stream_t *stream, const char *path);
/* ************************************************************************** */
/* List serial devices on Linux */
# ifdef __linux__
extern int p7_comlist_linux(p7_list_device_t callback, void *cookie);
extern int p7_comlist_linux(p7_list_device_t p7_arg_callback,
void *p7_arg_cookie);
# endif
/* List serial devices on Microsoft Windows */
# ifdef __WINDOWS__
extern int p7_comlist_windows(p7_list_device_t callback, void *cookie);
extern int p7_comlist_windows(p7_list_device_t p7_arg_callback,
void *p7_arg_cookie);
# endif
# ifdef __cplusplus

129
include/libp7/protocol/seven.h
View File

@ -103,22 +103,22 @@ typedef int p7_seven_term_t;
*
* fx-CP/fx-CG devices use the screenstreaming subheader (TYPZ1, TYPZ2): */
typedef struct {
typedef struct p7_typz_subheader_s {
/* ASCII-hex size */
uint8_t size[6];
uint8_t p7_typz_size[6];
/* dimensions */
uint8_t height[4];
uint8_t width[4];
uint8_t p7_typz_height[4];
uint8_t p7_typz_width[4];
/* one: we are number one but it is in ascii (always "1") */
uint8_t one;
uint8_t p7_typz_one;
/* encoding algorithm:
* - RC2: 16-bit mode;
* - RC3: 3-bit mode (1 nib./pxl, red-green-blue-trash)
* - RM2: 2-bit mode? */
uint8_t enc[3];
uint8_t p7_typz_enc[3];
} p7_typz_subheader_t;
/* You shouldn't use it, libp7 takes care of it for you (although the definition
@ -196,11 +196,11 @@ typedef int p7_pictype_t;
*
* You shouldn't use them directly to send a packet, but here they are: */
extern int p7_seven_send_basic(p7_handle_t *handle,
p7_seven_type_t type, p7ushort_t subtype, int resp);
extern int p7_seven_send_ext(p7_handle_t *handle,
p7_seven_type_t type, p7ushort_t subtype,
const void *data, p7ushort_t size, int resp);
extern int p7_seven_send_basic(p7_handle_t *p7_arg_handle,
p7_seven_type_t p7_arg_type, p7ushort_t p7_arg_subtype, int p7_arg_resp);
extern int p7_seven_send_ext(p7_handle_t *p7_arg_handle,
p7_seven_type_t p7_arg_type, p7ushort_t p7_arg_subtype,
const void *p7_arg_data, p7ushort_t p7_arg_size, int p7_arg_resp);
/* Send checks.
* Initial checks are useful to check if there is another device speaking P7
@ -208,10 +208,10 @@ extern int p7_seven_send_ext(p7_handle_t *handle,
* Waiting checks are for the other device which is waiting for a command
* not to timeout (which takes six minutes). */
# define p7_seven_send_check(H) \
(p7_seven_send_basic((H), p7_seven_type_check, p7_seven_chk_wait, 1))
# define p7_seven_send_ini_check(H) \
(p7_seven_send_basic((H), p7_seven_type_check, p7_seven_chk_ini, 1))
# define p7_seven_send_check(P7_ARG_H) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_check, p7_seven_chk_wait, 1))
# define p7_seven_send_ini_check(P7_ARG_H) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_check, p7_seven_chk_ini, 1))
/* Send acknowledgements (ACK packets).
* Basic ACK packets are used for plenty of things (`resp` should always be
@ -219,44 +219,48 @@ extern int p7_seven_send_ext(p7_handle_t *handle,
* Extended ACK is used for sending server information, usually as a response
* to the 0x01 command (sys_getinfo). */
# define p7_seven_send_ack(H, R) \
(p7_seven_send_basic((H), p7_seven_type_ack, 0x00, (R)))
# define p7_seven_confirm_ow(H) \
(p7_seven_send_basic((H), p7_seven_type_ack, 0x01, 1))
extern int p7_seven_send_eack(p7_handle_t *handle, p7_server_t *info);
# define p7_seven_send_ack(P7_ARG_H, P7_ARG_R) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_ack, 0x00, (P7_ARG_R)))
# define p7_seven_confirm_ow(P7_ARG_H) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_ack, 0x01, 1))
extern int p7_seven_send_eack(p7_handle_t *p7_arg_handle,
p7_server_t *p7_arg_info);
/* Send negative acknowledgements (NAK packets).
* These are used to report errors. */
# define p7_seven_send_err(H, C) \
(p7_seven_send_basic((H), p7_seven_type_nak, (C), 1))
# define p7_seven_deny_ow(H) \
(p7_seven_send_err((H), p7_seven_err_dont_overwrite))
# define p7_seven_send_err(P7_ARG_H, P7_ARG_C) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_nak, (P7_ARG_C), 1))
# define p7_seven_deny_ow(P7_ARG_H) \
(p7_seven_send_err((P7_ARG_H), p7_seven_err_dont_overwrite))
/* Send termination packets.
* Will end the communication from the handle point of view. */
# define p7_seven_send_term_because(H, R) \
(p7_seven_send_basic((H), p7_seven_type_end, (R), 1))
# define p7_seven_send_term(H) \
(p7_seven_send_term_because((H), p7_seven_term_default))
# define p7_seven_send_term_because(P7_ARG_H, P7_ARG_R) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_end, (P7_ARG_R), 1))
# define p7_seven_send_term(P7_ARG_H) \
(p7_seven_send_term_because((P7_ARG_H), p7_seven_term_default))
/* Send a roleswap notice.
* Will pass the handle in passive mode. */
# define p7_seven_send_roleswp(H) \
(p7_seven_send_basic((H), p7_seven_type_swp, 0, 1))
# define p7_seven_send_swp(H) (p7_seven_send_roleswp(H))
# define p7_seven_send_roleswp(P7_ARG_H) \
(p7_seven_send_basic((P7_ARG_H), p7_seven_type_swp, 0, 1))
# define p7_seven_send_swp(P7_ARG_H) \
(p7_seven_send_roleswp(P7_ARG_H))
/* Here are the base functions for sending a command.
* There are specific command-sending in `libp7/protocol/seven/commands.h`,
* so if you're using a classical command, you should use them instead. */
extern int p7_seven_send_cmd(p7_handle_t *handle, p7ushort_t subtype);
extern int p7_seven_send_cmd_data(p7_handle_t *handle, p7ushort_t subtype,
int overwrite, p7ushort_t datatype, p7uint_t filesize,
const char *arg1, const char *arg2, const char *arg3,
const char *arg4, const char *arg5, const char *arg6);
extern int p7_seven_send_cmd(p7_handle_t *p7_arg_handle,
p7ushort_t p7_arg_subtype);
extern int p7_seven_send_cmd_data(p7_handle_t *p7_arg_handle,
p7ushort_t p7_arg_subtype, int p7_arg_overwrite,
p7ushort_t p7_arg_datatype, p7uint_t p7_arg_filesize,
const char *p7_arg_arg1, const char *p7_arg_arg2, const char *p7_arg_arg3,
const char *p7_arg_arg4, const char *p7_arg_arg5, const char *p7_arg_arg6);
# include <libp7/protocol/seven/commands.h>
/* ************************************************************************** */
@ -267,29 +271,37 @@ extern int p7_seven_send_cmd_data(p7_handle_t *handle, p7ushort_t subtype,
typedef struct {
/* main info */
unsigned int type;
int extended;
unsigned int p7_seven_packet_type;
int p7_seven_packet_extended;
/* error, termination, check */
int code, initial;
int p7_seven_packet_code;
int p7_seven_packet_initial;
/* commands */
int ow; int mcstype; p7uint_t filesize;
char *args[6]; char _argsdata[6][MAX_CMDARG_SIZE + 1];
p7uint_t uploadsize, loadaddr, straddr; /* 0x56 */
int p7_seven_packet_ow;
int p7_seven_packet_mcstype;
p7uint_t p7_seven_packet_filesize;
char *p7_seven_packet_args[6];
char p7_seven_packet__argsdata[6][MAX_CMDARG_SIZE + 1];
p7uint_t p7_seven_packet_uploadsize;
p7uint_t p7_seven_packet_loadaddr;
p7uint_t p7_seven_packet_straddr;
/* data */
p7ushort_t id, total;
unsigned char data[MAX_RAWDATA_SIZE];
p7ushort_t data_size;
p7ushort_t p7_seven_packet_id;
p7ushort_t p7_seven_packet_total;
unsigned char p7_seven_packet_data[MAX_RAWDATA_SIZE];
p7ushort_t p7_seven_packet_data_size;
/* server information */
p7_server_t info;
p7_server_t p7_seven_packet_info;
/* screen */
p7_pictype_t pictype;
unsigned int height, width;
uint8_t vram[MAX_VRAM_SIZE];
p7_pictype_t p7_seven_packet_pictype;
unsigned int p7_seven_packet_height;
unsigned int p7_seven_packet_width;
uint8_t p7_seven_packet_vram[MAX_VRAM_SIZE];
} p7_seven_packet_t;
typedef p7_seven_packet_t p7_packet_t; /* compatibility */
@ -332,19 +344,22 @@ typedef p7_seven_packet_t p7_packet_t; /* compatibility */
* It is advised not to use it for receiving data, or for sensitive
* data. */
extern int p7_seven_send_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
int shift, p7_disp_t disp);
extern int p7_seven_get_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
p7uint_t size, int shift, p7_disp_t disp);
extern int p7_seven_send_buffer(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer, int p7_arg_shift,
p7_disp_t *p7_arg_disp);
extern int p7_seven_get_buffer(p7_handle_t *p7_arg_handle,
const p7_buffer_t *p7_arg_buffer, p7uint_t p7_arg_size, int p7_arg_shift,
p7_disp_t *p7_arg_disp);
/* Send and receive data, using memory areas.
* Beyond the buffer/memory difference, those and the previous ones are
* basically the same thing. */
extern int p7_seven_send_data(p7_handle_t *handle, const void *vbuf, \
p7uint_t size, int shift, void (*disp)(p7ushort_t, p7ushort_t));
extern int p7_seven_get_data(p7_handle_t *handle, void *buf, p7uint_t size,
int shift, p7_disp_t disp);
extern int p7_seven_send_data(p7_handle_t *p7_arg_handle,
const void *p7_arg_buf, p7uint_t p7_arg_size, int p7_arg_shift,
p7_disp_t *p7_arg_disp);
extern int p7_seven_get_data(p7_handle_t *p7_arg_handle, void *p7_arg_buf,
p7uint_t p7_arg_size, int p7_arg_shift, p7_disp_t *p7_arg_disp);
# ifdef __cplusplus
}

115
include/libp7/protocol/seven/commands.h
View File

@ -23,83 +23,92 @@
# define LIBP7_PROTOCOL_SEVEN_COMMANDS_H
/* Simple command format */
# define p7_sevencmd(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle) { \
return (p7_seven_send_cmd(handle, CODE)); }
# define p7_sevencmd(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle) { \
return (p7_seven_send_cmd(p7_arg_handle, P7_ARG_CODE)); }
/* ************************************************************************** */
/* Main Memory command formats */
/* ************************************************************************** */
/* Send an MCS file */
# define p7_sevencmd_mcsfile_send(C, CODE) \
static inline int p7_send_cmd##C(p7_handle_t *handle, \
int ow, g1m_mcsfile_t *file) { \
# define p7_sevencmd_mcsfile_send(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
int p7_arg_ow, g1m_mcsfile_t *p7_arg_file) { \
size_t P7_SEVENCMD_MCSFILE_SEND_SZ = 0; \
g1m_announce_mcsfile(file, &P7_SEVENCMD_MCSFILE_SEND_SZ); \
return (p7_seven_send_cmd_data(handle, CODE, ow, file->head._rawtype, \
P7_SEVENCMD_MCSFILE_SEND_SZ, (const char*)file->head._dirname, \
file->head.name, (const char*)file->head._group, NULL, NULL, NULL)); }
if (g1m_announce_mcsfile(p7_arg_file, &P7_SEVENCMD_MCSFILE_SEND_SZ)) \
return (p7_error_unknown); \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, p7_arg_ow, \
p7_arg_file->head._rawtype, P7_SEVENCMD_MCSFILE_SEND_SZ, \
(const char*)p7_arg_file->head._dirname, p7_arg_file->head.name, \
(const char*)p7_arg_file->head._group, NULL, NULL, NULL)); }
/* Interact with an MCS file */
# define p7_sevencmd_mcsfile(C, CODE) \
static inline int p7_send_cmd##C(p7_handle_t *handle, \
const g1m_mcshead_t *head) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, head->_rawtype, 0, \
(char*)head->_dirname, (char*)head->name, (char*)head->_group, \
# define p7_sevencmd_mcsfile(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const g1m_mcshead_t *p7_arg_head) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, \
p7_arg_head->_rawtype, 0, (char*)p7_arg_head->_dirname, \
(char*)p7_arg_head->name, (char*)p7_arg_head->_group, \
NULL, NULL, NULL)); }
/* ************************************************************************** */
/* Storage command formats */
/* ************************************************************************** */
/* Interact with a storage device */
# define p7_sevencmd_dev(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
NULL, NULL, NULL, NULL, devname, NULL)); }
# define p7_sevencmd_dev(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
NULL, NULL, NULL, NULL, p7_arg_devname, NULL)); }
/* Interact with a storage directory */
# define p7_sevencmd_dir(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *dirname, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
dirname, NULL, NULL, NULL, devname, NULL)); }
# define p7_sevencmd_dir(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_dirname, const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
p7_arg_dirname, NULL, NULL, NULL, p7_arg_devname, NULL)); }
/* Rename a storage directory */
# define p7_sevencmd_rendir(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *dirname, const char *newdir, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
dirname, newdir, NULL, NULL, devname, NULL)); }
# define p7_sevencmd_rendir(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_dirname, const char *p7_arg_newdir, \
const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
p7_arg_dirname, p7_arg_newdir, NULL, NULL, p7_arg_devname, NULL)); }
/* Interact with a storage file */
# define p7_sevencmd_file(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *dirname, const char *filename, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
dirname, filename, NULL, NULL, devname, NULL)); }
# define p7_sevencmd_file(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_dirname, const char *p7_arg_filename, \
const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
p7_arg_dirname, p7_arg_filename, NULL, NULL, p7_arg_devname, NULL)); }
/* Send a file to storage memory */
# define p7_sevencmd_send(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
int ow, p7uint_t fs, \
const char *dirname, const char *filename, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, ow, 0, fs, \
dirname, filename, NULL, NULL, devname, NULL)); }
# define p7_sevencmd_send(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
int p7_arg_ow, p7uint_t p7_arg_fs, const char *p7_arg_dirname, \
const char *p7_arg_filename, const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, p7_arg_ow, 0, \
p7_arg_fs, p7_arg_dirname, p7_arg_filename, \
NULL, NULL, p7_arg_devname, NULL)); }
/* Copy a file on storage memory */
# define p7_sevencmd_copy(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *dirname, const char *filename, \
const char *newdir, const char *newname, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
dirname, filename, newdir, newname, devname, NULL)); }
# define p7_sevencmd_copy(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_dirname, const char *p7_arg_filename, \
const char *p7_arg_newdir, const char *p7_arg_newname, \
const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
p7_arg_dirname, p7_arg_filename, p7_arg_newdir, \
p7_arg_newname, p7_arg_devname, NULL)); }
/* Rename a file on storage memory */
# define p7_sevencmd_rename(C, CODE) \
static inline int p7_seven_send_cmd##C(p7_handle_t *handle, \
const char *dirname, const char *filename, \
const char *newname, const char *devname) { \
return (p7_seven_send_cmd_data(handle, CODE, 0, 0, 0, \
dirname, filename, NULL, newname, devname, NULL)); }
# define p7_sevencmd_rename(P7_ARG_C, P7_ARG_CODE) \
static inline int p7_seven_send_cmd##P7_ARG_C(p7_handle_t *p7_arg_handle, \
const char *p7_arg_dirname, const char *p7_arg_filename, \
const char *p7_arg_newname, const char *p7_arg_devname) { \
return (p7_seven_send_cmd_data(p7_arg_handle, P7_ARG_CODE, 0, 0, 0, \
p7_arg_dirname, p7_arg_filename, NULL, p7_arg_newname, \
p7_arg_devname, NULL)); }
/* ************************************************************************** */
/* Known commands */
/* ************************************************************************** */

8
include/libp7/server.h
View File

@ -31,13 +31,13 @@ extern "C" {
*
* Here is the function for serving directly: */
extern int p7_serve_directly(p7_handle_t *handle,
p7_server_callback_t *callbacks, void *cookie);
extern int p7_serve_directly(p7_handle_t *p7_arg_handle,
p7_server_callback_t **p7_arg_callbacks, void *p7_arg_cookie);
/* And here is the function for serving a 'classical' server: */
extern int p7_serve(p7_handle_t *handle, p7_server_t *info,
p7_filesystem_t *filesystems);
extern int p7_serve(p7_handle_t *p7_arg_handle, p7_server_t *p7_arg_info,
p7_filesystem_t *p7_arg_filesystems);
# ifdef __cplusplus
}

89
include/libp7/stream.h
View File

@ -72,33 +72,31 @@ typedef struct p7_scsi_s p7_scsi_t;
/* Here are the callback types: */
typedef int (*p7_stream_close_t)(void*);
typedef int (*p7_stream_setcomm_t)(void*, const p7_streamsettings_t*);
typedef int (*p7_stream_settm_t)(void*, const p7_streamtimeouts_t*);
typedef int (*p7_stream_read_t)(void*, unsigned char*, size_t);
typedef int (*p7_stream_write_t)(void*, const unsigned char*, size_t);
typedef int (*p7_stream_scsi_request_t)(void*, p7_scsi_t*);
typedef int (p7_stream_close_t)(void*);
typedef int (p7_stream_setcomm_t)(void*, const p7_streamsettings_t*);
typedef int (p7_stream_settm_t)(void*, const p7_streamtimeouts_t*);
typedef int (p7_stream_read_t)(void*, unsigned char*, size_t);
typedef int (p7_stream_write_t)(void*, const unsigned char*, size_t);
typedef int (p7_stream_scsi_request_t)(void*, p7_scsi_t*);
/* Here is the stream structure: */
typedef struct p7_stream_s {
/* stream information */
unsigned int flags;
void *cookie;
unsigned int p7_stream_flags;
void *p7_stream_cookie;
/* main callbacks */
p7_stream_close_t close;
p7_stream_close_t *p7_stream_close;
/* settings callbacks */
p7_stream_setcomm_t setcomm;
p7_stream_settm_t settm;
p7_stream_setcomm_t *p7_stream_setcomm;
p7_stream_settm_t *p7_stream_settm;
/* character callbacks */
p7_stream_read_t read;
p7_stream_write_t write;
p7_stream_read_t *p7_stream_read;
p7_stream_write_t *p7_stream_write;
/* SCSI callbacks */
p7_stream_scsi_request_t scsi_request;
p7_stream_scsi_request_t *p7_stream_scsi_request;
} p7_stream_t;
/* Warning: in your stream initialization function, you shouldn't initialize
@ -152,13 +150,13 @@ typedef struct p7_stream_s {
# define P7_DTRCTL_DISABLE 0x0000 /* disable DTR */
# define P7_DTRCTL_ENABLE 0x0008 /* enable DTR */
# define P7_DTRCTL_HANDSHAKE 0x0010 /* enable DTR and handshake */
# define P7_DTRVAL(F) (((F) & P7_DTRMASK) >> 3)
# define P7_DTRVAL(P7_ARG_F) (((P7_ARG_F) & P7_DTRMASK) >> 3)
# define P7_RTSMASK 0x0060
# define P7_RTSCTL_DISABLE 0x0000 /* disable RTS */
# define P7_RTSCTL_ENABLE 0x0020 /* enable RTS */
# define P7_RTSCTL_HANDSHAKE 0x0040 /* enable RTS and handshake */
# define P7_RTSVAL(F) (((F) & P7_RTSMASK) >> 5)
# define P7_RTSVAL(P7_ARG_F) (((P7_ARG_F) & P7_RTSMASK) >> 5)
/* Here are the XON/XOFF software control settings.
* XOFF disables the transmission temporarily, usually because the device at
@ -181,13 +179,13 @@ typedef struct p7_stream_s {
struct p7_streamsettings_s {
/* flags - see the above section */
unsigned int flags;
unsigned int p7_streamsettings_flags;
/* speed: one of the P7_B* constants */
unsigned int speed;
unsigned int p7_streamsettings_speed;
/* characters */
unsigned char cc[P7_NCCS];
unsigned char p7_streamsettings_cc[P7_NCCS];
};
/* This structure will be sent to your `setcomm` callback to set serial
@ -196,13 +194,13 @@ struct p7_streamsettings_s {
struct p7_streamtimeouts_s {
/* Initial read timeout */
unsigned int read;
unsigned int p7_streamtimeouts_read;
/* In-between bytes read timeout */
unsigned int read_bw;
unsigned int p7_streamtimeouts_read_bw;
/* Total write timeout */
unsigned int write;
unsigned int p7_streamtimeouts_write;
};
/* This structure will be sent to your `settm` callback, usually after a state
@ -228,16 +226,21 @@ struct p7_streamtimeouts_s {
struct p7_scsi_s {
/* command description */
int type, direction;
unsigned int byte_transfer_length;
unsigned long logical_block, allocation_length;
unsigned char cbp[4], misc;
int p7_scsi_type;
int p7_scsi_direction;
unsigned int p7_scsi_byte_transfer_length;
unsigned long p7_scsi_logical_block;
unsigned long p7_scsi_allocation_length;
unsigned char p7_scsi_cbp[4];
unsigned char p7_scsi_misc;
/* raw data */
unsigned int cmd_len, data_len, sense_len;
unsigned char cmd[16];
unsigned char *data;
unsigned char *sense;
unsigned int p7_scsi_cmd_len;
unsigned int p7_scsi_data_len;
unsigned int p7_scsi_sense_len;
unsigned char p7_scsi_cmd[16];
unsigned char *p7_scsi_data;
unsigned char *p7_scsi_sense;
/* TODO: output thingies? */
};
@ -247,23 +250,27 @@ struct p7_scsi_s {
/* Public stream functions */
/* ************************************************************************** */
/* Initialize a handle using a custom stream. */
extern int p7_sinit(p7_handle_t **h, unsigned int flags,
const char *name, p7_stream_t *stream,
const p7_streamsettings_t *settings);
extern int p7_sinit(p7_handle_t **p7_arg_h, unsigned int p7_arg_flags,
const char *p7_arg_name, p7_stream_t *p7_arg_stream,
const p7_streamsettings_t *p7_arg_settings);
/* Default stream serial settings utilities.
* `p7_initcomm` initializes a stream settings structure. */
extern void p7_initcomm(p7_streamsettings_t *settings);
extern void p7_initcomm(p7_streamsettings_t *p7_arg_settings);
/* Read and write data from and to a stream, set stream settings and timeouts.
* You should use these functions instead of the callbacks directly. */
extern int p7_read(p7_stream_t *stream, void *dest, size_t size);
extern int p7_write(p7_stream_t *stream, const void *data, size_t size);
extern int p7_setcomm(p7_stream_t *stream, const p7_streamsettings_t *settings);
extern int p7_settm(p7_stream_t *stream, const p7_streamtimeouts_t *timeouts);
extern int p7_read(p7_stream_t *p7_arg_stream, void *p7_arg_dest,
size_t p7_arg_size);
extern int p7_write(p7_stream_t *p7_arg_stream, const void *p7_arg_data,
size_t p7_arg_size);
extern int p7_setcomm(p7_stream_t *p7_arg_stream,
const p7_streamsettings_t *p7_arg_settings);
extern int p7_settm(p7_stream_t *p7_arg_stream,
const p7_streamtimeouts_t *p7_arg_timeouts);
/* Skip bytes from a stream. */
extern int p7_skip(p7_stream_t *stream, size_t size);
extern int p7_skip(p7_stream_t *p7_arg_stream, size_t p7_arg_size);
# ifdef __cplusplus
}

98
include/libp7/types.h
View File

@ -90,14 +90,14 @@ extern const size_t p7_handle_size;
* This callback is for serial devices listing; for each device found, the
* callback is found with its device. */
typedef void (*p7_list_device_t)(void*, const char*);
typedef void p7_list_device_t(void*, const char*);
/* p7_screenfunc_t:
* This callback is for `p7_getscreen`: when a screen is received, it is called
* with the width, the height and the pixels, and returns either 1 if we should
* continue, or 0 if we should stop. */
typedef int (*p7_screenfunc_t)(int, int, uint32_t**);
typedef int p7_screenfunc_t(int, int, uint32_t**);
/* p7_disp_t:
* This callback is for displaying the progress of an operation (usually
@ -105,14 +105,14 @@ typedef int (*p7_screenfunc_t)(int, int, uint32_t**);
* packets. For initialization of the display, this callback is called with
* a packet ID superior to the number of packets. */
typedef void (*p7_disp_t)(p7ushort_t, p7ushort_t);
typedef void p7_disp_t(p7ushort_t, p7ushort_t);
/* p7_confirm_t:
* This callback is for if a confirmation needs to be obtained from the user
* (usually before overwriting a file). Returns 0 if the user has denied,
* and something else if he has confirmed. */
typedef int (*p7_confirm_t)(void);
typedef int p7_confirm_t(void);
/* p7_list_t:
* This callback is for storage file listing.
@ -121,39 +121,30 @@ typedef int (*p7_confirm_t)(void);
* file name (NULL if the entry is a directory), and the last argument
* is the filesize, if the entry is a file. */
typedef void (*p7_list_t)(void*, const char*, const char*, p7uint_t);
typedef void p7_list_t(void*, const char*, const char*, p7uint_t);
/* p7_mcslist_t:
* Basically the same as the previous one, but with the main memory.
* The MCS head given by libg1m contains the complementary information. */
typedef void (*p7_mcslist_t)(void*, const g1m_mcshead_t*);
typedef void p7_mcslist_t(void*, const g1m_mcshead_t*);
/* p7_server_callback_t:
* A basic server callback, for direct server. */
typedef int (*p7_server_callback_t)(void *cookie, p7_handle_t *handle);
typedef int p7_server_callback_t(void *cookie, p7_handle_t *handle);
/* ************************************************************************** */
/* Useful types */
/* ************************************************************************** */
/* An OS version. Must be of ASCII-DEC format MM.mm.ffff, where MM is the
* major, mm is the minor and ffff is the revision (flags). */
typedef struct {
unsigned int major;
unsigned int minor;
unsigned int rev;
} p7_version_t;
/* A CASIOWIN entry, which is the 0x80 bytes long entry at the beginning of
* the OS the bootcode reads for recognizing and running the OS. */
typedef struct {
/* OS version */
p7_version_t version;
g1m_version_t p7_casiowin_entry_version;
/* Syscall table address */
p7uint_t syscall_table_offset;
p7uint_t p7_casiowin_entry_syscall_table_offset;
} p7_casiowin_entry_t;
/* ************************************************************************** */
/* Server information */
@ -164,52 +155,69 @@ typedef struct {
* a classical server - see `libp7/server.h`. */
typedef struct {
/* main information */
char product_id[17], username[17];
char hwid[9], cpuid[17];
/* preprogrammed ROM info */
int preprog_rom_wiped;
p7uint_t preprog_rom_capacity;
p7_version_t preprog_rom_version;
int p7_server_preprog_rom_wiped;
p7uint_t p7_server_preprog_rom_capacity;
g1m_version_t p7_server_preprog_rom_version;
/* flash ROM and RAM info */
p7uint_t flash_rom_capacity, ram_capacity;
p7uint_t p7_server_flash_rom_capacity;
p7uint_t p7_server_ram_capacity;
/* bootcode info */
int bootcode_wiped;
p7_version_t bootcode_version;
p7uint_t bootcode_offset, bootcode_size;
int p7_server_bootcode_wiped;
g1m_version_t p7_server_bootcode_version;
p7uint_t p7_server_bootcode_offset;
p7uint_t p7_server_bootcode_size;
/* OS information */
int os_wiped;
p7_version_t os_version;
p7uint_t os_offset, os_size;
int p7_server_os_wiped;
g1m_version_t p7_server_os_version;
p7uint_t p7_server_os_offset;
p7uint_t p7_server_os_size;
/* addresses - for serving */
const unsigned char *flash_rom, *ram;
const unsigned char *casiowin_entry, *bootcode;
} p7_server_t;
const unsigned char *p7_server_flash_rom;
const unsigned char *p7_server_ram;
const unsigned char *p7_server_casiowin_entry;
const unsigned char *p7_server_bootcode;
/* And here is the filesystem structure for serving using a classical
/* main information */
char p7_server_product_id[17];
char p7_server_username[17];
char p7_server_hwid[9];
char p7_server_cpuid[17];
} p7_server_t;
/* ************************************************************************** */
/* Server filesystem structure, for serving */
/* ************************************************************************** */
/* And here, we define the filesystem structure for serving using a classical
* Protocol 7.00 server (see `libp7/server.h`).
* First, here are the callbacks: */
typedef int p7_filesystem_directory_exists_t(void*, const char *p7_arg_dirname);
typedef int p7_filesystem_create_directory_t(void*, const char *p7_arg_dirname);
typedef int p7_filesystem_delete_directory_t(void*, const char *p7_arg_dirname);
typedef int p7_filesystem_rename_directory_t(void*, const char *p7_arg_dirname,
const char *p7_arg_newdir);
/* Then, here is the filesystem structure.
* It contains the static information, the callbacks and the working
* information (fields used while serving). */
typedef struct {
/* filesystem metadata */
const char *name;
void *cookie;
const char *p7_filesystem_name;
void *p7_filesystem_cookie;
/* directory commands */
int (*directory_exists)(void *cookie, const char *dirname);
int (*create_directory)(void *cookie, const char *dirname);
int (*delete_directory)(void *cookie, const char *dirname);
int (*rename_directory)(void *cookie, const char *dirname,
const char *newdir);
p7_filesystem_directory_exists_t *p7_filesystem_directory_exists;
p7_filesystem_create_directory_t *p7_filesystem_create_directory;
p7_filesystem_delete_directory_t *p7_filesystem_delete_directory;
p7_filesystem_rename_directory_t *p7_filesystem_rename_directory;
/* working things - only libp7 should manipulate those */
char *working_directory, _wd[257];
char *p7_filesystem_working_directory;
char p7_filesystem__wd[257];
} p7_filesystem_t;
# ifdef __cplusplus

2
src/core/_init.c
View File

@ -170,7 +170,7 @@ void p7_exit(p7_handle_t *handle)
p7_seven_end(handle);
/* close stream */
(*handle->_stream.close)(handle->_stream.cookie);
(*handle->_stream.p7_stream_close)(handle->_stream.p7_stream_cookie);
/* free handle */
log_info("freeing the handle!");

41
src/core/stream.c
View File

@ -39,7 +39,7 @@
int p7_read(p7_stream_t *stream, void *dest, size_t size)
{
int err;
if (stream->flags & p7_streamflag_scsi || !stream->read)
if (stream->p7_stream_flags & p7_streamflag_scsi || !stream->p7_stream_read)
return (p7_error_noread);
if (!size) return (0);
@ -48,13 +48,13 @@ int p7_read(p7_stream_t *stream, void *dest, size_t size)
* FIXME: this won't help the legacy protocol lol */
unsigned char byte;
do {
err = (*stream->read)(stream->cookie, &byte, 1);
err = (*stream->p7_stream_read)(stream->p7_stream_cookie, &byte, 1);
if (err) return (err);
} while (byte == 0x10 || byte == 0x16);
/* return real result */
unsigned char *d = (void*)dest; *d++ = byte; size--;
err = (*stream->read)(stream->cookie, d, size);
err = (*stream->p7_stream_read)(stream->p7_stream_cookie, d, size);
return (err);
}
@ -70,9 +70,10 @@ int p7_read(p7_stream_t *stream, void *dest, size_t size)
int p7_write(p7_stream_t *stream, const void *data, size_t size)
{
if (stream->flags & p7_streamflag_scsi || !stream->write)
if (stream->p7_stream_flags & p7_streamflag_scsi
|| !stream->p7_stream_write)
return (p7_error_nowrite);
return ((*stream->write)(stream->cookie,
return ((*stream->p7_stream_write)(stream->p7_stream_cookie,
(const unsigned char*)data, size));
}
/* ************************************************************************** */
@ -89,11 +90,11 @@ int p7_write(p7_stream_t *stream, const void *data, size_t size)
int p7_setcomm(p7_stream_t *stream, const p7_streamsettings_t *settings)
{
if (stream->flags & p7_streamflag_usb) {
if (stream->p7_stream_flags & p7_streamflag_usb) {
logr_info("Stream is an USB device!");
return (0);
}
if (!stream->setcomm) {
if (!stream->p7_stream_setcomm) {
logr_info("No communication manager for this stream.");
return (0);
}
@ -110,22 +111,26 @@ int p7_setcomm(p7_stream_t *stream, const p7_streamsettings_t *settings)
const char *es[] = {"disabled", "enabled", "handshake", "disabled"};
logr_info("Setting serial settings: %u%c%c",
settings->speed, ~settings->flags & P7_PARENB ? 'N'
: settings->flags & P7_PARODD ? 'O' : 'E',
settings->flags & P7_TWOSTOPBITS ? '2' : '1');
settings->p7_streamsettings_speed,
~settings->p7_streamsettings_flags & P7_PARENB ? 'N'
: settings->p7_streamsettings_flags & P7_PARODD ? 'O' : 'E',
settings->p7_streamsettings_flags & P7_TWOSTOPBITS ? '2' : '1');
logr_info("DTR mode: %s, RTS mode: %s",
es[P7_DTRVAL(settings->flags)], es[P7_RTSVAL(settings->flags)]);
es[P7_DTRVAL(settings->p7_streamsettings_flags)],
es[P7_RTSVAL(settings->p7_streamsettings_flags)]);
if (settings->flags & P7_XONMASK)
logr_info("XON is enabled (0x%02X)", settings->cc[P7_XON]);
if (settings->p7_streamsettings_flags & P7_XONMASK)
logr_info("XON is enabled (0x%02X)",
settings->p7_streamsettings_cc[P7_XON]);
else logr_info("XON is disabled");
if (settings->flags & P7_XOFFMASK)
logr_info("XOFF is enabled (0x%02X)", settings->cc[P7_XOFF]);
if (settings->p7_streamsettings_flags & P7_XOFFMASK)
logr_info("XOFF is enabled (0x%02X)",
settings->p7_streamsettings_cc[P7_XOFF]);
else logr_info("XOFF is disabled");
#endif
/* then make */
return ((*stream->setcomm)(stream->cookie, settings));
return ((*stream->p7_stream_setcomm)(stream->p7_stream_cookie, settings));
}
/**
@ -139,6 +144,6 @@ int p7_setcomm(p7_stream_t *stream, const p7_streamsettings_t *settings)
int p7_settm(p7_stream_t *stream, const p7_streamtimeouts_t *timeouts)
{
if (!stream->settm) return (0);
return ((*stream->settm)(stream->cookie, timeouts));
if (!stream->p7_stream_settm) return (0);
return ((*stream->p7_stream_settm)(stream->p7_stream_cookie, timeouts));
}

6
src/platform/comlist/linux.c
View File

@ -41,12 +41,12 @@
int p7_comlist_linux(p7_list_device_t callback, void *cookie)
{
/* open the thing */
char path[1025]; strcpy(path, "/dev/serial/by-id/");
char path[PATH_MAX + 1]; strcpy(path, "/dev/serial/by-id/");
DIR *d = opendir(path);
if (!d) return (0);
/* prepare */
char *f = strchr(path, 0), devname[1025];
char *f = strchr(path, 0), devname[PATH_MAX + 1];
/* read the entries */
struct dirent *dr; struct stat st;
@ -57,7 +57,7 @@ int p7_comlist_linux(p7_list_device_t callback, void *cookie)
continue;
/* get destination path and send it */
ssize_t rl = readlink(path, devname, 1025);
ssize_t rl = readlink(path, devname, PATH_MAX + 1);
if (rl < 0) continue;
devname[rl] = 0;
if (devname[0] == '/')

13
src/platform/stream/file.c
View File

@ -197,12 +197,13 @@ int p7_sopen_file(p7_stream_t *stream, FILE *rstream, FILE *wstream)
};
/* initialize da stream */
stream->flags = p7_streamflag_usb; /* TODO: make a 'virtual stream' type? */
stream->cookie = cookie;
stream->read = p7_file_read;
stream->write = p7_file_write;
stream->close = p7_file_close;
stream->settm = NULL;
stream->p7_stream_flags = p7_streamflag_usb; /* TODO: make a
* 'virtual stream' type? */
stream->p7_stream_cookie = cookie;
stream->p7_stream_read = p7_file_read;
stream->p7_stream_write = p7_file_write;
stream->p7_stream_close = p7_file_close;
stream->p7_stream_settm = NULL;
return (0);
}

18
src/platform/stream/libusb.c
View File

@ -52,8 +52,8 @@ static int p7_libusb_settm(void *vcookie, const p7_streamtimeouts_t *timeouts)
libusb_cookie_t *cookie = (void*)vcookie;
/* set the timeouts */
cookie->tmread = timeouts->read;
cookie->tmwrite = timeouts->write;
cookie->tmread = timeouts->p7_streamtimeouts_read;
cookie->tmwrite = timeouts->p7_streamtimeouts_write;
/* no error! */
return (0);
@ -199,7 +199,7 @@ int p7_sopen_libusb(p7_stream_t *stream)
int err = 0;
libusb_context *context = NULL;
libusb_device_handle *dhandle = NULL;
stream->flags = p7_streamflag_usb;
stream->p7_stream_flags = p7_streamflag_usb;
/* open up context */
if (libusb_init(&context)) {
@ -233,7 +233,7 @@ int p7_sopen_libusb(p7_stream_t *stream)
/* check if is a CASIO SCSI device */
if (descriptor.idVendor == 0x07cf && descriptor.idProduct == 0x6102) {
calc = device_list[id];
stream->flags |= p7_streamflag_usb;
stream->p7_stream_flags |= p7_streamflag_usb;
break;
}
}
@ -320,11 +320,11 @@ int p7_sopen_libusb(p7_stream_t *stream)
};
/* final call. */
stream->cookie = cookie;
stream->read = p7_libusb_read;
stream->write = p7_libusb_write;
stream->close = p7_libusb_close;
stream->settm = p7_libusb_settm;
stream->p7_stream_cookie = cookie;
stream->p7_stream_read = p7_libusb_read;
stream->p7_stream_write = p7_libusb_write;
stream->p7_stream_close = p7_libusb_close;
stream->p7_stream_settm = p7_libusb_settm;
err = 0;
fail:
if (err) {

46
src/platform/stream/streams.c
View File

@ -55,7 +55,7 @@ static int setcomm_for_fd(const int fd, const p7_streamsettings_t *settings)
{
/* get the speed */
speed_t speed;
switch (settings->speed) {
switch (settings->p7_streamsettings_speed) {
case P7_B1200: speed = B1200; break;
case P7_B2400: speed = B2400; break;
case P7_B4800: speed = B4800; break;
@ -65,7 +65,8 @@ static int setcomm_for_fd(const int fd, const p7_streamsettings_t *settings)
case P7_B57600: speed = B57600; break;
case P7_B115200: speed = B115200; break;
default:
logr_info("Speed was unsupported by termios: %u", settings->speed);
logr_info("Speed was unsupported by termios: %u",
settings->p7_streamsettings_speed);
return (p7_error_unsupported);
}
@ -81,8 +82,8 @@ static int setcomm_for_fd(const int fd, const p7_streamsettings_t *settings)
/* input flags */
term.c_iflag &= ~(IGNBRK | IGNCR | BRKINT | PARMRK | ISTRIP | INLCR
| ICRNL | IGNPAR | IXON | IXOFF);
if (settings->flags & P7_XONMASK) term.c_iflag |= IXON;
if (settings->flags & P7_XOFFMASK) term.c_iflag |= IXOFF;
if (settings->p7_streamsettings_flags & P7_XONMASK) term.c_iflag |= IXON;
if (settings->p7_streamsettings_flags & P7_XOFFMASK) term.c_iflag |= IXOFF;
/* output flags, local modes */
term.c_oflag = 0;
@ -91,13 +92,14 @@ static int setcomm_for_fd(const int fd, const p7_streamsettings_t *settings)
/* control flags */
term.c_cflag &= ~(PARENB | PARODD | CREAD | CSTOPB | CSIZE);
term.c_cflag |= CREAD | CS8;
if (settings->flags & P7_TWOSTOPBITS) term.c_cflag |= CSTOPB;
if (settings->flags & P7_PARENB) term.c_cflag |= PARENB;
if (settings->flags & P7_PARODD) term.c_cflag |= PARODD;
if (settings->p7_streamsettings_flags & P7_TWOSTOPBITS)
term.c_cflag |= CSTOPB;
if (settings->p7_streamsettings_flags & P7_PARENB) term.c_cflag |= PARENB;
if (settings->p7_streamsettings_flags & P7_PARODD) term.c_cflag |= PARODD;
/* control characters */
term.c_cc[VSTART] = settings->cc[P7_XON];
term.c_cc[VSTOP] = settings->cc[P7_XOFF];
term.c_cc[VSTART] = settings->p7_streamsettings_cc[P7_XON];
term.c_cc[VSTOP] = settings->p7_streamsettings_cc[P7_XOFF];
term.c_cc[VMIN] = 0; /* ? */
/* update the termios settings! */
@ -109,11 +111,11 @@ static int setcomm_for_fd(const int fd, const p7_streamsettings_t *settings)
status &= ~(TIOCM_DTR | TIOCM_RTS);
/* activate DTR and RTS */
if ((settings->flags & P7_DTRMASK) == P7_DTRCTL_ENABLE
|| (settings->flags & P7_DTRMASK) == P7_DTRCTL_HANDSHAKE)
if ((settings->p7_streamsettings_flags & P7_DTRMASK) == P7_DTRCTL_ENABLE
|| (settings->p7_streamsettings_flags & P7_DTRMASK) == P7_DTRCTL_HANDSHAKE)
status |= TIOCM_DTR;
if ((settings->flags & P7_RTSMASK) == P7_RTSCTL_ENABLE
|| (settings->flags & P7_RTSMASK) == P7_RTSCTL_HANDSHAKE)
if ((settings->p7_streamsettings_flags & P7_RTSMASK) == P7_RTSCTL_ENABLE
|| (settings->p7_streamsettings_flags & P7_RTSMASK) == P7_RTSCTL_HANDSHAKE)
status |= TIOCM_RTS;
if (ioctl(fd, TIOCMSET, &status) < 0)
return (p7_error_unknown);
@ -165,7 +167,7 @@ static int p7_streams_settm(void *vcookie, const p7_streamtimeouts_t *timeouts)
struct termios term;
if (!tcgetattr(cookie->_readfd, &term)) {
/* set the timeout */
term.c_cc[VTIME] = timeouts->read / 100;
term.c_cc[VTIME] = timeouts->p7_streamtimeouts_read / 100;
/* update */
if (tcsetattr(cookie->_readfd, TCSANOW, &term))
@ -175,7 +177,7 @@ static int p7_streams_settm(void *vcookie, const p7_streamtimeouts_t *timeouts)
/* set on the write thing */
if (cookie->_readfd != cookie->_writefd
&& !tcgetattr(cookie->_writefd, &term)) {
term.c_cc[VTIME] = timeouts->write / 100;
term.c_cc[VTIME] = timeouts->p7_streamtimeouts_write / 100;
/* update */
if (tcsetattr(cookie->_writefd, TCSANOW, &term))
@ -422,13 +424,13 @@ int p7_sopen_streams(p7_stream_t *stream, const char *path,
/* init for real */
logr_info("Initializing STREAMS stream with fds: (%d, %d)",
readfd, writefd);
stream->flags = p7_streamflag_serial; /* TODO: USB? SCSI? */
stream->cookie = cookie;
stream->read = p7_streams_read;
stream->write = p7_streams_write;
stream->setcomm = p7_streams_setcomm;
stream->settm = p7_streams_settm;
stream->close = p7_streams_close;
stream->p7_stream_flags = p7_streamflag_serial; /* TODO: USB? SCSI? */
stream->p7_stream_cookie = cookie;
stream->p7_stream_read = p7_streams_read;
stream->p7_stream_write = p7_streams_write;
stream->p7_stream_setcomm = p7_streams_setcomm;
stream->p7_stream_settm = p7_streams_settm;
stream->p7_stream_close = p7_streams_close;
/* end */
err = 0;

33
src/protocol/seven/command.c
View File

@ -164,7 +164,7 @@ int p7_seven_send_cmdsys_setlink(p7_handle_t *handle,
int baudrate, int parity, int stopbits)
{
/* check if is a serial connexion */
if (handle->_stream.flags & p7_streamflag_usb)
if (handle->_stream.p7_stream_flags & p7_streamflag_usb)
return (p7_error_unsupported);
/* make arguments */
@ -220,12 +220,13 @@ int p7_seven_send_cmdosu_upandrun(p7_handle_t *handle,
/* macro to copy an argument into the packet */
#define cpy_arg(I) { \
size_t ALEN = arglengths[I]; \
memcpy(packet->_argsdata[I], p, ALEN); \
packet->_argsdata[I][ALEN] = 0; \
packet->args[I] = ALEN ? packet->_argsdata[I] : NULL; \
memcpy(packet->p7_seven_packet__argsdata[I], p, ALEN); \
packet->p7_seven_packet__argsdata[I][ALEN] = 0; \
packet->p7_seven_packet_args[I] = ALEN ? \
packet->p7_seven_packet__argsdata[I] : NULL; \
p += ALEN; \
\
log_info("D%d is '%s'", I, packet->args[I]); }
log_info("D%d is '%s'", I, packet->p7_seven_packet_args[I]); }
/**
* p7_seven_decode_command:
@ -244,11 +245,11 @@ int p7_seven_decode_command(p7_handle_t *handle,
{
p7_packet_t *packet = &handle->_response;
/* check up_and_run command */
if (packet->code == p7_seven_cmdosu_upandrun) {
if (packet->p7_seven_packet_code == p7_seven_cmdosu_upandrun) {
if (raw_size != 12) return (1);
packet->uploadsize = p7_getascii(raw, 4);
packet->loadaddr = p7_getascii(&raw[4], 4);
packet->straddr = p7_getascii(&raw[8], 4);
packet->p7_seven_packet_uploadsize = p7_getascii(raw, 4);
packet->p7_seven_packet_loadaddr = p7_getascii(&raw[4], 4);
packet->p7_seven_packet_straddr = p7_getascii(&raw[8], 4);
return (0);
}
@ -256,17 +257,19 @@ int p7_seven_decode_command(p7_handle_t *handle,
if (raw_size < 24) return (1);
/* get overwrite */
packet->ow = p7_getascii(raw, 2);
packet->p7_seven_packet_ow = p7_getascii(raw, 2);
log_info("overwrite mode is '%s' (0x%02x)",
getowstring(packet->ow), packet->ow);
getowstring(packet->p7_seven_packet_ow),
packet->p7_seven_packet_ow);
/* get data type */
packet->mcstype = p7_getascii(&raw[2], 2);
log_info("datatype is 0x%02x", packet->mcstype);
packet->p7_seven_packet_mcstype = p7_getascii(&raw[2], 2);
log_info("datatype is 0x%02x", packet->p7_seven_packet_mcstype);
/* filesize */
packet->filesize = p7_getascii(&raw[4], 8);
log_info("filesize is %" PRIuP7INT "o", packet->filesize);
packet->p7_seven_packet_filesize = p7_getascii(&raw[4], 8);
log_info("filesize is %" PRIuP7INT "o",
packet->p7_seven_packet_filesize);
/* args length */
size_t arglengths[6] = {

82
src/protocol/seven/data.c
View File

@ -133,7 +133,8 @@ int p7_seven_send_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
/* dynamically allocate buffer */
unsigned int bufsize = MAX_RAWDATA_SIZE * BUFNUM;
bufsize = buffer->size < bufsize ? buffer->size : bufsize;
bufsize = buffer->p7_buffer_size < bufsize
? buffer->p7_buffer_size : bufsize;
unsigned char *buf = malloc(8 + bufsize);
if (!buf) {
log_fatal("Couldn't allocate file buffer");
@ -141,8 +142,8 @@ int p7_seven_send_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
}
/* get total and last packet size */
unsigned int lastpacket_size = buffer->size % MAX_RAWDATA_SIZE;
unsigned int total = buffer->size / MAX_RAWDATA_SIZE
unsigned int lastpacket_size = buffer->p7_buffer_size % MAX_RAWDATA_SIZE;
unsigned int total = buffer->p7_buffer_size / MAX_RAWDATA_SIZE
+ !!lastpacket_size; /* left data */
if (!lastpacket_size) lastpacket_size = MAX_RAWDATA_SIZE;
@ -153,7 +154,8 @@ int p7_seven_send_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
unsigned int datasize = MAX_RAWDATA_SIZE; int resp = !shift;
for (unsigned int id = 1; id <= total;) {
/* read big block */
if ((err = (*buffer->read)(buffer->cookie, 8 + buf, bufsize)))
if ((err = (*buffer->p7_buffer_read)(buffer->p7_buffer_cookie,
8 + buf, bufsize)))
return (err);
/* then send each block */
@ -178,7 +180,7 @@ int p7_seven_send_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
resp = 1;
/* - check response - */
if (response.type != p7_seven_type_ack) {
if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_error("calculator didn't send ack, weird");
err = p7_error_unknown;
goto fail;
@ -218,7 +220,8 @@ int p7_seven_get_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
int err = 0;
/* announce */
if (buffer->announce && (err = (*buffer->announce)(buffer->cookie, size)))
if (buffer->p7_buffer_announce
&& (err = (*buffer->p7_buffer_announce)(buffer->p7_buffer_cookie, size)))
return (err);
/* dynamically allocate buf size */
@ -250,36 +253,39 @@ int p7_seven_get_buffer(p7_handle_t *handle, const p7_buffer_t *buffer,
}
/* if packet is not data, wtf casio? */
if (response.type != p7_seven_type_data) {
if (response.p7_seven_packet_type != p7_seven_type_data) {
log_fatal("packet type was unplanned, wtf ?");
err = p7_error_unknown;
goto fail;
}
/* displaying */
if (disp) (*disp)(response.id, response.total);
if (disp) (*disp)(response.p7_seven_packet_id,
response.p7_seven_packet_total);
/* check overflow */
if ((size_t)response.data_size > size) {
if ((size_t)response.p7_seven_packet_data_size > size) {
log_fatal("%" PRIuP7SHORT " bytes received... "
"that's more than the %" PRIuP7INT " expected. "
"Taking the first bytes.",
response.data_size, size);
response.data_size = size;
response.p7_seven_packet_data_size, size);
response.p7_seven_packet_data_size = size;
}
/* copy the data */
log_info("is data, put it in buffer");
memcpy(b, response.data, response.data_size);
fillsize += response.data_size; b += response.data_size;
size -= response.data_size;
memcpy(b, response.p7_seven_packet_data,
response.p7_seven_packet_data_size);
fillsize += response.p7_seven_packet_data_size;
b += response.p7_seven_packet_data_size;
size -= response.p7_seven_packet_data_size;
/* check if we should empty the buffer */
if (fillsize > bufsize - MAX_RAWDATA_SIZE || !size) {
log_info("buffer too full, should be emptied");
/* empty buffer in file
* TODO: read error and terminate if problem? */
(*buffer->write)(buffer->cookie, buf, fillsize);
(*buffer->p7_buffer_write)(buffer->p7_buffer_cookie, buf, fillsize);
b = buf; fillsize = 0;
}
}
@ -315,7 +321,7 @@ fail:
*/
int p7_seven_send_data(p7_handle_t *handle, const void *vbuf, p7uint_t size,
int shift, p7_disp_t disp)
int shift, p7_disp_t *disp)
{
int err = 0;
const unsigned char *buf = (const unsigned char*)vbuf;
@ -349,7 +355,7 @@ int p7_seven_send_data(p7_handle_t *handle, const void *vbuf, p7uint_t size,
resp = 1;
/* check response */
if (response.type != p7_seven_type_ack) {
if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_error("calculator didn't send ack, weird");
return (p7_error_unknown);
}
@ -403,27 +409,30 @@ int p7_seven_get_data(p7_handle_t *handle, void *vbuf, p7uint_t size,
}
/* if packet is not data, wtf casio? */
if (response.type != p7_seven_type_data) {
if (response.p7_seven_packet_type != p7_seven_type_data) {
log_fatal("packet type was unplanned, wtf ?");
return (p7_error_unknown);
}
/* displaying */
if (disp) (*disp)(response.id, response.total);
if (disp) (*disp)(response.p7_seven_packet_id,
response.p7_seven_packet_total);
/* check overflow */
if (response.data_size > size) {
if (response.p7_seven_packet_data_size > size) {
log_fatal("%" PRIuP7SHORT " bytes received... "
"that's more than the %" PRIuP7INT " expected. "
"Taking the first bytes.",
response.data_size, size);
response.data_size = size;
response.p7_seven_packet_data_size, size);
response.p7_seven_packet_data_size = size;
}
/* data! continue */
log_info("is data, put it in buffer");
memcpy(buf, response.data, response.data_size);
buf += response.data_size; size -= response.data_size;
memcpy(buf, response.p7_seven_packet_data,
response.p7_seven_packet_data_size);
buf += response.p7_seven_packet_data_size;
size -= response.p7_seven_packet_data_size;
}
/* send last ack */
@ -498,7 +507,7 @@ int p7_seven_data_write(p7_seven_data_cookie_t *cookie,
if ((cookie->p7err = send_quick_data_packet(cookie->p7handle, cookie->total,
cookie->id, &cookie->reserved, cookie->pos + 1, 1)))
return (g1m_error_nowrite);
if (resp->type != p7_seven_type_ack) {
if (resp->p7_seven_packet_type != p7_seven_type_ack) {
cookie->p7err = p7_error_unknown;
return (g1m_error_nowrite);
}
@ -511,7 +520,7 @@ int p7_seven_data_write(p7_seven_data_cookie_t *cookie,
if ((cookie->p7err = send_quick_data_packet(cookie->p7handle,
cookie->total, cookie->id, &cookie->reserved, MAX_RAWDATA_SIZE, 1)))
return (g1m_error_nowrite);
if (resp->type != p7_seven_type_ack) {
if (resp->p7_seven_packet_type != p7_seven_type_ack) {
cookie->p7err = p7_error_unknown;
return (g1m_error_nowrite);
}
@ -530,7 +539,7 @@ int p7_seven_data_write(p7_seven_data_cookie_t *cookie,
if ((cookie->p7err = send_quick_data_packet(cookie->p7handle, cookie->total,
cookie->id, &cookie->reserved, cookie->pos + 1, 1)))
return (g1m_error_nowrite);
if (resp->type != p7_seven_type_ack) {
if (resp->p7_seven_packet_type != p7_seven_type_ack) {
cookie->p7err = p7_error_unknown;
return (g1m_error_nowrite);
}
@ -565,18 +574,21 @@ int p7_seven_decode_data(p7_handle_t *handle,
const packetdata_data_t *d = raw;
/* total number */
packet->total = p7_getascii(d->total_number, 4);
log_info("Total data packets : %" PRIuP7SHORT, packet->total);
packet->p7_seven_packet_total = p7_getascii(d->total_number, 4);
log_info("Total data packets : %" PRIuP7SHORT,
packet->p7_seven_packet_total);
/* current id */
packet->id = p7_getascii(d->current_number, 4);
log_info("Data packet ID : %" PRIuP7SHORT, packet->id);
packet->p7_seven_packet_id = p7_getascii(d->current_number, 4);
log_info("Data packet ID : %" PRIuP7SHORT,
packet->p7_seven_packet_id);
/* data */
packet->data_size = raw_size - 8;
memcpy(packet->data, d->data, raw_size - 8);
log_info("Decoded data (%" PRIuP7SHORT "o) :", packet->data_size);
logm_info(packet->data, packet->data_size);
packet->p7_seven_packet_data_size = raw_size - 8;
memcpy(packet->p7_seven_packet_data, d->data, raw_size - 8);
log_info("Decoded data (%" PRIuP7SHORT "o) :",
packet->p7_seven_packet_data_size);
logm_info(packet->p7_seven_packet_data, packet->p7_seven_packet_data_size);
/* no error */
return (0);

141
src/protocol/seven/eack.c
View File

@ -73,11 +73,9 @@ typedef struct {
* @arg data the raw version data ("xx.xx.xx" + type)
*/
static void version_of_string(p7_version_t *ver, const unsigned char *data)
static void version_of_string(g1m_version_t *ver, const unsigned char *data)
{
ver->major = p7_getdec(p7_getascii(data, 2));
ver->minor = p7_getdec(p7_getascii(&data[3], 2));
ver->rev = p7_getdec(p7_getascii(&data[6], 4));
g1m_decode_version((const char*)data, ver);
}
/**
@ -88,15 +86,11 @@ static void version_of_string(p7_version_t *ver, const unsigned char *data)
* @arg data the raw version data destination ("xx.xx.xx" + type).
*/
static void string_of_version(unsigned char *data, const p7_version_t *ver)
static void string_of_version(unsigned char *data, const g1m_version_t *ver)
{
/* put data */
memcpy(data, "xx.xx.xxxx\xFF\xFF\xFF\xFF\xFF\xFF", 16);
p7_putascii(data, p7_gethex(ver->major), 2);
p7_putascii(&data[3], p7_gethex(ver->minor), 2);
p7_putascii(&data[6], p7_gethex(ver->rev), 4);
g1m_encode_version(ver, (char*)data);
memset(&data[10], '\xFF', 6);
}
/* ************************************************************************** */
/* Send ACK packets */
/* ************************************************************************** */
@ -117,36 +111,44 @@ int p7_seven_send_eack(p7_handle_t *handle, p7_server_t *info)
memset(&raw, 0xFF, sizeof(packetdata_ackext_t));
/* put in the structure */
memcpy(raw.hwid, info->hwid, strnlen(info->hwid, 8));
memcpy(raw.cpuid, info->cpuid, strnlen(info->cpuid, 16));
memcpy(raw.hwid, info->p7_server_hwid,
strnlen(info->p7_server_hwid, 8));
memcpy(raw.cpuid, info->p7_server_cpuid,
strnlen(info->p7_server_cpuid, 16));
if (!info->preprog_rom_wiped) {
p7_putascii(raw.preprog_rom_capacity, info->preprog_rom_capacity, 8);
string_of_version(raw.preprog_rom_version, &info->preprog_rom_version);
if (!info->p7_server_preprog_rom_wiped) {
p7_putascii(raw.preprog_rom_capacity,
info->p7_server_preprog_rom_capacity, 8);
string_of_version(raw.preprog_rom_version,
&info->p7_server_preprog_rom_version);
}
p7_putascii(raw.flash_rom_capacity,
p7_gethex(info->flash_rom_capacity / 1024), 8);
p7_gethex(info->p7_server_flash_rom_capacity / 1024), 8);
p7_putascii(raw.ram_capacity,
p7_gethex(info->ram_capacity / 1024), 8);
p7_gethex(info->p7_server_ram_capacity / 1024), 8);
if (!info->bootcode_wiped) {
string_of_version(raw.bootcode_version, &info->bootcode_version);
p7_putascii(raw.bootcode_offset, info->bootcode_offset, 8);
if (!info->p7_server_bootcode_wiped) {
string_of_version(raw.bootcode_version,
&info->p7_server_bootcode_version);
p7_putascii(raw.bootcode_offset,
info->p7_server_bootcode_offset, 8);
p7_putascii(raw.bootcode_size,
p7_gethex(info->bootcode_size / 1024), 8);
p7_gethex(info->p7_server_bootcode_size / 1024), 8);
}
if (!info->os_wiped) {
string_of_version(raw.os_version, &info->os_version);
p7_putascii(raw.os_offset, info->os_offset, 8);
if (!info->p7_server_os_wiped) {
string_of_version(raw.os_version, &info->p7_server_os_version);
p7_putascii(raw.os_offset, info->p7_server_os_offset, 8);
p7_putascii(raw.os_size,
p7_gethex(info->os_size / 1024), 8);
p7_gethex(info->p7_server_os_size / 1024), 8);
}
memcpy(raw.protocol_version, "7.00", 4);
memcpy(raw.product_id, info->product_id, strnlen(info->product_id, 16));
memcpy(raw.username, info->username, strnlen(info->username, 16));
memcpy(raw.product_id, info->p7_server_product_id,
strnlen(info->p7_server_product_id, 16));
memcpy(raw.username, info->p7_server_username,
strnlen(info->p7_server_username, 16));
/* send the packet */
return (p7_seven_send_ext(handle, p7_seven_type_ack, 0x02, &raw,
@ -193,88 +195,89 @@ int p7_seven_decode_ack(p7_handle_t *handle,
if (data_size != sizeof(packetdata_ackext_t)) return (1);
const packetdata_ackext_t *d = (const packetdata_ackext_t*)data;
p7_server_t *info = &packet->info;
p7_server_t *info = &packet->p7_seven_packet_info;
/* log */
log_info("ack packet is extended");
/* hardware identifier */
cpy_string(info->hwid, (const char*)d->hwid, 8);
log_info("hardware identifier is '%s'", info->hwid);
cpy_string(info->p7_server_hwid, (const char*)d->hwid, 8);
log_info("hardware identifier is '%s'", info->p7_server_hwid);
/* processor identifier */
cpy_string(info->cpuid, (const char*)d->cpuid, 16);
log_info("cpu identifier is '%s'", info->cpuid);
cpy_string(info->p7_server_cpuid, (const char*)d->cpuid, 16);
log_info("cpu identifier is '%s'", info->p7_server_cpuid);
/* preprogrammed ROM information is wiped */
info->preprog_rom_wiped = (d->preprog_rom_version[2] == 0xFF);
info->p7_server_preprog_rom_wiped = (d->preprog_rom_version[2] == 0xFF);
#if LOGLEVEL <= ll_info
if (info->preprog_rom_wiped)
if (info->p7_server_preprog_rom_wiped)
log_info("Preprogrammed ROM information looks wiped out!");
else
log_info("preprogrammed ROM version is %.10s", d->preprog_rom_version);
#endif
/* preprogrammed ROM capacity */
info->preprog_rom_capacity =
info->p7_server_preprog_rom_capacity =
p7_getascii(d->preprog_rom_capacity, 8) * 1000;
log_info("preprogrammed ROM capacity is %" PRIuP7INT "o",
info->preprog_rom_capacity);
info->p7_server_preprog_rom_capacity);
/* preprogrammed ROM version */
version_of_string(&info->preprog_rom_version, d->preprog_rom_version);
log_info("preprogrammed ROM version is %02u.%02u.%04u",
info->preprog_rom_version.major, info->preprog_rom_version.minor,
info->preprog_rom_version.rev);
version_of_string(&info->p7_server_preprog_rom_version,
d->preprog_rom_version);
/* flash ROM capacity */
info->flash_rom_capacity =
info->p7_server_flash_rom_capacity =
p7_getdec(p7_getascii(d->flash_rom_capacity, 8)) * 1024;
log_info("flash ROM capacity is %" PRIuP7INT "KiB",
info->flash_rom_capacity / 1024);
info->p7_server_flash_rom_capacity / 1024);
/* RAM capacity */
info->ram_capacity =
info->p7_server_ram_capacity =
p7_getdec(p7_getascii(d->ram_capacity, 8)) * 1024;
log_info("RAM capacity is %" PRIuP7INT "KiB",
info->ram_capacity / 1024);
info->p7_server_ram_capacity / 1024);
/* bootcode information is wiped */
info->bootcode_wiped = (d->bootcode_version[2] == 0xFF);
info->p7_server_bootcode_wiped = (d->bootcode_version[2] == 0xFF);
#if LOGLEVEL <= ll_info
if (info->bootcode_wiped)
if (info->p7_server_bootcode_wiped)
log_info("Bootcode information looks wiped out!");
else
log_info("bootcode version is %.10s", d->bootcode_version);
#endif
/* bootcode version */
version_of_string(&info->bootcode_version, d->bootcode_version);
log_info("bootcode version is %02u.%02u.%04u",
info->bootcode_version.major, info->bootcode_version.minor,
info->bootcode_version.rev);
version_of_string(&info->p7_server_bootcode_version, d->bootcode_version);
/* bootcode offset */
info->bootcode_offset = p7_getascii(d->bootcode_offset, 8);
log_info("bootcode offset is 0x%08" PRIxP7INT, info->bootcode_offset);
info->p7_server_bootcode_offset = p7_getascii(d->bootcode_offset, 8);
log_info("bootcode offset is 0x%08" PRIxP7INT,
info->p7_server_bootcode_offset);
/* bootcode size */
info->bootcode_size = p7_getdec(p7_getascii(d->bootcode_size, 8)) * 1024;
log_info("bootcode size is %" PRIuP7INT "KiB", info->bootcode_size / 1024);
info->p7_server_bootcode_size =
p7_getdec(p7_getascii(d->bootcode_size, 8)) * 1024;
log_info("bootcode size is %" PRIuP7INT "KiB",
info->p7_server_bootcode_size / 1024);
/* OS information is wiped */
info->os_wiped = (d->os_version[2] == 0xFF);
info->p7_server_os_wiped = (d->os_version[2] == 0xFF);
#if LOGLEVEL <= ll_info
if (info->os_wiped)
if (info->p7_server_os_wiped)
log_info("OS information looks wiped out!");
else
log_info("OS version is %.10s", d->os_version);
#endif
/* OS version */
version_of_string(&info->os_version, d->os_version);
log_info("OS version is %02u.%02u.%04u",
info->os_version.major, info->os_version.minor,
info->os_version.rev);
version_of_string(&info->p7_server_os_version, d->os_version);
/* OS offset */
info->os_offset = p7_getascii(d->os_offset, 8);
log_info("OS offset is 0x%08" PRIxP7INT , info->os_offset);
info->p7_server_os_offset = p7_getascii(d->os_offset, 8);
log_info("OS offset is 0x%08" PRIxP7INT , info->p7_server_os_offset);
/* OS size */
info->os_size = p7_getdec(p7_getascii(d->os_size, 8)) * 1024;
log_info("OS size is %" PRIuP7INT "KiB", info->os_size / 1024);
info->p7_server_os_size = p7_getdec(p7_getascii(d->os_size, 8)) * 1024;
log_info("OS size is %" PRIuP7INT "KiB", info->p7_server_os_size / 1024);
/* product ID */
cpy_string(info->product_id, (const char*)d->product_id, 16);
log_info("product ID is %s", info->product_id);
cpy_string(info->p7_server_product_id, (const char*)d->product_id, 16);
log_info("product ID is %s", info->p7_server_product_id);
/* username */
cpy_string(info->username, (const char*)d->username, 16);
log_info("username is %s", info->username);
cpy_string(info->p7_server_username, (const char*)d->username, 16);
log_info("username is %s", info->p7_server_username);
/* no error */
return (0);

11
src/protocol/seven/init.c
View File

@ -40,7 +40,7 @@ int p7_seven_start(p7_handle_t *handle)
if ((err = p7_seven_send_ini_check(handle))) {
log_fatal("couldn't send check/didn't receive answer");
return (err);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("received packet wasn't ack, ask your dentist");
return (p7_error_unknown);
}
@ -55,14 +55,15 @@ int p7_seven_start(p7_handle_t *handle)
if ((err = p7_seven_send_cmdsys_getinfo(handle))) {
log_fatal("couldn't send env query/receive answer");
return (err);
} else if (response.type != p7_seven_type_ack || !response.extended) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
|| !response.p7_seven_packet_extended) {
log_fatal("response to env query wasn't an extended ack packet");
return (p7_error_unknown);
}
/* save server, get environment based on hardware id */
handle->_server = response.info;
handle->_env = p7_seven_getenv(handle->_server.hwid);
handle->_server = response.p7_seven_packet_info;
handle->_env = p7_seven_getenv(handle->_server.p7_server_hwid);
log_info("environment is '%s'", handle->_env->name);
/* no error */
@ -93,7 +94,7 @@ int p7_seven_end(p7_handle_t *handle)
}
/* check ack */
if (response.type != p7_seven_type_ack) {
if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_warn("answer to terminate packet wasn't ack!");
return (p7_error_unknown);
}

59
src/protocol/seven/recv.c
View File

@ -216,10 +216,10 @@ static int receive(p7_handle_t *handle)
}
/* get the type */
response.type = buffer[0];
response.p7_seven_packet_type = buffer[0];
/* image has a particular format starting from here, look for it now! */
if (response.type == p7_seven_type_ohp) {
if (response.p7_seven_packet_type == p7_seven_type_ohp) {
log_info("Johnson, this is a screen.");
COMPLETE_PACKET(3)
@ -227,32 +227,32 @@ static int receive(p7_handle_t *handle)
unsigned int image_size = 0;
if (!memcmp(&buffer[1], "TYP01", 5)) {
log_info("This is normal VRAM, we know it !");
response.pictype = p7_pictype_1bit;
response.width = 128;
response.height = 64;
response.p7_seven_packet_pictype = p7_pictype_1bit;
response.p7_seven_packet_width = 128;
response.p7_seven_packet_height = 64;
image_size = 1024;
} else if (!memcmp(&buffer[1], "TYPZ1", 5)
|| !memcmp(&buffer[1], "TYPZ2", 5)) {
log_info("Prizm VRAM!");
COMPLETE_PACKET(sizeof(p7_typz_subheader_t))
p7_typz_subheader_t *s = (void*)&buffer[6];
response.width = p7_getascii(s->width, 4);
response.height = p7_getascii(s->height, 4);
response.p7_seven_packet_width = p7_getascii(s->p7_typz_width, 4);
response.p7_seven_packet_height = p7_getascii(s->p7_typz_height, 4);
/* check the type */
response.pictype = 0;
if (!memcmp(s->enc, "RC2", 3))
response.pictype = p7_pictype_16bit;
else if (!memcmp(s->enc, "RC3", 3))
response.pictype = p7_pictype_3bit;
else if (!memcmp(s->enc, "RM2", 3))
response.pictype = p7_pictype_2bit;
response.p7_seven_packet_pictype = 0;
if (!memcmp(s->p7_typz_enc, "RC2", 3))
response.p7_seven_packet_pictype = p7_pictype_16bit;
else if (!memcmp(s->p7_typz_enc, "RC3", 3))
response.p7_seven_packet_pictype = p7_pictype_3bit;
else if (!memcmp(s->p7_typz_enc, "RM2", 3))
response.p7_seven_packet_pictype = p7_pictype_2bit;
#if LOGLEVEL <= ll_error
else log_error("Unknown encoding: %.3s", s->enc);
else log_error("Unknown encoding: %.3s", s->p7_typz_enc);
#endif
/* FIXME: check size according to format? */
image_size = p7_getascii(s->size, 6);
image_size = p7_getascii(s->p7_typz_size, 6);
log_info("Image size: %uB", image_size);
handle->_flags |= p7_intflag_nocheck;
} else {
@ -261,7 +261,7 @@ static int receive(p7_handle_t *handle)
}
/* check if we should skip */
if (!response.pictype || image_size > MAX_VRAM_SIZE) {
if (!response.p7_seven_packet_pictype || image_size > MAX_VRAM_SIZE) {
p7_skip(&handle->_stream, image_size
+ (handle->_flags & p7_intflag_nocheck ? 0 : 2));
return (p7_error_unknown);
@ -271,7 +271,7 @@ static int receive(p7_handle_t *handle)
size_t hdsize = received;
log_info("Get screen content (%uo)", image_size);
COMPLETE_PACKET(image_size)
memcpy(&response.vram, &buffer[hdsize], image_size);
memcpy(&response.p7_seven_packet_vram, &buffer[hdsize], image_size);
/* check the sum */
if ((~handle->_flags & p7_intflag_nocheck)) {
@ -324,7 +324,7 @@ static int receive(p7_handle_t *handle)
COMPLETE_PACKET(2)
/* check if we should read a binary zero */
int is_binary_zero = (response.type == p7_seven_type_cmd
int is_binary_zero = (response.p7_seven_packet_type == p7_seven_type_cmd
&& subtype == p7_seven_cmdosu_upandrun);
if (is_binary_zero) COMPLETE_PACKET(1)
@ -345,11 +345,11 @@ static int receive(p7_handle_t *handle)
data_size = p7_decode(&buffer[8], &buffer[8], data_size);
/* get fields out for specific packets */
switch (response.type) {
switch (response.p7_seven_packet_type) {
/* - for command - */
case p7_seven_type_cmd:
log_info("packet was interpreted as a command one");
response.code = subtype;
response.p7_seven_packet_code = subtype;
log_info("command is '%s' (0x%02" PRIxP7SHORT ")",
getcmdstring(subtype), subtype);
if (is_extended
@ -373,15 +373,15 @@ static int receive(p7_handle_t *handle)
/* - for check - */
case p7_seven_type_check:
log_info("packet was interpreted as a check one");
response.initial = !subtype;
response.p7_seven_packet_initial = !subtype;
break;
/* - for ack - */
case p7_seven_type_ack:
log_info("packet was interpreted as an ack one");
response.ow = (subtype == 0x01);
response.extended = (subtype == 0x02);
if (response.extended
response.p7_seven_packet_ow = (subtype == 0x01);
response.p7_seven_packet_extended = (subtype == 0x02);
if (response.p7_seven_packet_extended
&& p7_seven_decode_ack(handle, &buffer[8], data_size))
return (p7_error_checksum);
if (subtype == 0x03)
@ -393,7 +393,7 @@ static int receive(p7_handle_t *handle)
log_info("packet was interpreted as an error one");
log_info("error is '%s' (0x%02" PRIxP7SHORT ")",
geterrstring(subtype), subtype);
response.code = subtype;
response.p7_seven_packet_code = subtype;
if (subtype == p7_seven_err_fullmem)
handle->_flags |= p7_intflag_terminated;
break;
@ -403,14 +403,15 @@ static int receive(p7_handle_t *handle)
log_info("packet was interpreted as a terminate one");
log_info("termination cause is '%s' (0x%02" PRIxP7SHORT ")",
gettermstring(subtype), subtype);
response.code = subtype;
response.p7_seven_packet_code = subtype;
if (subtype == p7_seven_term_user)
return (p7_error_interrupted);
break;
/* other */
default:
log_fatal("bad type received ! type was 0x%02x", response.type);
log_fatal("bad type received ! type was 0x%02x",
response.p7_seven_packet_type);
return (p7_error_unknown);
}
@ -457,7 +458,7 @@ int p7_seven_recv(p7_handle_t *handle, int checksum)
/* get the ack */
err = receive(handle);
if (!err && response.type != p7_seven_type_ack)
if (!err && response.p7_seven_packet_type != p7_seven_type_ack)
err = p7_error_unknown;
if (err) goto fail;

10
src/protocol/seven/send.c
View File

@ -85,8 +85,8 @@ static int p7_seven_send_buf(p7_handle_t *handle,
if (!resp) break;
if ((resp_err = p7_seven_recv(handle, 1)))
break;
if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_resend)
if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_resend)
continue;
break;
}
@ -125,10 +125,12 @@ int p7_seven_send_basic(p7_handle_t *handle,
int err = p7_seven_send_buf(handle, NULL, 0, resp);
if (!err) {
if (type == p7_seven_type_term
&& (!resp || (resp && response.type == p7_seven_type_ack)))
&& (!resp || (resp
&& response.p7_seven_packet_type == p7_seven_type_ack)))
handle->_env = NULL;
if (type == p7_seven_type_roleswp
&& (!resp || (resp && response.type != p7_seven_type_roleswp)))
&& (!resp || (resp
&& response.p7_seven_packet_type != p7_seven_type_roleswp)))
handle->_flags &= ~p7_intflag_active;
}

59
src/usage/backup.c
View File

@ -77,16 +77,13 @@ static int decode_entry(p7_handle_t *handle, p7_casiowin_entry_t *entry,
return (p7_error_checksum);
/* decode */
entry->version.major = p7_getascii(&raw->version[0], 2);
entry->version.minor = p7_getascii(&raw->version[3], 2);
entry->version.rev = p7_getascii(&raw->version[6], 4);
entry->syscall_table_offset = be32toh(raw->syscall_table);
g1m_decode_version((char*)raw->version, &entry->p7_casiowin_entry_version);
entry->p7_casiowin_entry_syscall_table_offset = be32toh(raw->syscall_table);
/* log */
log_info("OS version is %02u.%02u.%04u",
entry->version.major, entry->version.minor, entry->version.rev);
log_info("OS version is %.10s", raw->version);
log_info("OS syscall table offset is 0x%08" PRIxP7INT,
entry->syscall_table_offset);
entry->p7_casiowin_entry_syscall_table_offset);
/* no error */
return (0);
@ -118,11 +115,11 @@ int p7_backup_casiowin_entry(p7_handle_t *handle, p7_casiowin_entry_t *entry)
if ((err = p7_seven_send_cmdbak_reqcwe(handle))) {
log_fatal("couldn't send command/get response");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("backup is unsupported.");
return (p7_error_unsupported);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
@ -132,8 +129,8 @@ int p7_backup_casiowin_entry(p7_handle_t *handle, p7_casiowin_entry_t *entry)
if ((err = p7_seven_send_swp(handle))) {
log_fatal("couldn't send roleswap");
return (err);
} else if (response.type != p7_seven_type_cmd
|| response.code != 0x53) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd
|| response.p7_seven_packet_code != 0x53) {
log_fatal("didn't receive correct command");
return (p7_error_unknown);
}
@ -184,11 +181,11 @@ int p7_backup_boot(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_cmdbak_reqboot(handle))) {
log_fatal("couldn't send command/get response");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("backup is unsupported.");
return (p7_error_unsupported);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
@ -198,7 +195,7 @@ int p7_backup_boot(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_swp(handle))) {
log_fatal("couldn't send roleswap");
return (err);
} else if (response.type != p7_seven_type_cmd) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd) {
log_fatal("didn't receive command");
return (p7_error_unknown);
}
@ -226,8 +223,8 @@ int p7_backup_bootfile(p7_handle_t *handle, FILE *file, p7_disp_t disp)
{
chk_iswrite(file);
p7_buffer_t buffer = {
.cookie = file,
.write = p7_filebuffer_write
.p7_buffer_cookie = file,
.p7_buffer_write = p7_filebuffer_write
};
return (p7_backup_boot(handle, &buffer, disp));
@ -246,7 +243,7 @@ int p7_backup_bootfile(p7_handle_t *handle, FILE *file, p7_disp_t disp)
* @return the error code (0 if ok)
*/
#define rom_size (handle->_server.flash_rom_capacity)
#define rom_size (handle->_server.p7_server_flash_rom_capacity)
int p7_backup_rom(p7_handle_t *handle, const p7_buffer_t *buffer,
p7_disp_t disp)
{
@ -263,11 +260,11 @@ int p7_backup_rom(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_cmdbak_reqrom(handle))) {
log_fatal("couldn't send command/get response");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("backup is unsupported.");
return (p7_error_unsupported);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
@ -277,7 +274,7 @@ int p7_backup_rom(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_roleswp(handle))) {
log_fatal("couldn't send roleswap");
return (err);
} else if (response.type != p7_seven_type_cmd) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd) {
log_fatal("didn't receive command");
return (p7_error_unknown);
}
@ -305,8 +302,8 @@ int p7_backup_romfile(p7_handle_t *handle, FILE *file, p7_disp_t disp)
{
chk_iswrite(file);
p7_buffer_t buffer = {
.cookie = file,
.write = p7_filebuffer_write
.p7_buffer_cookie = file,
.p7_buffer_write = p7_filebuffer_write
};
return (p7_backup_rom(handle, &buffer, disp));
@ -342,11 +339,11 @@ int p7_backup_ram(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_cmdbak_reqram(handle))) {
log_fatal("couldn't send command/get response");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("backup is unsupported.");
return (p7_error_unsupported);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
@ -356,7 +353,7 @@ int p7_backup_ram(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_roleswp(handle))) {
log_fatal("couldn't send roleswap");
return (err);
} else if (response.type != p7_seven_type_cmd) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd) {
log_fatal("didn't receive command");
return (p7_error_unknown);
}
@ -384,8 +381,8 @@ int p7_backup_ramfile(p7_handle_t *handle, FILE *file, p7_disp_t disp)
{
chk_iswrite(file);
p7_buffer_t buffer = {
.cookie = file,
.write = p7_filebuffer_write
.p7_buffer_cookie = file,
.p7_buffer_write = p7_filebuffer_write
};
return (p7_backup_ram(handle, &buffer, disp));

32
src/usage/getscreen.c
View File

@ -32,15 +32,15 @@
static void p7_getscreen_adapt(uint32_t **pixels, p7_packet_t *resp)
{
uint8_t *vram = resp->vram; int msk;
uint8_t *vram = resp->p7_seven_packet_vram; int msk;
uint32_t prizm_gray_colors[] = {0xFFFFFF, 0xAAAAAA, 0x777777, 0x000000};
switch (resp->pictype) {
switch (resp->p7_seven_packet_pictype) {
/* monochrome */
case p7_pictype_1bit:
msk = 0x80;
for (unsigned int y = 0; y < resp->height; y++)
for (unsigned int x = 0; x < resp->width; x++) {
for (unsigned int y = 0; y < resp->p7_seven_packet_height; y++)
for (unsigned int x = 0; x < resp->p7_seven_packet_width; x++) {
/* get pixel */
pixels[y][x] = (*vram & msk) ? 0x000000 : 0xFFFFFF;
@ -52,9 +52,10 @@ static void p7_getscreen_adapt(uint32_t **pixels, p7_packet_t *resp)
/* 2-bit (Prizm's encoding) */
case p7_pictype_2bit:
msk = 0x80; uint8_t *v2 = &vram[resp->height * resp->width / 8];
for (unsigned int y = 0; y < resp->height; y++)
for (unsigned int x = 0; x < resp->width; x++) {
msk = 0x80; uint8_t *v2 = &vram[resp->p7_seven_packet_height
* resp->p7_seven_packet_width / 8];
for (unsigned int y = 0; y < resp->p7_seven_packet_height; y++)
for (unsigned int x = 0; x < resp->p7_seven_packet_width; x++) {
/* get pixel */
uint32_t val = (!!(*vram & msk) << 1) | !!(*v2 & msk);
pixels[y][x] = prizm_gray_colors[val];
@ -68,8 +69,10 @@ static void p7_getscreen_adapt(uint32_t **pixels, p7_packet_t *resp)
/* 3-bit */
case p7_pictype_3bit:
msk = 0xF0;
for (unsigned int y = resp->height - 1; y != (unsigned int)-1; y--)
for (unsigned int x = resp->width - 1; x != (unsigned int)-1; x--) {
for (unsigned int y = resp->p7_seven_packet_height - 1;
y != (unsigned int)-1; y--)
for (unsigned int x = resp->p7_seven_packet_width - 1;
x != (unsigned int)-1; x--) {
/* get pixel */
uint32_t val = *vram & msk; val = val | (val >> 4);
uint32_t px = 0;
@ -86,8 +89,8 @@ static void p7_getscreen_adapt(uint32_t **pixels, p7_packet_t *resp)
/* 16-bit */
case p7_pictype_16bit:
for (unsigned int y = 0; y < resp->height; y++)
for (unsigned int x = 0; x < resp->width; x++) {
for (unsigned int y = 0; y < resp->p7_seven_packet_height; y++)
for (unsigned int x = 0; x < resp->p7_seven_packet_width; x++) {
/* get pixel */
uint32_t o = vram[0], t = vram[1];
pixels[y][x] = (o >> 3) << (16 + 3);
@ -138,15 +141,16 @@ int p7_getscreen(p7_handle_t *handle, int (*callback)(int, int, uint32_t**))
/* get packet */
if ((err = p7_seven_recv(handle, 0)))
return (err);
if (response.type != p7_seven_type_ohp)
if (response.p7_seven_packet_type != p7_seven_type_ohp)
return (p7_error_unknown);
/* convert */
if (response.pictype) {
if (response.p7_seven_packet_pictype) {
p7_getscreen_adapt(pixels, &response);
/* then call back the callback */
if (!(*callback)(response.width, response.height, pixels))
if (!(*callback)(response.p7_seven_packet_width,
response.p7_seven_packet_height, pixels))
break;
}
}

12
src/usage/mcs/list.c
View File

@ -42,7 +42,7 @@ int p7_mcs_list(p7_handle_t *handle, p7_mcslist_t callback, void *cookie)
if ((err = p7_seven_send_cmdmcs_reqallinfo(handle))) {
log_fatal("couldn't send transfer request");
return (err);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("didn't receive ack...");
return (p7_error_unknown);
}
@ -56,16 +56,18 @@ int p7_mcs_list(p7_handle_t *handle, p7_mcslist_t callback, void *cookie)
/* - Note: we are now in passive mode - */
g1m_mcshead_t head;
while (1) switch (response.type) {
while (1) switch (response.p7_seven_packet_type) {
/* if answer is roleswap, we are done */
case p7_seven_type_swp: return (0);
/* if it is command, should be another file info */
case p7_seven_type_cmd:
/* check args */
if (g1m_decode_mcsfile_head(&head, response.mcstype,
(unsigned char*)response.args[2], (unsigned char*)response.args[0],
(unsigned char*)response.args[1], response.filesize))
if (g1m_decode_mcsfile_head(&head, response.p7_seven_packet_mcstype,
(unsigned char*)response.p7_seven_packet_args[2],
(unsigned char*)response.p7_seven_packet_args[0],
(unsigned char*)response.p7_seven_packet_args[1],
response.p7_seven_packet_filesize))
continue;
(*callback)(cookie, &head);

19
src/usage/mcs/request.c
View File

@ -45,11 +45,11 @@ int p7_mcs_request(p7_handle_t *handle, g1m_mcsfile_t **file,
if ((err = p7_send_cmdmcs_reqfile(handle, reqhead))) {
log_fatal("couldn't send file transfer request/didn't receive answer");
return (err);
} if (response.type == p7_seven_type_nak
&& response.code == p7_seven_err_other) {
} if (response.p7_seven_packet_type == p7_seven_type_nak
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("requested file didn't exist");
return (p7_error_notfound);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("didn't receive ack or known error...");
return (p7_error_unknown);
}
@ -59,16 +59,19 @@ int p7_mcs_request(p7_handle_t *handle, g1m_mcsfile_t **file,
if ((err = p7_seven_send_swp(handle))) {
log_fatal("couldn't swap roles");
return (err);
} else if (response.type != p7_seven_type_cmd || response.code != 0x25) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd
|| response.p7_seven_packet_code != p7_seven_cmdmcs_sendfile) {
log_fatal("didn't receive expected command");
return (p7_error_unknown);
}
/* save the head */
g1m_mcshead_t head;
g1m_decode_mcsfile_head(&head, response.mcstype,
(unsigned char*)response.args[2], (unsigned char*)response.args[0],
(unsigned char*)response.args[1], response.filesize);
g1m_decode_mcsfile_head(&head, response.p7_seven_packet_mcstype,
(unsigned char*)response.p7_seven_packet_args[2],
(unsigned char*)response.p7_seven_packet_args[0],
(unsigned char*)response.p7_seven_packet_args[1],
response.p7_seven_packet_filesize);
/* get data */
unsigned char *tmp = malloc(head.size);
@ -77,7 +80,7 @@ int p7_mcs_request(p7_handle_t *handle, g1m_mcsfile_t **file,
goto fail;
/* check if last answer was roleswap */
if (response.type != p7_seven_type_swp) {
if (response.p7_seven_packet_type != p7_seven_type_swp) {
err = p7_error_unknown;
goto fail;
}

11
src/usage/mcs/send.c
View File

@ -52,14 +52,15 @@ int p7_mcs_send(p7_handle_t *handle, g1m_mcsfile_t *file,
if ((err = p7_send_cmdmcs_sendfile(handle, owmode, file))) {
log_fatal("couldn't send file transfer pakcet/didn't receive answer");
return (err);
} else if (response.type != p7_seven_type_ack
&& response.type != p7_seven_type_error) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
&& response.p7_seven_packet_type != p7_seven_type_error) {
log_fatal("file transfer answer was unknown");
return (p7_error_unknown);
}
/* check what happened if it is an error packet */
if (response.type == p7_seven_type_error) switch (response.code) {
if (response.p7_seven_packet_type == p7_seven_type_error)
switch (response.p7_seven_packet_code) {
/* file exists, confirm or not */
case p7_seven_err_overwrite:
log_info("calc wanted overwrite confirmation");
@ -69,7 +70,7 @@ int p7_mcs_send(p7_handle_t *handle, g1m_mcsfile_t *file,
log_info("sending yes to overwrite confirmation");
if ((err = p7_seven_confirm_ow(handle)))
return (err);
else if (response.type != p7_seven_type_ack) {
else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response packet wasn't ack");
return (p7_error_unknown);
}
@ -78,7 +79,7 @@ int p7_mcs_send(p7_handle_t *handle, g1m_mcsfile_t *file,
log_info("sending no to overwrite confirmation");
if ((err = p7_seven_deny_ow(handle)))
return (err);
else if (response.type != p7_seven_type_ack) {
else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response packet wasn't ack");
return (p7_error_unknown);
}

2
src/usage/poke.c
View File

@ -38,7 +38,7 @@ int p7_poke(p7_handle_t *handle)
if ((err = p7_seven_send_check(handle))) {
log_fatal("couldn't send check");
return (err);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("check answer was unexpected");
return (p7_error_unknown);
}

22
src/usage/sendexe.c
View File

@ -40,18 +40,18 @@ int p7_sendexe(p7_handle_t *handle, const p7_buffer_t *buffer,
chk_handle(handle);
chk_seven(handle);
chk_active(handle);
chk_filesize(buffer->size);
chk_filesize(buffer->p7_buffer_size);
/* send command */
log_info("sending up and run command");
if ((err = p7_seven_send_cmdosu_upandrun(handle, buffer->size,
if ((err = p7_seven_send_cmdosu_upandrun(handle, buffer->p7_buffer_size,
loadaddr, straddr)))
return (err);
else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("0x56 is non implemented!");
return (p7_error_unsupported);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response wasn't ack");
return (p7_error_unknown);
}
@ -94,9 +94,9 @@ int p7_sendexe_file(p7_handle_t *handle,
/* make the buffer */
p7_buffer_t buffer = {
.cookie = exe,
.size = size,
.read = p7_filebuffer_read
.p7_buffer_cookie = exe,
.p7_buffer_size = size,
.p7_buffer_read = p7_filebuffer_read
};
/* real func */
@ -127,9 +127,9 @@ int p7_sendexe_mem(p7_handle_t *handle,
/* make the buffer */
p7_cursor_t cursor = {.mem = mem};
p7_buffer_t buffer = {
.cookie = &cursor,
.size = size,
.read = p7_membuffer_read
.p7_buffer_cookie = &cursor,
.p7_buffer_size = size,
.p7_buffer_read = p7_membuffer_read
};
/* real func */

91
src/usage/server/classical.c
View File

@ -30,12 +30,12 @@ typedef struct {
/* macros */
#define gather_fs() \
p7_filesystem_t *fs = find_filesystem(response.args[4], \
p7_filesystem_t *fs = find_filesystem(response.p7_seven_packet_args[4], \
cookie->filesystems); \
if (!fs) return (p7_error_unknown);
#define gather_sdir() \
const char *sdir = response.args[0]; \
if (!sdir) sdir = fs->working_directory;
const char *sdir = response.p7_seven_packet_args[0]; \
if (!sdir) sdir = fs->p7_filesystem_working_directory;
/**
* find_filesystem:
@ -49,8 +49,8 @@ typedef struct {
static p7_filesystem_t *find_filesystem(const char *name,
p7_filesystem_t *filesystems)
{
while (filesystems->name) {
if (!strcmp(name, filesystems->name))
while (filesystems->p7_filesystem_name) {
if (!strcmp(name, filesystems->p7_filesystem_name))
return (filesystems);
filesystems++;
}
@ -89,21 +89,21 @@ static int backup_ram(p7_server_cookie_t *cookie, p7_handle_t *handle)
p7_server_t *info = cookie->info;
/* check that we have the RAM */
if (!info->ram) return (p7_error_unknown);
if (!info->p7_server_ram) return (p7_error_unknown);
/* accept and roleswap */
int err = p7_seven_send_ack(handle, 1);
if (err) return (err);
if (response.type != p7_seven_type_swp)
if (response.p7_seven_packet_type != p7_seven_type_swp)
return (p7_error_unknown);
/* send the command */
err = p7_seven_send_cmdbak_putram(handle);
if (err) return (err);
if (response.type == p7_seven_type_ack) {
if (response.p7_seven_packet_type == p7_seven_type_ack) {
/* send the thing */
err = p7_seven_send_data(handle, info->ram, info->ram_capacity,
0, NULL);
err = p7_seven_send_data(handle, info->p7_server_ram,
info->p7_server_ram_capacity, 0, NULL);
if (err) return (err);
}
@ -125,21 +125,21 @@ static int backup_rom(p7_server_cookie_t *cookie, p7_handle_t *handle)
p7_server_t *info = cookie->info;
/* check that we have the ROM */
if (!info->flash_rom) return (p7_error_unknown);
if (!info->p7_server_flash_rom) return (p7_error_unknown);
/* accept and roleswap */
int err = p7_seven_send_ack(handle, 1);
if (err) return (err);
if (response.type != p7_seven_type_swp)
if (response.p7_seven_packet_type != p7_seven_type_swp)
return (p7_error_unknown);
/* send the command */
err = p7_seven_send_cmdbak_putrom(handle);
if (err) return (err);
if (response.type == p7_seven_type_ack) {
if (response.p7_seven_packet_type == p7_seven_type_ack) {
/* send the thing */
err = p7_seven_send_data(handle, info->flash_rom,
info->flash_rom_capacity, 0, NULL);
err = p7_seven_send_data(handle, info->p7_server_flash_rom,
info->p7_server_flash_rom_capacity, 0, NULL);
if (err) return (err);
}
@ -161,21 +161,21 @@ static int backup_boot(p7_server_cookie_t *cookie, p7_handle_t *handle)
p7_server_t *info = cookie->info;
/* check that we have the bootcode */
if (!info->bootcode) return (p7_error_unknown);
if (!info->p7_server_bootcode) return (p7_error_unknown);
/* accept and roleswap */
int err = p7_seven_send_ack(handle, 1);
if (err) return (err);
if (response.type != p7_seven_type_swp)
if (response.p7_seven_packet_type != p7_seven_type_swp)
return (p7_error_unknown);
/* send the command */
err = p7_seven_send_cmdbak_putboot(handle);
if (err) return (err);
if (response.type == p7_seven_type_ack) {
if (response.p7_seven_packet_type == p7_seven_type_ack) {
/* send the thing */
err = p7_seven_send_data(handle, info->bootcode, info->bootcode_size,
0, NULL);
err = p7_seven_send_data(handle, info->p7_server_bootcode,
info->p7_server_bootcode_size, 0, NULL);
if (err) return (err);
}
@ -200,9 +200,10 @@ static int create_directory(p7_server_cookie_t *cookie, p7_handle_t *handle)
gather_sdir()
/* create the directory */
if (!fs->create_directory || !sdir)
if (!fs->p7_filesystem_create_directory || !sdir)
return (p7_error_unknown);
int err = (*fs->create_directory)(fs->cookie, sdir);
int err = (*fs->p7_filesystem_create_directory)(fs->p7_filesystem_cookie,
sdir);
if (err) return (err);
/* send ack */
@ -224,9 +225,10 @@ static int delete_directory(p7_server_cookie_t *cookie, p7_handle_t *handle)
gather_sdir()
/* delete the directory */
if (!fs->delete_directory || !sdir)
if (!fs->p7_filesystem_delete_directory || !sdir)
return (p7_error_unknown);
int err = (*fs->delete_directory)(fs->cookie, sdir);
int err = (*fs->p7_filesystem_delete_directory)(fs->p7_filesystem_cookie,
sdir);
if (err) return (err);
/* send ack */
@ -248,9 +250,11 @@ static int rename_directory(p7_server_cookie_t *cookie, p7_handle_t *handle)
gather_sdir()
/* rename the directory */
if (!fs->rename_directory || !sdir || !response.args[1])
if (!fs->p7_filesystem_rename_directory || !sdir
|| !response.p7_seven_packet_args[1])
return (p7_error_unknown);
int err = (*fs->rename_directory)(fs->cookie, sdir, response.args[1]);
int err = (*fs->p7_filesystem_rename_directory)(fs->p7_filesystem_cookie,
sdir, response.p7_seven_packet_args[1]);
if (err) return (err);
/* send ack */
@ -272,17 +276,18 @@ static int change_working_directory(p7_server_cookie_t *cookie,
gather_fs()
/* check and change working directory */
log_info("Changing directory to \"%s\"", response.args[0]);
if (!response.args[0])
fs->working_directory = NULL;
else if (fs->directory_exists
&& (*fs->directory_exists)(fs->cookie, response.args[0])) {
log_info("Changing directory to \"%s\"", response.p7_seven_packet_args[0]);
if (!response.p7_seven_packet_args[0])
fs->p7_filesystem_working_directory = NULL;
else if (fs->p7_filesystem_directory_exists
&& (*fs->p7_filesystem_directory_exists)(fs->p7_filesystem_cookie,
response.p7_seven_packet_args[0])) {
log_info("Directory does not exist, not changing!");
return (p7_error_unknown);
} else {
fs->working_directory = fs->_wd;
strncpy(fs->_wd, response.args[0], 256);
fs->_wd[256] = 0;
fs->p7_filesystem_working_directory = fs->p7_filesystem__wd;
strncpy(fs->p7_filesystem__wd, response.p7_seven_packet_args[0], 256);
fs->p7_filesystem__wd[256] = 0;
}
/* success! */
@ -308,20 +313,20 @@ int p7_serve(p7_handle_t *handle, p7_server_t *info,
p7_server_cookie_t cookie = {
.info = info,
.filesystems = filesystems};
p7_server_callback_t callbacks[256] = {
p7_server_callback_t *callbacks[256] = {
/* main commands */
[p7_seven_cmdsys_getinfo] = (p7_server_callback_t)send_server_info,
[p7_seven_cmdsys_getinfo] = (p7_server_callback_t*)send_server_info,
/* backup commands */
[p7_seven_cmdbak_reqram] = (p7_server_callback_t)backup_ram,
[p7_seven_cmdbak_reqrom] = (p7_server_callback_t)backup_rom,
[p7_seven_cmdbak_reqboot] = (p7_server_callback_t)backup_boot,
[p7_seven_cmdbak_reqram] = (p7_server_callback_t*)backup_ram,
[p7_seven_cmdbak_reqrom] = (p7_server_callback_t*)backup_rom,
[p7_seven_cmdbak_reqboot] = (p7_server_callback_t*)backup_boot,
/* storage-related commands */
[p7_seven_cmdfls_mkdir] = (p7_server_callback_t)create_directory,
[p7_seven_cmdfls_rmdir] = (p7_server_callback_t)delete_directory,
[p7_seven_cmdfls_mvdir] = (p7_server_callback_t)rename_directory,
[p7_seven_cmdfls_cwd] = (p7_server_callback_t)change_working_directory,
[p7_seven_cmdfls_mkdir] = (p7_server_callback_t*)create_directory,
[p7_seven_cmdfls_rmdir] = (p7_server_callback_t*)delete_directory,
[p7_seven_cmdfls_mvdir] = (p7_server_callback_t*)rename_directory,
[p7_seven_cmdfls_cwd] = (p7_server_callback_t*)change_working_directory,
};
/* serve! */

15
src/usage/server/direct.c
View File

@ -28,7 +28,7 @@
* @return the error.
*/
int p7_serve_directly(p7_handle_t *handle, p7_server_callback_t *callbacks,
int p7_serve_directly(p7_handle_t *handle, p7_server_callback_t **callbacks,
void *cookie)
{
int err;
@ -39,7 +39,10 @@ int p7_serve_directly(p7_handle_t *handle, p7_server_callback_t *callbacks,
/* initial check */
if ((err = p7_seven_recv(handle, 0))) return (err);
while (response.type != p7_seven_type_check || !response.initial) {
while (response.p7_seven_packet_type != p7_seven_type_check
|| !response.p7_seven_packet_initial) {
/* FIXME: real server does not send error, it just waits for another
* packet to come */
err = p7_seven_send_err(handle, p7_seven_err_other);
if (err) return (err);
}
@ -51,21 +54,21 @@ int p7_serve_directly(p7_handle_t *handle, p7_server_callback_t *callbacks,
/* main loop */
while (1) {
/* check command packet */
if (response.type != p7_seven_type_cmd) {
if (response.type == p7_seven_type_end) break;
if (response.p7_seven_packet_type != p7_seven_type_cmd) {
if (response.p7_seven_packet_type == p7_seven_type_end) break;
p7_seven_send_err(handle, p7_seven_err_other);
continue ;
}
/* check if callback exists */
if (!callbacks[response.code]) {
if (!callbacks[response.p7_seven_packet_code]) {
err = p7_seven_send_err(handle, p7_seven_err_other);
if (err) return (err);
continue ;
}
/* call the callback */
err = (*callbacks[response.code])(cookie, handle);
err = (*callbacks[response.p7_seven_packet_code])(cookie, handle);
if (err) {
if (err != p7_error_unknown) return (err);
p7_seven_send_err(handle, p7_seven_err_other);

18
src/usage/setlink.c
View File

@ -40,10 +40,10 @@ int p7_setlink(p7_handle_t *handle, const p7_streamsettings_t *settings)
}
/* get the information */
unsigned int speed = settings->speed;
int stopbits = (settings->flags & P7_TWOSTOPBITS) + 1;
int parity = (~settings->flags & P7_PARENB) ? 0
: (settings->flags & P7_PARODD) ? 1 : 2;
unsigned int speed = settings->p7_streamsettings_speed;
int stopbits = (settings->p7_streamsettings_flags & P7_TWOSTOPBITS) + 1;
int parity = (~settings->p7_streamsettings_flags & P7_PARENB) ? 0
: (settings->p7_streamsettings_flags & P7_PARODD) ? 1 : 2;
/* make checks */
chk_handle(handle);
@ -55,16 +55,18 @@ int p7_setlink(p7_handle_t *handle, const p7_streamsettings_t *settings)
if ((err = p7_seven_send_cmdsys_setlink(handle, speed, parity, stopbits))) {
log_fatal("could not set command/receive answer");
return (err);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
err = p7_error_unknown;
goto end;
}
/* set communication properties */
log_info("updating communication settings accordingly");
handle->_settings.speed = speed;
handle->_settings.flags &= ~(P7_STOPBITSMASK | P7_PARMASK);
handle->_settings.flags |= settings->flags & (P7_STOPBITSMASK | P7_PARMASK);
handle->_settings.p7_streamsettings_speed = speed;
handle->_settings.p7_streamsettings_flags &=
~(P7_STOPBITSMASK | P7_PARMASK);
handle->_settings.p7_streamsettings_flags |=
settings->p7_streamsettings_flags & (P7_STOPBITSMASK | P7_PARMASK);
p7_setcomm(&handle->_stream, &handle->_settings);
end:

7
src/usage/storage/copy.c
View File

@ -52,14 +52,15 @@ int p7_copy(p7_handle_t *handle,
newname, devname))) {
log_fatal("couldn't send command/get its response");
return (err);
} else if (response.type != p7_seven_type_ack
&& response.type != p7_seven_type_error) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
&& response.p7_seven_packet_type != p7_seven_type_error) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
/* - check error - */
if (response.type == p7_seven_type_error) switch (response.code) {
if (response.p7_seven_packet_type == p7_seven_type_error)
switch (response.p7_seven_packet_code) {
/* overwrite impossible */
case p7_seven_err_dont_overwrite:
case p7_seven_err_other:

7
src/usage/storage/createdir.c
View File

@ -43,14 +43,15 @@ int p7_createdir(p7_handle_t *handle, const char *dirname, const char *devname)
if ((err = p7_seven_send_cmdfls_mkdir(handle, dirname, devname))) {
log_fatal("couldn't send command/get its response");
return (err);
} else if (response.type != p7_seven_type_ack
&& response.type != p7_seven_type_error) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
&& response.p7_seven_packet_type != p7_seven_type_error) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
/* check error */
if (response.type == p7_seven_type_error) switch (response.code) {
if (response.p7_seven_packet_type == p7_seven_type_error)
switch (response.p7_seven_packet_code) {
default:
log_fatal("unknown/unmanaged error");
return (p7_error_unknown);

7
src/usage/storage/delete.c
View File

@ -50,14 +50,15 @@ int p7_delete(p7_handle_t *handle,
dirname, filename, devname))) {
log_fatal("couldn't send command/get its response");
return (err);
} else if (response.type != p7_seven_type_ack
&& response.type != p7_seven_type_error) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
&& response.p7_seven_packet_type != p7_seven_type_error) {
log_fatal("received an invalid answer");
return (p7_error_unknown);
}
/* - check error - */
if (response.type == p7_seven_type_error) switch (response.code) {
if (response.p7_seven_packet_type == p7_seven_type_error)
switch (response.p7_seven_packet_code) {
case p7_seven_err_other:
log_fatal("file not found");
return (p7_error_notfound);

15
src/usage/storage/getfreemem.c
View File

@ -45,11 +45,11 @@ int p7_getfreemem(p7_handle_t *handle, const char *devname,
}
/* check response packet */
if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("filesystem probably doesn't exist");
return (p7_error_unsupported_device);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("didn't receive ack or known error...");
return (p7_error_unknown);
}
@ -59,21 +59,22 @@ int p7_getfreemem(p7_handle_t *handle, const char *devname,
if ((err = p7_seven_send_swp(handle))) {
log_fatal("couldn't swap roles");
return (err);
} else if (response.type != p7_seven_type_cmd || response.code != 0x4C
|| !response.args[4]) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd
|| response.p7_seven_packet_code != 0x4C
|| !response.p7_seven_packet_args[4]) {
log_fatal("didn't receive expected command");
return (p7_error_unknown);
}
/* decode thingy */
*capacity = response.filesize;
*capacity = response.p7_seven_packet_filesize;
/* ack and check for the roleswap */
log_info("return ack and wait for roleswp");
if ((err = p7_seven_send_ack(handle, 1))) {
log_fatal("unable to send ack.");
return (err);
} else if (response.type != p7_seven_type_swp)
} else if (response.p7_seven_packet_type != p7_seven_type_swp)
return (p7_error_unknown);
/* no error! */

14
src/usage/storage/list.c
View File

@ -45,11 +45,11 @@ int p7_list(p7_handle_t *handle, const char *devname,
if ((err = p7_seven_send_cmdfls_reqallinfo(handle, devname))) {
log_fatal("couldn't send file transfer request/didn't receive answer");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("invalid filesystem");
return (p7_error_unsupported_device);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("didn't receive ack or known error...");
return (p7_error_unknown);
}
@ -65,7 +65,7 @@ int p7_list(p7_handle_t *handle, const char *devname,
while (1) {
/* check answer */
char *dir, *filename; unsigned int fs;
switch (response.type) {
switch (response.p7_seven_packet_type) {
/* - if is roleswap, we have finished our job here - */
case p7_seven_type_roleswp:
return (0);
@ -73,9 +73,9 @@ int p7_list(p7_handle_t *handle, const char *devname,
/* - if is command, should be another file info - */
case p7_seven_type_cmd:
/* check args */
dir = response.args[0];
filename = response.args[1];
fs = response.filesize;
dir = response.p7_seven_packet_args[0];
filename = response.p7_seven_packet_args[1];
fs = response.p7_seven_packet_filesize;
/* device root should not be sent */
if (!dir && !filename) continue;
/* call callback */

6
src/usage/storage/optimize.c
View File

@ -41,11 +41,11 @@ int p7_optimize(p7_handle_t *handle, const char *devname)
if ((err = p7_seven_send_cmdfls_opt(handle, devname))) {
log_fatal("couldn't send command/receive its answer");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("storage device does not exist");
return (p7_error_unsupported_device);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response wasn't ack");
return (p7_error_unknown);
}

18
src/usage/storage/request.c
View File

@ -54,11 +54,11 @@ int p7_request(p7_handle_t *handle, const p7_buffer_t *buffer,
}
/* check response packet */
if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("requested file doesn't exist");
return (p7_error_notfound);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("didn't receive ack or known error...");
return (p7_error_unknown);
}
@ -68,17 +68,19 @@ int p7_request(p7_handle_t *handle, const p7_buffer_t *buffer,
if ((err = p7_seven_send_swp(handle))) {
log_fatal("couldn't swap roles");
return (err);
} else if (response.type != p7_seven_type_cmd || response.code != 0x45) {
} else if (response.p7_seven_packet_type != p7_seven_type_cmd
|| response.p7_seven_packet_code != 0x45) {
log_fatal("didn't receive expected command");
return (p7_error_unknown);
}
/* get data */
if ((err = p7_seven_get_buffer(handle, buffer, response.filesize, 0, disp)))
if ((err = p7_seven_get_buffer(handle, buffer,
response.p7_seven_packet_filesize, 0, disp)))
return (err);
/* check if last answer was roleswap */
if (response.type != p7_seven_type_roleswp)
if (response.p7_seven_packet_type != p7_seven_type_roleswp)
return (p7_error_unknown);
/* no error! */
@ -105,8 +107,8 @@ int p7_reqfile(p7_handle_t *handle, FILE *file,
{
chk_iswrite(file);
p7_buffer_t buffer = {
.cookie = file,
.write = p7_filebuffer_write
.p7_buffer_cookie = file,
.p7_buffer_write = p7_filebuffer_write
};
return (p7_request(handle, &buffer, dirname, filename, devname, disp));

6
src/usage/storage/reset.c
View File

@ -41,11 +41,11 @@ int p7_reset(p7_handle_t *handle, const char *devname)
if ((err = p7_seven_send_cmdfls_reset(handle, devname))) {
log_fatal("couldn't send command/receive its answer");
return (err);
} else if (response.type == p7_seven_type_error
&& response.code == p7_seven_err_other) {
} else if (response.p7_seven_packet_type == p7_seven_type_error
&& response.p7_seven_packet_code == p7_seven_err_other) {
log_fatal("storage device doesn't exist");
return (p7_error_unsupported_device);
} else if (response.type != p7_seven_type_ack) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response wasn't ack");
return (p7_error_unknown);
}

31
src/usage/storage/send.c
View File

@ -41,7 +41,7 @@ int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
int err;
/* make checks */
chk_filesize(buffer->size);
chk_filesize(buffer->p7_buffer_size);
chk_required_filename(filename);
chk_dirname(dirname);
chk_bufread(buffer);
@ -59,18 +59,19 @@ int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
/* send command packet and check answer */
log_info("sending file transfer command");
if ((err = p7_seven_send_cmdfls_sendfile(handle, owmode, buffer->size,
dirname, filename, devname))) {
if ((err = p7_seven_send_cmdfls_sendfile(handle, owmode,
buffer->p7_buffer_size, dirname, filename, devname))) {
log_fatal("couldn't send file transfer packet/didn't receive answer");
return (err);
} else if (response.type != p7_seven_type_ack
&& response.type != p7_seven_type_error) {
} else if (response.p7_seven_packet_type != p7_seven_type_ack
&& response.p7_seven_packet_type != p7_seven_type_error) {
log_fatal("file transfer answer was unknown");
return (p7_error_unknown);
}
/* - checking what happened if it is an error packet - */
if (response.type == p7_seven_type_error) switch (response.code) {
if (response.p7_seven_packet_type == p7_seven_type_error)
switch (response.p7_seven_packet_code) {
/* file exists, confirm or not */
case p7_seven_err_overwrite:
log_info("calc wanted overwrite confirmation");
@ -80,7 +81,7 @@ int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
log_info("sending yes to overwrite confirmation");
if ((err = p7_seven_confirm_ow(handle)))
return (err);
else if (response.type != p7_seven_type_ack) {
else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response packet wasn't ack");
return (p7_error_unknown);
}
@ -89,7 +90,7 @@ int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
log_info("sending no to overwrite confirmation");
if ((err = p7_seven_deny_ow(handle)))
return (err);
else if (response.type != p7_seven_type_ack) {
else if (response.p7_seven_packet_type != p7_seven_type_ack) {
log_fatal("response packet wasn't ack");
return (p7_error_unknown);
}
@ -114,7 +115,7 @@ int p7_send(p7_handle_t *handle, const p7_buffer_t *buffer,
/* send data */
if ((err = p7_seven_send_buffer(handle, buffer,
handle->_stream.flags & p7_streamflag_usb, disp)))
handle->_stream.p7_stream_flags & p7_streamflag_usb, disp)))
return (err);
/* we're done */
@ -158,9 +159,9 @@ int p7_sendfile(p7_handle_t *handle,
/* prepare the buffer */
p7_buffer_t buffer = {
.cookie = file,
.size = size,
.read = p7_filebuffer_read
.p7_buffer_cookie = file,
.p7_buffer_size = size,
.p7_buffer_read = p7_filebuffer_read
};
/* send file */
@ -196,9 +197,9 @@ int p7_sendmem(p7_handle_t *handle, const void *mem, size_t size,
/* make the buffer */
p7_cursor_t cursor = {.mem = mem};
p7_buffer_t buffer = {
.cookie = &cursor,
.size = size,
.read = p7_membuffer_read
.p7_buffer_cookie = &cursor,
.p7_buffer_size = size,
.p7_buffer_read = p7_membuffer_read
};
/* real func */

29
src/utils/scsi.c
View File

@ -74,25 +74,26 @@ struct scsi_cdb16 {
int p7_scsi_correct(p7_scsi_t *request)
{
if (request->cmd_len > 16) return (p7_error_unknown);
memset(request->cmd, 0, request->cmd_len); /* TODO: length from type? */
if (request->p7_scsi_cmd_len > 16) return (p7_error_unknown);
memset(request->p7_scsi_cmd, 0,
request->p7_scsi_cmd_len); /* TODO: length from type? */
switch (request->type) {
case 10:; struct scsi_cdb10 *c10 = (void*)request->cmd;
c10->type = request->type;
switch (request->p7_scsi_type) {
case 10:; struct scsi_cdb10 *c10 = (void*)request->p7_scsi_cmd;
c10->type = request->p7_scsi_type;
c10->special = 0;
c10->lba = htobe32((uint32_t)request->logical_block);
c10->misc = request->misc;
c10->btl = htobe16((uint32_t)request->byte_transfer_length);
c10->lba = htobe32((uint32_t)request->p7_scsi_logical_block);
c10->misc = request->p7_scsi_misc;
c10->btl = htobe16((uint32_t)request->p7_scsi_byte_transfer_length);
c10->control = 0; /* make this a request member? */
break;
case 16:; struct scsi_cdb16 *c16 = (void*)request->cmd;
c16->type = request->type;
case 16:; struct scsi_cdb16 *c16 = (void*)request->p7_scsi_cmd;
c16->type = request->p7_scsi_type;
c16->special = 0;
c16->lb = htobe32((uint32_t)request->logical_block);
memcpy(c16->cbp, request->cbp, 4);
c16->all = htobe32((uint32_t)request->allocation_length);
c16->misc = request->misc;
c16->lb = htobe32((uint32_t)request->p7_scsi_logical_block);
memcpy(c16->cbp, request->p7_scsi_cbp, 4);
c16->all = htobe32((uint32_t)request->p7_scsi_allocation_length);
c16->misc = request->p7_scsi_misc;
c16->control = 0; /* make this a request member? */
break;
default: return (p7_error_unknown);

13
src/utils/settings.c
View File

@ -24,8 +24,9 @@
/* ************************************************************************** */
/* default settings */
static p7_streamsettings_t default_settings = {
.flags = P7_TWOSTOPBITS | P7_DTRCTL_ENABLE | P7_RTSCTL_ENABLE,
.speed = P7_B9600,
.p7_streamsettings_flags =
P7_TWOSTOPBITS | P7_DTRCTL_ENABLE | P7_RTSCTL_ENABLE,
.p7_streamsettings_speed = P7_B9600,
};
/**
@ -79,10 +80,10 @@ int p7_makesettings(p7_streamsettings_t *settings, const char *s)
/* set the settings */
p7_initcomm(settings);
settings->speed = speed;
settings->flags &= ~(P7_TWOSTOPBITS | P7_PARMASK);
settings->flags |= --stop ? P7_TWOSTOPBITS : P7_ONESTOPBIT;
settings->flags |= par == 'N' ? P7_PARDIS :
settings->p7_streamsettings_speed = speed;
settings->p7_streamsettings_flags &= ~(P7_TWOSTOPBITS | P7_PARMASK);
settings->p7_streamsettings_flags |= --stop ? P7_TWOSTOPBITS : P7_ONESTOPBIT;
settings->p7_streamsettings_flags |= par == 'N' ? P7_PARDIS :
par == 'E' ? P7_PARENB | P7_PAREVEN : P7_PARENB | P7_PARODD;
return (0);
}