Skip to content

Commit 6e04a91

Browse files
0x00002a0x00002a
committed
chore: working on tls images
1 parent 84acfb1 commit 6e04a91

File tree

7 files changed

+193
-21
lines changed

7 files changed

+193
-21
lines changed

‎libfprint/drivers/goodixtls/goodix.c‎

Lines changed: 75 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -43,12 +43,15 @@ typedef struct {
4343

4444
gboolean ack;
4545
gboolean reply;
46+
gboolean tls;
4647

4748
GoodixCmdCallback callback;
4849
gpointer user_data;
4950

5051
guint8* data;
5152
guint32 length;
53+
54+
GoodixCallbackInfo* tls_ready_callback;
5255
} FpiDeviceGoodixTlsPrivate;
5356

5457
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(FpiDeviceGoodixTls, fpi_device_goodixtls,
@@ -360,6 +363,7 @@ void goodix_receive_pack(FpDevice *dev, guint8 *data, guint32 length) {
360363
if (!goodix_decode_pack(priv->data, priv->length, &flags, &payload,
361364
&payload_len, &valid_checksum)) {
362365
// Packet is not full, we still need data.
366+
fp_dbg("not full packet");
363367
return;
364368
}
365369

@@ -371,6 +375,9 @@ void goodix_receive_pack(FpDevice *dev, guint8 *data, guint32 length) {
371375

372376
case GOODIX_FLAGS_TLS:
373377
fp_dbg("Got TLS msg");
378+
if (!priv->tls) {
379+
fp_warn("unexpected tls packet");
380+
}
374381
goodix_receive_done(dev, payload, payload_len, NULL);
375382

376383
// TLS message sending it to TLS server.
@@ -534,7 +541,7 @@ void goodix_send_nop(FpDevice *dev, GoodixNoneCallback callback,
534541
goodix_receive_done(dev, NULL, 0, NULL);
535542
}
536543

537-
void goodix_send_mcu_get_image(FpDevice* dev, GoodixNoneCallback callback,
544+
void goodix_send_mcu_get_image(FpDevice* dev, GoodixImageCallback callback,
538545
gpointer user_data)
539546
{
540547
GoodixDefault payload = {.unused_flags = 0x01};
@@ -547,13 +554,13 @@ void goodix_send_mcu_get_image(FpDevice* dev, GoodixNoneCallback callback,
547554
cb_info->user_data = user_data;
548555

549556
goodix_send_protocol(dev, GOODIX_CMD_MCU_GET_IMAGE, (guint8*) &payload,
550-
sizeof(payload), NULL, TRUE, GOODIX_TIMEOUT, FALSE,
551-
goodix_receive_none, cb_info);
557+
sizeof(payload), NULL, TRUE, GOODIX_TIMEOUT, TRUE,
558+
goodix_receive_default, cb_info);
552559
return;
553560
}
554561

555562
goodix_send_protocol(dev, GOODIX_CMD_MCU_GET_IMAGE, (guint8*) &payload,
556-
sizeof(payload), NULL, TRUE, GOODIX_TIMEOUT, FALSE,
563+
sizeof(payload), NULL, TRUE, GOODIX_TIMEOUT, TRUE,
557564
NULL, NULL);
558565
}
559566

@@ -1024,6 +1031,7 @@ void goodix_read_tls(FpDevice* dev, GoodixTlsCallback callback,
10241031
priv->callback = callback;
10251032
priv->user_data = user_data;
10261033
priv->reply = TRUE;
1034+
priv->cmd = 0;
10271035
goodix_receive_data(FP_DEVICE(self));
10281036
}
10291037

@@ -1040,9 +1048,6 @@ static void on_goodix_tls_server_ready(GoodixTlsServer* server, GError* err,
10401048
fp_err("server ready failed: %s", err->message);
10411049
return;
10421050
}
1043-
FpiDeviceGoodixTls* self = FPI_DEVICE_GOODIXTLS(dev);
1044-
FpiDeviceGoodixTlsPrivate* priv =
1045-
fpi_device_goodixtls_get_instance_private(self);
10461051
fp_dbg("TLS connection ready");
10471052
}
10481053

@@ -1081,15 +1086,26 @@ enum goodix_tls_handshake_stages {
10811086

10821087
TLS_HANDSHAKE_STAGE_NUM,
10831088
};
1089+
1090+
static void on_tls_successfully_established(FpDevice* dev, gpointer user_data,
1091+
GError* error)
1092+
{
1093+
1094+
fp_dbg("HANDSHAKE DONE");
1095+
FpiDeviceGoodixTls* self = FPI_DEVICE_GOODIXTLS(dev);
1096+
FpiDeviceGoodixTlsPrivate* priv =
1097+
fpi_device_goodixtls_get_instance_private(self);
1098+
((GoodixNoneCallback) priv->tls_ready_callback->callback)(
1099+
dev, priv->tls_ready_callback->user_data, NULL);
1100+
}
10841101
static void tls_handshake_done(FpiSsm* ssm, FpDevice* dev, GError* error)
10851102
{
10861103
if (error) {
10871104
fp_dbg("failed to do tls handshake: %s (code: %d)", error->message,
10881105
error->code);
10891106
}
1090-
goodix_send_tls_successfully_established(dev, NULL, NULL);
1091-
1092-
fp_dbg("HANDSHAKE DONE");
1107+
goodix_send_tls_successfully_established(
1108+
dev, on_tls_successfully_established, NULL);
10931109
}
10941110
static void tls_handshake_run(FpiSsm* ssm, FpDevice* dev)
10951111
{
@@ -1178,13 +1194,20 @@ void goodix_tls_complete(FpiSsm *ssm, FpDevice *dev, GError *error) {
11781194
fpi_image_device_activate_complete(FP_IMAGE_DEVICE(dev), error);
11791195
}
11801196

1181-
void goodix_tls(FpDevice *dev) {
1197+
void goodix_tls(FpDevice* dev, GoodixNoneCallback callback, gpointer user_data)
1198+
{
11821199
fp_dbg("Starting up goodix tls server");
11831200
FpiDeviceGoodixTls* self = FPI_DEVICE_GOODIXTLS(dev);
11841201
FpiDeviceGoodixTlsPrivate* priv =
11851202
fpi_device_goodixtls_get_instance_private(self);
11861203
g_assert(priv->tls_hop == NULL);
11871204
priv->tls_hop = malloc(sizeof(GoodixTlsServer));
1205+
1206+
if (!priv->tls_ready_callback) {
1207+
priv->tls_ready_callback = malloc(sizeof(GoodixCallbackInfo));
1208+
}
1209+
priv->tls_ready_callback->callback = G_CALLBACK(callback);
1210+
priv->tls_ready_callback->user_data = user_data;
11881211
GoodixTlsServer* s = priv->tls_hop;
11891212
s->connection_callback = on_goodix_tls_server_ready;
11901213
s->user_data = self;
@@ -1197,6 +1220,47 @@ void goodix_tls(FpDevice *dev) {
11971220

11981221
goodix_tls_ready(s, err, self);
11991222
}
1223+
static void goodix_tls_ready_image_handler(FpDevice* dev, guint8* data,
1224+
guint16 length, gpointer user_data,
1225+
GError* error)
1226+
{
1227+
1228+
g_autofree GoodixCallbackInfo* cb_info = user_data;
1229+
GoodixImageCallback callback = (GoodixImageCallback) cb_info->callback;
1230+
if (error) {
1231+
callback(dev, NULL, 0, error, cb_info->user_data);
1232+
return;
1233+
}
1234+
FpiDeviceGoodixTls* self = FPI_DEVICE_GOODIXTLS(dev);
1235+
FpiDeviceGoodixTlsPrivate* priv =
1236+
fpi_device_goodixtls_get_instance_private(self);
1237+
goodix_tls_client_send(priv->tls_hop, data, length);
1238+
1239+
const guint16 size = -1;
1240+
guint8* buff = malloc(size);
1241+
GError* err = NULL;
1242+
if (!goodix_tls_server_receive(priv->tls_hop, buff, size, &err)) {
1243+
callback(dev, NULL, 0, err, cb_info->user_data);
1244+
return;
1245+
}
1246+
1247+
callback(dev, buff, size, cb_info->user_data, NULL);
1248+
}
1249+
1250+
void goodix_tls_read_image(FpDevice* dev, GoodixImageCallback callback,
1251+
gpointer user_data)
1252+
{
1253+
g_assert(callback);
1254+
FpiDeviceGoodixTls* self = FPI_DEVICE_GOODIXTLS(dev);
1255+
FpiDeviceGoodixTlsPrivate* priv =
1256+
fpi_device_goodixtls_get_instance_private(self);
1257+
GoodixCallbackInfo* cb_info = malloc(sizeof(GoodixImageCallback));
1258+
1259+
cb_info->callback = G_CALLBACK(callback);
1260+
cb_info->user_data = user_data;
1261+
1262+
goodix_send_mcu_get_image(dev, goodix_tls_ready_image_handler, cb_info);
1263+
}
12001264

12011265
// ---- TLS SECTION END ----
12021266

‎libfprint/drivers/goodixtls/goodix.h‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -67,6 +67,9 @@ typedef void (*GoodixDefaultCallback)(FpDevice *dev, guint8 *data,
6767
GError *error);
6868
typedef GoodixDefaultCallback GoodixTlsCallback;
6969

70+
typedef void (*GoodixImageCallback)(FpDevice* dev, guint8* data, guint16 length,
71+
gpointer user_data, GError* error);
72+
7073
gchar *data_to_str(guint8 *data, guint32 length);
7174

7275
// ---- GOODIX RECEIVE SECTION START ----
@@ -133,7 +136,7 @@ void goodix_send_protocol(FpDevice *dev, guint8 cmd, guint8 *payload,
133136
void goodix_send_nop(FpDevice *dev, GoodixNoneCallback callback,
134137
gpointer user_data);
135138

136-
void goodix_send_mcu_get_image(FpDevice *dev, GoodixNoneCallback callback,
139+
void goodix_send_mcu_get_image(FpDevice *dev, GoodixImageCallback callback,
137140
gpointer user_data);
138141

139142
void goodix_send_mcu_switch_to_fdt_down(FpDevice *dev, guint8 *mode,
@@ -233,6 +236,9 @@ void goodix_tls_run_state(FpiSsm* ssm, FpDevice* dev);
233236

234237
void goodix_tls_complete(FpiSsm *ssm, FpDevice *dev, GError *error);
235238

236-
void goodix_tls(FpDevice *dev);
239+
void goodix_tls(FpDevice* dev, GoodixNoneCallback callback, gpointer user_data);
240+
241+
void goodix_tls_read_image(FpDevice* dev, GoodixImageCallback callback,
242+
gpointer user_data);
237243

238244
// ---- TLS SECTION END ----

‎libfprint/drivers/goodixtls/goodix511.c‎

Lines changed: 105 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,9 @@
2222
#include "fpi-assembling.h"
2323
#include "fpi-image-device.h"
2424
#include "fpi-ssm.h"
25+
#include "glibconfig.h"
2526
#include "gusb/gusb-device.h"
27+
#include <stdio.h>
2628
#define FP_COMPONENT "goodixtls511"
2729

2830
#include <glib.h>
@@ -249,20 +251,119 @@ static void activate_run_state(FpiSsm *ssm, FpDevice *dev) {
249251
}
250252
}
251253

252-
static void activate_complete(FpiSsm *ssm, FpDevice *dev, GError *error) {
253-
G_DEBUG_HERE();
254+
static void tls_activation_complete(FpDevice* dev, gpointer user_data,
255+
GError* error)
256+
{
257+
if (error) {
258+
fp_err("failed to complete tls activation: %s", error->message);
259+
return;
260+
}
254261
FpImageDevice* image_dev = FP_IMAGE_DEVICE(dev);
255262

256263
fpi_image_device_activate_complete(image_dev, error);
264+
}
257265

266+
static void activate_complete(FpiSsm* ssm, FpDevice* dev, GError* error)
267+
{
268+
G_DEBUG_HERE();
258269
if (!error)
259-
goodix_tls(dev);
270+
goodix_tls(dev, tls_activation_complete, NULL);
260271
}
261272

262273
// ---- ACTIVE SECTION END ----
263274

264275
// -----------------------------------------------------------------------------
265276

277+
// ---- SCAN SECTION START ----
278+
279+
enum SCAN_STAGES {
280+
SCAN_STAGE_SWITCH_TO_FDT_MODE,
281+
SCAN_STAGE_SWITCH_TO_FDT_DOWN,
282+
SCAN_STAGE_GET_IMG,
283+
284+
SCAN_STAGE_NUM,
285+
};
286+
287+
static void check_none_cmd(FpDevice* dev, guint8* data, guint16 len,
288+
gpointer ssm, GError* err)
289+
{
290+
if (err) {
291+
fpi_ssm_mark_failed(ssm, err);
292+
return;
293+
}
294+
fpi_ssm_next_state(ssm);
295+
}
296+
297+
static void scan_on_read_img(FpDevice* dev, guint8* data, guint16 len,
298+
gpointer ssm, GError* err)
299+
{
300+
if (err) {
301+
fpi_ssm_mark_failed(ssm, err);
302+
return;
303+
}
304+
fp_dbg("Got image");
305+
FILE* out = fopen("./fingerprint.pgm", "wb");
306+
fwrite(data, sizeof(guint8), len, out);
307+
fclose(out);
308+
fpi_ssm_next_state(ssm);
309+
}
310+
311+
static void scan_get_img(FpDevice* dev, FpiSsm* ssm)
312+
{
313+
goodix_tls_read_image(dev, scan_on_read_img, ssm);
314+
}
315+
const guint8 fdt_switch_state_mode[] = {0x0d, 0x01, 0x80, 0xaf, 0x80, 0xa4,
316+
0x80, 0xb8, 0x80, 0xa8, 0x80, 0xb7};
317+
318+
const guint8 fdt_switch_state_down[] = {0x0c, 0x01, 0x80, 0xaf, 0x80, 0xa4,
319+
0x80, 0xb8, 0x80, 0xa8, 0x80, 0xb7};
320+
321+
/*
322+
323+
const guint8 fdt_switch_state_mode[] = {0x0d, 0x01, 0x80, 0xaf, 0x80, 0xa3,
324+
0x80, 0xb7, 0x80, 0xa7, 0x80, 0xb6};
325+
326+
const guint8 fdt_switch_state_down[] = {0x0d, 0x01, 0x80, 0xaf, 0x80,
327+
0xbf, 0x80, 0xa4, 0x80, 0xb8,
328+
0x80, 0xa8, 0x80, 0xb7};
329+
*/
330+
331+
static void scan_run_state(FpiSsm* ssm, FpDevice* dev)
332+
{
333+
switch (fpi_ssm_get_cur_state(ssm)) {
334+
case SCAN_STAGE_SWITCH_TO_FDT_MODE:
335+
goodix_send_mcu_switch_to_fdt_mode(dev, fdt_switch_state_mode,
336+
sizeof(fdt_switch_state_mode), NULL,
337+
check_none_cmd, ssm);
338+
break;
339+
case SCAN_STAGE_SWITCH_TO_FDT_DOWN:
340+
goodix_send_mcu_switch_to_fdt_down(dev, fdt_switch_state_down,
341+
sizeof(fdt_switch_state_down), NULL,
342+
check_none_cmd, ssm);
343+
break;
344+
case SCAN_STAGE_GET_IMG:
345+
scan_get_img(dev, ssm);
346+
break;
347+
}
348+
}
349+
350+
static void scan_complete(FpiSsm* ssm, FpDevice* dev, GError* error)
351+
{
352+
if (error) {
353+
fp_err("failed to scan: %s (code: %d)", error->message, error->code);
354+
return;
355+
}
356+
fp_dbg("finished scan");
357+
}
358+
359+
static void scan_start(FpiDeviceGoodixTls511* dev)
360+
{
361+
fpi_ssm_start(fpi_ssm_new(FP_DEVICE(dev), scan_run_state, SCAN_STAGE_NUM),
362+
scan_complete);
363+
}
364+
365+
// ---- SCAN SECTION END ----
366+
266367
// ---- DEV SECTION START ----
267368

268369
static void dev_init(FpImageDevice *img_dev) {
@@ -304,6 +405,7 @@ static void dev_change_state(FpImageDevice* img_dev, FpiImageDeviceState state)
304405
G_DEBUG_HERE();
305406

306407
if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON) {
408+
scan_start(self);
307409
}
308410
}
309411

‎libfprint/drivers/goodixtls/goodix_proto.c‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -84,8 +84,7 @@ gboolean goodix_decode_pack(guint8 *data, guint32 data_len, guint8 *flags,
8484

8585
if (data_len < sizeof(GoodixPack) + sizeof(guint8)) return FALSE;
8686

87-
length = pack->length; // length = GUINT16_FROM_LE(pack->length);
88-
printf("SIZE: %d\n", length);
87+
length = GUINT16_FROM_LE(pack->length);
8988

9089
if (data_len < length + sizeof(GoodixPack) + sizeof(guint8)) return FALSE;
9190

‎libfprint/drivers/goodixtls/goodix_proto.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@
1919

2020
#pragma once
2121

22-
#define GOODIX_EP_IN_MAX_BUF_SIZE (0x2000)
22+
#define GOODIX_EP_IN_MAX_BUF_SIZE (0x10000)
2323
#define GOODIX_EP_OUT_MAX_BUF_SIZE (0x40)
2424

2525
#define GOODIX_NULL_CHECKSUM (0x88)

‎libfprint/drivers/goodixtls/goodixtls.c‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -96,14 +96,15 @@ static void tls_server_config_ctx(SSL_CTX* ctx)
9696

9797
int goodix_tls_client_send(GoodixTlsServer* self, guint8* data, guint16 length)
9898
{
99+
fp_dbg("sent: %s size: %d", data_to_str(data, length), length);
99100
return write(self->client_fd, data, length * sizeof(guint8));
100101
}
101102
int goodix_tls_client_recv(GoodixTlsServer* self, guint8* data, guint16 length) {
102103
return read(self->client_fd, data, length * sizeof(guint8));
103104
}
104105

105106
int goodix_tls_server_receive(GoodixTlsServer* self, guint8* data,
106-
guint16 length, GError** error)
107+
guint32 length, GError** error)
107108
{
108109
fp_dbg("READ START");
109110
int retr = SSL_read(self->ssl_layer, data, length * sizeof(guint8));

‎libfprint/drivers/goodixtls/goodixtls.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ gboolean goodix_tls_init_cli(GoodixTlsServer* self, GError** err);
7979
// This can be called multiple times. It is called when the device send a TLS
8080
// packet.
8181
int goodix_tls_server_receive(GoodixTlsServer* self, guint8* data,
82-
guint16 length, GError** error);
82+
guint32 length, GError** error);
8383

8484
int goodix_tls_client_send(GoodixTlsServer* self, guint8* data, guint16 length);
8585

0 commit comments

Comments
 (0)