cake
/
libp7
Archived
1
0
Fork 1
Code

Should have introduced packet shifting correctly

This commit is contained in:
Thomas Touhey 2016-09-04 17:29:12 +02:00
parent 9694060432
commit ee2ad1ab9a
8 changed files with 207 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/libp7.h
View File

@ -65,7 +65,7 @@ int p7_init(void);
/* Protocol */
/* ************************************************************************** */
/* Initializer and terminator */
int p7_start(void);
int p7_start(int shift);
int p7_term(void);
/* Get info */
@ -81,4 +81,7 @@ int p7_reqfile(FILE *file, char *dirname, char *filename, char *devname);
/* Delete distant file */
int p7_delfile(char *dirname, char *filename, char *devname);
/* Unshift (get response without sending) */
int p7_unshift(void);
#endif /* LIBP7_H */

14
include/libp7/internals.h
View File

@ -41,10 +41,11 @@
int p7_send_basic(unsigned int type, unsigned int subtype, int resp);
int p7_send_ext(unsigned int type, unsigned int subtype,
void *data, unsigned int size, int resp);
int p7_recv(void);
int p7_send_again(void);
int p7_recv(unsigned char *lastbuf, int lastbuf_size);
/* Resend error packet (meant to be used with recv, not suited for public) */
int p7_send_err_resend(void);
int p7_send_err_resend(unsigned char *lastbuf, int lastbuf_size);
/* ************************************************************************** */
/* Useful globals */
@ -55,14 +56,19 @@ extern libusb_device_handle *p7_lusb_handler;
/* Is active */
extern int p7_active;
/* Is shifted */
extern int p7_shifted;
/* last sent command */
extern unsigned int p7_last_sent_command;
/* ************************************************************************** */
/* Buffers */
/* ************************************************************************** */
/* raw sending packet buffer */
extern unsigned char *p7_send_buffer;
/* raw sending packet buffers */
extern unsigned char *p7_send_buffers[2];
extern int p7_send_buffers_size[2];
extern int p7_send_buffer_id;
/* raw reception packet buffer */
extern unsigned char *p7_recv_buffer;

16
src/core/init.c
View File

@ -32,6 +32,13 @@ int p7_error = p7_noerror;
int p7_active;
/**
* p7_shifted:
* Boolean to know if we are shifted.
*/
int p7_shifted;
/**
* p7_lusb_context:
* libusb context used by libp7.
@ -59,8 +66,9 @@ static void p7_exit(void)
/* free buffers */
/* - raw reception packet buffer - */
if (p7_recv_buffer) free(p7_recv_buffer);
/* - raw sending packet buffer - */
if (p7_send_buffer) free(p7_send_buffer);
/* - raw sending packet buffers - */
if (p7_send_buffers[0]) free(p7_send_buffers[0]);
if (p7_send_buffers[1]) free(p7_send_buffers[1]);
/* - decoded packet buffer - */
if (p7_response) free(p7_response);
@ -144,7 +152,9 @@ int p7_init(void)
}
/* allocating buffers */
if (!(p7_send_buffer = malloc(MAX_PACKET_SIZE)))
if (!(p7_send_buffers[0] = malloc(MAX_PACKET_SIZE)))
return (0);
if (!(p7_send_buffers[1] = malloc(MAX_PACKET_SIZE)))
return (0);
if (!(p7_recv_buffer = malloc(MAX_PACKET_SIZE)))
return (0);

8
src/packet/recv.c
View File

@ -451,10 +451,12 @@ static int p7_recv_main(void)
* p7_recv:
* Receives packet, checks for errors.
*
* @return if it worked
* @arg lastbuf last sending buffer
* @arg lastbuf_size last sending buffer size
* @return if it worked
*/
int p7_recv(void)
int p7_recv(unsigned char *lastbuf, int lastbuf_size)
{
int tries = 2, fail = 0;
@ -480,7 +482,7 @@ int p7_recv(void)
/* reset tries number in case of bad checksum between timeouts */
case p7_error_checksum:
tries = 0;
if (p7_send_err_resend())
if (p7_send_err_resend(lastbuf, lastbuf_size))
fail = 0;
break;
}

156
src/packet/send.c
View File

@ -17,12 +17,27 @@
/* Buffers */
/* ************************************************************************** */
/**
* p7_send_buffer:
* p7_send_buffers:
* Sending packet buffer.
*/
#define buffer p7_send_buffer
unsigned char *p7_send_buffer;
#define buffer p7_send_buffers[p7_send_buffer_id]
unsigned char *p7_send_buffers[2];
/**
* p7_send_buffers_size:
* Sending packet buffer sizes.
*/
#define buffer_size p7_send_buffers_size[p7_send_buffer_id]
int p7_send_buffers_size[2];
/**
* p7_send_buffer_id:
* ID of the current send buffer.
*/
int p7_send_buffer_id = 0;
/* ************************************************************************** */
/* Main functions */
@ -32,27 +47,41 @@ unsigned char *p7_send_buffer;
* Send resend request.
*
* In case of bad checksum. As this is a special packet ("meta" packet ?), we
* do not want to use up the send buffer for this.
* do not want to use up a send buffer for this - packets like this one could
* be recursive !
*
* No need for a "special function" like this as sending a "resend" packet
* means that what we've received was invalid.
* No need for a "special function" like this for receiving, as sending
* a "resend" packet means that what we've received was invalid.
*
* @return if it worked
* @arg lastbuf last buffer
* @arg lastbuf_size last buffer size
* @return if it worked
*/
int p7_send_err_resend(void)
int p7_send_err_resend(unsigned char *lastbuf, int lastbuf_size)
{
static unsigned char rpack[] = {p7_pt_error, '0', '1', '0', '6', 'F'};
static unsigned char rpack[] = {p7_pt_error, '0', '1', '0', '6', 'F', 0};
/* log packet */
log_info("sending the following resend (basic) packet :");
logm_info(rpack, 6);
logm_info(rpack, 7);
/* sending loop */
int wasresend = 0, got_response = 0; int tf;
int wasresend = 0, was_for_last = 1, got_response = 0; int tf;
unsigned char *buf = rpack; int buf_size = 7;
do {
/* log resend */
if (wasresend) {
if (p7_shifted) {
if (was_for_last) {
buf = lastbuf;
buf_size = lastbuf_size;
} else {
buf = rpack;
buf_size = 7;
}
was_for_last = !was_for_last;
}
log_warn("resend request was received, resend it goes");
}
@ -61,7 +90,7 @@ int p7_send_err_resend(void)
long ts = p7_get_ms();
#endif
int err = libusb_bulk_transfer(p7_lusb_handler, ENDPOINT_OUT,
rpack, 6, &tf, SENDNG_TIMEOUT);
buf, buf_size, &tf, SENDNG_TIMEOUT);
log_info("packet sent, sending took %ldµs", p7_get_ms() - ts);
/* check error */
@ -88,7 +117,7 @@ int p7_send_err_resend(void)
p7_error = p7_error_unknown;
return (0);
}
} while ((got_response = p7_recv())
} while ((got_response = p7_recv(buf, buf_size))
&& response.type == p7_pt_error
&& response.error.code == p7_ec_resend);
@ -113,22 +142,26 @@ int p7_send_basic(unsigned int type, unsigned int subtype, int resp)
return (0);
}
/* prepare packet */
/* change buffer and prepare packet */
p7_send_buffer_id = !p7_send_buffer_id;
buffer[0] = (unsigned char)type;
p7_putascii(&buffer[1], subtype, 2);
buffer[3] = '0';
p7_putascii(&buffer[4], p7_checksum(buffer, 6), 2);
buffer[6] = 0;
buffer_size = 7;
/* log packet */
log_info("sending the following basic packet :");
logm_info(buffer, 7);
logm_info(buffer, buffer_size);
/* sending loop */
int wasresend = 0, got_response = 1; int tf;
do {
/* log resend */
/* resend */
if (wasresend) {
if (p7_shifted)
p7_send_buffer_id = !p7_send_buffer_id;
log_warn("resend request was received, resend it goes");
}
@ -137,7 +170,7 @@ int p7_send_basic(unsigned int type, unsigned int subtype, int resp)
long ts = p7_get_ms();
#endif
int err = libusb_bulk_transfer(p7_lusb_handler, ENDPOINT_OUT,
buffer, 7, &tf, SENDNG_TIMEOUT);
buffer, buffer_size, &tf, SENDNG_TIMEOUT);
log_info("packet sent, sending took %ldµs", p7_get_ms() - ts);
/* check error */
@ -164,7 +197,7 @@ int p7_send_basic(unsigned int type, unsigned int subtype, int resp)
p7_error = p7_error_unknown;
return (0);
}
} while (resp && (got_response = p7_recv())
} while (resp && (got_response = p7_recv(buffer, buffer_size))
&& response.type == p7_pt_error
&& response.error.code == p7_ec_resend);
@ -193,7 +226,8 @@ int p7_send_ext(unsigned int type, unsigned int subtype,
return (0);
}
/* fill packet buffer */
/* change buffer and prepare packet */
p7_send_buffer_id = !p7_send_buffer_id;
/* - first infos - */
buffer[0] = (unsigned char)type;
p7_putascii(&buffer[1], subtype, 2);
@ -204,16 +238,19 @@ int p7_send_ext(unsigned int type, unsigned int subtype,
/* - checksum - */
p7_putascii(&buffer[8 + size], p7_checksum(buffer, 8 + size + 2), 2);
buffer[8 + size + 2] = 0;
buffer_size = 8 + size + 3;
/* log packet */
log_info("sending the following extended packet :");
logm_info(buffer, 8 + size + 3);
logm_info(buffer, buffer_size);
/* sending loop */
int wasresend = 0, got_response = 1; int transferred;
do {
/* log resend request */
if (wasresend) {
if (p7_shifted)
p7_send_buffer_id = !p7_send_buffer_id;
log_warn("resend request was received, resend it goes");
}
@ -222,7 +259,7 @@ int p7_send_ext(unsigned int type, unsigned int subtype,
long ts = p7_get_ms();
#endif
int err = libusb_bulk_transfer(p7_lusb_handler, ENDPOINT_OUT,
buffer, 8 + (int)size + 3, &transferred, SENDNG_TIMEOUT);
buffer, buffer_size, &transferred, SENDNG_TIMEOUT);
log_info("packet sent, sending took %ldµs", p7_get_ms() - ts);
/* check error */
@ -252,7 +289,82 @@ int p7_send_ext(unsigned int type, unsigned int subtype,
/* set wasreset for logging */
wasresend = 1;
} while (resp && (got_response = p7_recv())
} while (resp && (got_response = p7_recv(buffer, buffer_size))
&& response.type == p7_pt_error
&& response.error.code == p7_ec_resend);
/* packet sending is finished */
return (got_response);
}
/**
* p7_send_again:
* Send the last packet again.
*
* Useful for when resending wasn't managed in one of the previous functions.
* Only used for unshifting right now.
*
* @return if it worked
*/
int p7_send_again(void)
{
/* check if handler is initialized */
if (!p7_lusb_handler) {
p7_error = p7_error_uninitialized;
return (0);
}
/* log packet */
log_info("sending again the following extended packet :");
logm_info(buffer, buffer_size);
/* sending loop */
int wasresend = 0, got_response = 1; int transferred;
do {
/* log resend request */
if (wasresend) {
if (p7_shifted)
p7_send_buffer_id = !p7_send_buffer_id;
log_warn("resend request was received, resend it goes");
}
/* send prepared packet */
#if LOGLEVEL <= ll_info
long ts = p7_get_ms();
#endif
int err = libusb_bulk_transfer(p7_lusb_handler, ENDPOINT_OUT,
buffer, buffer_size, &transferred, SENDNG_TIMEOUT);
log_info("packet sent, sending took %ldµs", p7_get_ms() - ts);
/* check error */
switch (err) {
/* - timeout error - */
case LIBUSB_ERROR_TIMEOUT:
log_error("timeout received");
p7_error = p7_error_timeout;
return (0);
/* - device disconnected - */
case LIBUSB_ERROR_PIPE:
case LIBUSB_ERROR_NO_DEVICE:
log_fatal("calculator was disconnected");
p7_error = p7_error_nocalc;
return (0);
/* - unknown error - */
case 0: break;
default:
log_fatal("libusb_bulk_transfer returned %d: %s", err,
libusb_error_name(err));
log_fatal("errno was %d: %s", errno, strerror(errno));
p7_error = p7_error_unknown;
return (0);
}
/* set wasreset for logging */
wasresend = 1;
} while ((got_response = p7_recv(buffer, buffer_size))
&& response.type == p7_pt_error
&& response.error.code == p7_ec_resend);

4
src/packet/send_check.c
View File

@ -38,7 +38,9 @@ int p7_send_check(int initial, int shift)
/* experimental and dangerous when it comes to errors/checks */
if (shift) {
log_info("shifting...");
p7_send_basic(T, subtype, 0);
p7_shifted = 1;
if (!p7_send_basic(T, subtype, 0))
return (0);
}
/* then send normal packet */

35
src/packet/shift.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* _____ _ */
/* shift.c |_ _|__ _ _| |__ ___ _ _ */
/* | Project : libp7 | |/ _ \| | | | '_ \ / _ \ | | | */
/* | | (_) | |_| | | | | __/ |_| | */
/* By: thomas <thomas@touhey.fr> |_|\___/ \__,_|_| |_|\___|\__, |.fr */
/* Last updated: 2016/09/04 15:06:59 |___/ */
/* */
/* ************************************************************************** */
#include <libp7/internals.h>
/**
* p7_unshift:
* Unshift packet.
*
* @return if it worked
*/
int p7_unshift(void)
{
/* truly unshift */
if (!p7_recv(p7_send_buffers[p7_send_buffer_id],
p7_send_buffers_size[p7_send_buffer_id]))
return (0);
p7_shifted = 0;
/* check if last sent packet was okay */
while (response.type == p7_pt_error
&& response.error.code == p7_ec_resend)
if (!p7_send_again()) return (0);
/* then return */
return (1);
}

5
src/protocol/start.c
View File

@ -14,14 +14,15 @@
* p7_start:
* Initialize communication.
*
* @arg shift should initialize with packet shifting
* @return if it worked
*/
int p7_start(void)
int p7_start(int shift)
{
/* sending check packet */
log_info("sending initial check");
if (!p7_send_check(1, 0)) {
if (!p7_send_check(1, shift)) {
log_error("couldn't send check/didn't receive answer");
return (0);
}