« back to all changes in this revision
Viewing changes to src/nsp_cmd.c
- browse files at revision 5
- compare with another revision
- download diff
- download tarball
- view history from revision 5
- Committer: Package Import Robot
- Author(s): Andreas B. Mundt
- Date: 2013-08-27 19:58:21 UTC
- mfrom: (2.1.2 sid)
- Revision ID: package-import@ubuntu.com-20130827195821-biurlicyqb65gj3g
Tags: 1.1.8+dfsg2-2
* Provide original upstream source, but patch away pre-compiled
binaries to be policy-compliant.
* Remove unnecessary dependency on 'autopoint', use autoreconf.
binaries to be policy-compliant.
* Remove unnecessary dependency on 'autopoint', use autoreconf.
- files added:
- .pc
- .pc/ticalcs2-external-rom-dumpers.patch
- .pc/ticalcs2-external-rom-dumpers.patch/src
- debian/patches
- debian/source
- m4
- src/romdump_84p_usb
- files removed:
- build/fedora
- files modified:
- ABOUT-NLS
added
removed
src/nsp_cmd.c
1
/* Hey EMACS -*- linux-c -*- */
2
/* $Id: cmd84p.c 2077 2006-03-31 21:16:19Z roms $ */
3
4
/* libticalcs - Ti Calculator library, a part of the TiLP project
5
* Copyright (C) 1999-2005 Romain Li�vin
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
*/
21
22
/*
23
This unit handles commands and session management thru DirectLink.
24
*/
25
26
#include <stdlib.h>
27
#include <string.h>
28
29
#include "ticalcs.h"
30
#include "logging.h"
31
#include "error.h"
32
#include "macros.h"
33
#include "pause.h"
34
35
#include "nsp_vpkt.h"
36
#include "nsp_cmd.h"
37
38
/////////////----------------
39
40
static uint8_t usb_errors[] = {
41
0x04, 0x0a, 0x0f, 0x10, 0x11, 0x14, 0x15,
42
};
43
44
static int err_code(uint8_t code)
45
{
46
int i;
47
48
for(i = 0; i < sizeof(usb_errors) / sizeof(uint16_t); i++)
49
if(usb_errors[i] == code)
50
return i+1;
51
52
ticalcs_warning("NSpire error code not found in list. Please report it at <tilp-devel@lists.sf.net>.");
53
54
return 0;
55
}
56
57
/////////////----------------
58
59
static int put_str(uint8_t *dst, const char *src)
60
{
61
int i, j;
62
63
for(i = 0; i < (int)strlen(src); i++)
64
dst[i] = src[i];
65
dst[i++] = '\0';
66
67
if(i < 9)
68
{
69
for(j = i; j < 9; j++)
70
dst[j] = '\0';
71
}
72
else
73
j = i;
74
75
return j;
76
}
77
78
/////////////----------------
79
80
int cmd_r_login(CalcHandle *h)
81
{
82
VirtualPacket* pkt = nsp_vtl_pkt_new();
83
84
ticalcs_info(" receiving login:");
85
86
TRYF(nsp_recv_data(h, pkt));
87
88
nsp_vtl_pkt_del(pkt);
89
return 0;
90
}
91
92
/////////////----------------
93
94
int cmd_s_status(CalcHandle *h, uint8_t status)
95
{
96
VirtualPacket* pkt;
97
98
ticalcs_info(" sending status (%04x):", status);
99
100
pkt = nsp_vtl_pkt_new_ex(1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, nsp_dst_port);
101
pkt->cmd = CMD_STATUS;
102
pkt->data[0] = status;
103
TRYF(nsp_send_data(h, pkt));
104
105
nsp_vtl_pkt_del(pkt);
106
107
return 0;
108
}
109
110
int cmd_r_status(CalcHandle *h, uint8_t *status)
111
{
112
VirtualPacket* pkt = nsp_vtl_pkt_new();
113
uint8_t value;
114
115
ticalcs_info(" receiving status:");
116
117
TRYF(nsp_recv_data(h, pkt));
118
value = pkt->data[0];
119
120
if(pkt->cmd != CMD_STATUS)
121
return ERR_INVALID_PACKET;
122
123
if(status)
124
*status = value;
125
126
if(value != 0x00)
127
return ERR_CALC_ERROR3 + err_code(value);
128
129
nsp_vtl_pkt_del(pkt);
130
return 0;
131
}
132
133
/////////////----------------
134
135
int cmd_s_dev_infos(CalcHandle *h, uint8_t cmd)
136
{
137
VirtualPacket* pkt;
138
139
ticalcs_info(" requesting device information (cmd = %02x):", cmd);
140
141
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_DEV_INFOS);
142
pkt->cmd = cmd;
143
TRYF(nsp_send_data(h, pkt));
144
145
nsp_vtl_pkt_del(pkt);
146
return 0;
147
}
148
149
int cmd_r_dev_infos(CalcHandle *h, uint8_t *cmd, uint32_t *size, uint8_t **data)
150
{
151
VirtualPacket* pkt = nsp_vtl_pkt_new();
152
153
ticalcs_info(" receiving device information:");
154
155
TRYF(nsp_recv_data(h, pkt));
156
157
*cmd = pkt->cmd;
158
*data = g_malloc0(pkt->size);
159
memcpy(*data, pkt->data, pkt->size);
160
161
nsp_vtl_pkt_del(pkt);
162
return 0;
163
}
164
165
/////////////----------------
166
167
int cmd_s_screen_rle(CalcHandle *h, uint8_t cmd)
168
{
169
VirtualPacket* pkt;
170
171
ticalcs_info(" requesting RLE screenshot (cmd = %02x):", cmd);
172
173
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_SCREEN_RLE);
174
pkt->cmd = cmd;
175
TRYF(nsp_send_data(h, pkt));
176
177
nsp_vtl_pkt_del(pkt);
178
return 0;
179
}
180
181
int cmd_r_screen_rle(CalcHandle *h, uint8_t *cmd, uint32_t *size, uint8_t **data)
182
{
183
VirtualPacket* pkt = nsp_vtl_pkt_new();
184
185
ticalcs_info(" receiving RLE screenshot:");
186
187
pkt->size = *size;
188
TRYF(nsp_recv_data(h, pkt));
189
190
*cmd = pkt->cmd;
191
*size = pkt->size;
192
*data = g_malloc0(pkt->size);
193
memcpy(*data, pkt->data, pkt->size);
194
195
nsp_vtl_pkt_del(pkt);
196
return 0;
197
}
198
199
/////////////----------------
200
201
int cmd_s_dir_attributes(CalcHandle *h, const char *name)
202
{
203
VirtualPacket* pkt;
204
uint8_t len = strlen(name) < 8 ? 8 : strlen(name);
205
206
ticalcs_info(" unknown directory list command in <%s>:", name);
207
208
pkt = nsp_vtl_pkt_new_ex(1 + len + 1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
209
pkt->cmd = CMD_FM_UNKWOWN;
210
211
pkt->data[0] = 0x01;
212
put_str(pkt->data + 1, name);
213
214
TRYF(nsp_send_data(h, pkt));
215
216
nsp_vtl_pkt_del(pkt);
217
return 0;
218
}
219
220
int cmd_r_dir_attributes(CalcHandle *h, uint32_t *size, uint8_t *type, uint32_t *date)
221
{
222
VirtualPacket* pkt = nsp_vtl_pkt_new();
223
224
ticalcs_info(" unknown directory list command reply received:");
225
226
TRYF(nsp_recv_data(h, pkt));
227
228
if(pkt->cmd != CMD_FM_UNKWOWN)
229
return ERR_CALC_ERROR3 + err_code(pkt->data[0]);
230
231
if(size)
232
*size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 0)));
233
if(date)
234
*date = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 4)));
235
if(type)
236
*type = *(pkt->data + 8);
237
238
nsp_vtl_pkt_del(pkt);
239
return 0;
240
}
241
242
int cmd_s_dir_enum_init(CalcHandle *h, const char *name)
243
{
244
VirtualPacket* pkt;
245
uint8_t len = strlen(name) < 8 ? 8 : strlen(name);
246
247
ticalcs_info(" initiating directory listing in <%s>:", name);
248
249
pkt = nsp_vtl_pkt_new_ex(len + 1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
250
pkt->cmd = CMD_FM_DIRLIST_INIT;
251
put_str(pkt->data, name);
252
253
TRYF(nsp_send_data(h, pkt));
254
255
nsp_vtl_pkt_del(pkt);
256
return 0;
257
}
258
259
int cmd_r_dir_enum_init(CalcHandle *h)
260
{
261
return cmd_r_status(h, NULL);
262
}
263
264
int cmd_s_dir_enum_next(CalcHandle *h)
265
{
266
VirtualPacket* pkt;
267
268
ticalcs_info(" requesting next directory entry:");
269
270
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
271
pkt->cmd = CMD_FM_DIRLIST_NEXT;
272
273
TRYF(nsp_send_data(h, pkt));
274
275
nsp_vtl_pkt_del(pkt);
276
return 0;
277
}
278
279
int cmd_r_dir_enum_next(CalcHandle *h, char* name, uint32_t *size, uint8_t *type)
280
{
281
VirtualPacket* pkt = nsp_vtl_pkt_new();
282
uint8_t data_size;
283
uint32_t date;
284
int o;
285
286
ticalcs_info(" next directory entry:");
287
288
TRYF(nsp_recv_data(h, pkt));
289
290
if(pkt->cmd != CMD_FM_DIRLIST_ENT)
291
{
292
if(pkt->data[0] == ERR_NO_MORE_TO_LIST)
293
{
294
nsp_vtl_pkt_del(pkt);
295
return ERR_EOT;
296
}
297
else
298
return ERR_CALC_ERROR3 + err_code(pkt->data[0]);
299
}
300
301
data_size = pkt->data[1] + 2;
302
strcpy(name, (char *)pkt->data + 2);
303
o = data_size - 10;
304
305
if(size)
306
*size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + o)));
307
date = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + o + 4)));
308
if(type)
309
*type = pkt->data[o + 8];
310
311
nsp_vtl_pkt_del(pkt);
312
return 0;
313
}
314
315
int cmd_s_dir_enum_done(CalcHandle *h)
316
{
317
VirtualPacket* pkt;
318
319
ticalcs_info(" closing directory listing:");
320
321
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
322
pkt->cmd = CMD_FM_DIRLIST_DONE;
323
324
TRYF(nsp_send_data(h, pkt));
325
326
nsp_vtl_pkt_del(pkt);
327
return 0;
328
}
329
330
int cmd_r_dir_enum_done(CalcHandle *h)
331
{
332
return cmd_r_status(h, NULL);
333
}
334
335
/////////////----------------
336
337
int cmd_s_put_file(CalcHandle *h, const char *name, uint32_t size)
338
{
339
VirtualPacket* pkt;
340
int o;
341
342
ticalcs_info(" sending variable:");
343
344
pkt = nsp_vtl_pkt_new_ex(6 + strlen(name), NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
345
pkt->cmd = CMD_FM_PUT_FILE;
346
pkt->data[0] = 0x01;
347
o = put_str(pkt->data + 1, name);
348
o++;
349
350
pkt->data[o+0] = MSB(MSW(size));
351
pkt->data[o+1] = LSB(MSW(size));
352
pkt->data[o+2] = MSB(LSW(size));
353
pkt->data[o+3] = LSB(LSW(size));
354
355
TRYF(nsp_send_data(h, pkt));
356
357
nsp_vtl_pkt_del(pkt);
358
return 0;
359
}
360
361
int cmd_r_put_file(CalcHandle *h)
362
{
363
return cmd_r_file_ok(h);
364
}
365
366
int cmd_s_get_file(CalcHandle *h, const char *name)
367
{
368
VirtualPacket* pkt;
369
370
ticalcs_info(" requesting variable:");
371
372
pkt = nsp_vtl_pkt_new_ex(2 + strlen(name), NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
373
pkt->cmd = CMD_FM_GET_FILE;
374
pkt->data[0] = 0x01;
375
put_str(pkt->data + 1, name);
376
377
TRYF(nsp_send_data(h, pkt));
378
379
nsp_vtl_pkt_del(pkt);
380
return 0;
381
}
382
383
int cmd_r_get_file(CalcHandle *h, uint32_t *size)
384
{
385
VirtualPacket* pkt = nsp_vtl_pkt_new();
386
387
ticalcs_info(" file size:");
388
389
TRYF(nsp_recv_data(h, pkt));
390
391
if(pkt->cmd != CMD_FM_PUT_FILE)
392
{
393
nsp_vtl_pkt_del(pkt);
394
return ERR_INVALID_PACKET;
395
}
396
397
if(size)
398
*size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 10)));
399
400
nsp_vtl_pkt_del(pkt);
401
return 0;
402
}
403
404
int cmd_s_file_ok(CalcHandle *h)
405
{
406
VirtualPacket* pkt;
407
408
ticalcs_info(" sending file contents:");
409
410
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
411
pkt->cmd = CMD_FM_OK;
412
TRYF(nsp_send_data(h, pkt));
413
414
nsp_vtl_pkt_del(pkt);
415
return 0;
416
}
417
418
int cmd_r_file_ok(CalcHandle *h)
419
{
420
VirtualPacket* pkt = nsp_vtl_pkt_new();
421
422
ticalcs_info(" file status:");
423
424
TRYF(nsp_recv_data(h, pkt));
425
426
if(pkt->cmd != CMD_FM_OK)
427
{
428
if(pkt->cmd == CMD_STATUS)
429
{
430
uint8_t value = pkt->data[0];
431
432
nsp_vtl_pkt_del(pkt);
433
return ERR_CALC_ERROR3 + err_code(value);
434
}
435
else
436
{
437
nsp_vtl_pkt_del(pkt);
438
return ERR_INVALID_PACKET;
439
}
440
}
441
else
442
ticalcs_info(" ok");
443
444
return 0;
445
}
446
447
int cmd_s_file_contents(CalcHandle *h, uint32_t size, uint8_t *data)
448
{
449
VirtualPacket* pkt;
450
451
ticalcs_info(" sending file contents:");
452
453
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_FILE_MGMT);
454
pkt->cmd = CMD_FM_CONTENTS;
455
memcpy(pkt->data, data, size);
456
TRYF(nsp_send_data(h, pkt));
457
458
nsp_vtl_pkt_del(pkt);
459
return 0;
460
}
461
462
int cmd_r_file_contents(CalcHandle *h, uint32_t *size, uint8_t **data)
463
{
464
VirtualPacket* pkt = nsp_vtl_pkt_new();
465
466
ticalcs_info(" receiving file contents:");
467
468
pkt->size = *size;
469
TRYF(nsp_recv_data(h, pkt));
470
471
*size = pkt->size;
472
*data = g_malloc0(pkt->size);
473
memcpy(*data, pkt->data, pkt->size);
474
475
nsp_vtl_pkt_del(pkt);
476
return 0;
477
}
478
479
/////////////----------------
480
481
int cmd_s_os_install(CalcHandle *h, uint32_t size)
482
{
483
VirtualPacket* pkt;
484
485
ticalcs_info(" installing OS:");
486
487
pkt = nsp_vtl_pkt_new_ex(4, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_OS_INSTALL);
488
pkt->cmd = CMD_OS_INSTALL;
489
pkt->data[0] = MSB(MSW(size));
490
pkt->data[1] = LSB(MSW(size));
491
pkt->data[2] = MSB(LSW(size));
492
pkt->data[3] = LSB(LSW(size));
493
TRYF(nsp_send_data(h, pkt));
494
495
nsp_vtl_pkt_del(pkt);
496
return 0;
497
}
498
499
int cmd_r_os_install(CalcHandle *h)
500
{
501
VirtualPacket* pkt = nsp_vtl_pkt_new();
502
503
ticalcs_info(" receiving OS installation:");
504
505
TRYF(nsp_recv_data(h, pkt));
506
507
if(pkt->cmd != CMD_OS_OK)
508
return ERR_INVALID_PACKET;
509
510
nsp_vtl_pkt_del(pkt);
511
return 0;
512
}
513
514
int cmd_s_os_contents(CalcHandle *h, uint32_t size, uint8_t *data)
515
516
{
517
VirtualPacket* pkt;
518
519
ticalcs_info(" sending OS contents:");
520
521
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_OS_INSTALL);
522
pkt->cmd = CMD_OS_CONTENTS;
523
memcpy(pkt->data, data, size);
524
TRYF(nsp_send_data(h, pkt));
525
526
nsp_vtl_pkt_del(pkt);
527
return 0;
528
}
529
530
int cmd_r_progress(CalcHandle *h, uint8_t *value)
531
{
532
VirtualPacket* pkt = nsp_vtl_pkt_new();
533
534
ticalcs_info(" OS installation status:");
535
536
TRYF(nsp_recv_data(h, pkt));
537
*value = pkt->data[0];
538
539
switch(pkt->cmd)
540
{
541
case CMD_OS_PROGRESS:
542
ticalcs_info(" %i/100", *value);
543
break;
544
case CMD_STATUS:
545
nsp_vtl_pkt_del(pkt);
546
return ERR_CALC_ERROR3 + err_code(*value);
547
default:
548
nsp_vtl_pkt_del(pkt);
549
return ERR_INVALID_PACKET;
550
}
551
552
return 0;
553
}
554
555
/////////////----------------
556
557
int cmd_s_echo(CalcHandle *h, uint32_t size, uint8_t *data)
558
{
559
VirtualPacket* pkt;
560
561
ticalcs_info(" sending echo:");
562
563
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, PORT_ECHO);
564
pkt->cmd = 0;
565
if(data) memcpy(pkt->data, data, size);
566
TRYF(nsp_send_data(h, pkt));
567
568
nsp_vtl_pkt_del(pkt);
569
return 0;
570
}
571
572
int cmd_r_echo(CalcHandle *h, uint32_t *size, uint8_t **data)
573
{
574
VirtualPacket* pkt = nsp_vtl_pkt_new();
575
576
ticalcs_info(" receiving echo:");
577
578
TRYF(nsp_recv_data(h, pkt));
579
if(size) *size = pkt->size;
580
if(data) *data = g_malloc0(pkt->size);
581
if(size && data) memcpy(*data, pkt->data, pkt->size);
582
583
nsp_vtl_pkt_del(pkt);
584
return 0;
585
}
1
/* Hey EMACS -*- linux-c -*- */
2
/* $Id: nsp_cmd.c 2077 2006-03-31 21:16:19Z roms $ */
3
4
/* libticalcs - Ti Calculator library, a part of the TiLP project
5
* Copyright (C) 1999-2005 Romain Li�vin
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software Foundation,
19
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
*/
21
22
/*
23
This unit handles commands and session management thru DirectLink.
24
*/
25
26
#include <stdlib.h>
27
#include <string.h>
28
29
#include "ticalcs.h"
30
#include "internal.h"
31
#include "logging.h"
32
#include "error.h"
33
#include "macros.h"
34
#include "pause.h"
35
36
#include "nsp_vpkt.h"
37
#include "nsp_cmd.h"
38
39
/////////////----------------
40
41
static const uint8_t usb_errors[] = {
42
0x02, 0x04, 0x07, 0x0a, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x20, 0x80
43
};
44
45
static int err_code(uint8_t code)
46
{
47
int i;
48
49
for(i = 0; i < (int)(sizeof(usb_errors) / sizeof(usb_errors[0])); i++)
50
if(usb_errors[i] == code)
51
return i+1;
52
53
ticalcs_warning("Nspire error code 0x%02x not found in list. Please report it at <tilp-devel@lists.sf.net>.", (int)code);
54
55
return 0;
56
}
57
58
/////////////----------------
59
60
static int put_str(uint8_t *dst, const char *src)
61
{
62
size_t i, j;
63
size_t len = strlen(src);
64
65
for(i = 0; i < len; i++)
66
{
67
dst[i] = src[i];
68
}
69
dst[i++] = '\0';
70
71
if(i < 9)
72
{
73
for(j = i; j < 9; j++)
74
dst[j] = '\0';
75
}
76
else
77
{
78
j = i;
79
}
80
81
return j;
82
}
83
84
/////////////----------------
85
86
TIEXPORT3 int TICALL nsp_cmd_r_login(CalcHandle *h)
87
{
88
NSPVirtualPacket* pkt;
89
int retval = 0;
90
91
if (h == NULL)
92
{
93
ticalcs_critical("%s: h is NULL", __FUNCTION__);
94
return ERR_INVALID_HANDLE;
95
}
96
97
pkt = nsp_vtl_pkt_new();
98
99
ticalcs_info(" receiving login:");
100
101
retval = nsp_recv_data(h, pkt);
102
103
nsp_vtl_pkt_del(pkt);
104
105
return retval;
106
}
107
108
/////////////----------------
109
110
TIEXPORT3 int TICALL nsp_cmd_s_status(CalcHandle *h, uint8_t status)
111
{
112
NSPVirtualPacket* pkt;
113
int retval = 0;
114
115
if (h == NULL)
116
{
117
ticalcs_critical("%s: h is NULL", __FUNCTION__);
118
return ERR_INVALID_HANDLE;
119
}
120
121
pkt = nsp_vtl_pkt_new_ex(1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, nsp_dst_port);
122
123
ticalcs_info(" sending status (%04x):", status);
124
125
pkt->cmd = CMD_STATUS;
126
pkt->data[0] = status;
127
retval = nsp_send_data(h, pkt);
128
129
nsp_vtl_pkt_del(pkt);
130
131
return retval;
132
}
133
134
TIEXPORT3 int TICALL nsp_cmd_r_status(CalcHandle *h, uint8_t *status)
135
{
136
NSPVirtualPacket* pkt;
137
uint8_t value;
138
int retval = 0;
139
140
if (h == NULL)
141
{
142
ticalcs_critical("%s: h is NULL", __FUNCTION__);
143
return ERR_INVALID_HANDLE;
144
}
145
146
pkt = nsp_vtl_pkt_new();
147
148
ticalcs_info(" receiving status:");
149
150
retval = nsp_recv_data(h, pkt);
151
if (!retval)
152
{
153
value = pkt->data[0];
154
155
if (pkt->cmd != CMD_STATUS)
156
{
157
retval = ERR_INVALID_PACKET;
158
goto end;
159
}
160
161
if (status)
162
{
163
*status = value;
164
}
165
166
if (value != 0x00)
167
{
168
retval = ERR_CALC_ERROR3 + err_code(value);
169
}
170
}
171
172
end:
173
nsp_vtl_pkt_del(pkt);
174
175
return retval;
176
}
177
178
/////////////----------------
179
180
TIEXPORT3 int TICALL nsp_cmd_s_dev_infos(CalcHandle *h, uint8_t cmd)
181
{
182
NSPVirtualPacket* pkt;
183
int retval = 0;
184
185
if (h == NULL)
186
{
187
ticalcs_critical("%s: h is NULL", __FUNCTION__);
188
return ERR_INVALID_HANDLE;
189
}
190
191
ticalcs_info(" requesting device information (cmd = %02x):", cmd);
192
193
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_DEV_INFOS);
194
195
pkt->cmd = cmd;
196
retval = nsp_send_data(h, pkt);
197
198
nsp_vtl_pkt_del(pkt);
199
200
return retval;
201
}
202
203
TIEXPORT3 int TICALL nsp_cmd_r_dev_infos(CalcHandle *h, uint8_t *cmd, uint32_t *size, uint8_t **data)
204
{
205
NSPVirtualPacket* pkt;
206
int retval = 0;
207
208
if (h == NULL)
209
{
210
ticalcs_critical("%s: h is NULL", __FUNCTION__);
211
return ERR_INVALID_HANDLE;
212
}
213
214
if (cmd == NULL || size == NULL || data == NULL)
215
{
216
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
217
return ERR_INVALID_PARAMETER;
218
}
219
220
pkt = nsp_vtl_pkt_new();
221
222
ticalcs_info(" receiving device information:");
223
224
retval = nsp_recv_data(h, pkt);
225
if (!retval)
226
{
227
*cmd = pkt->cmd;
228
*data = g_malloc0(pkt->size); // aborts the program if it fails.
229
memcpy(*data, pkt->data, pkt->size);
230
}
231
232
nsp_vtl_pkt_del(pkt);
233
234
return retval;
235
}
236
237
/////////////----------------
238
239
TIEXPORT3 int TICALL nsp_cmd_s_screen_rle(CalcHandle *h, uint8_t cmd)
240
{
241
NSPVirtualPacket* pkt;
242
int retval = 0;
243
244
if (h == NULL)
245
{
246
ticalcs_critical("%s: h is NULL", __FUNCTION__);
247
return ERR_INVALID_HANDLE;
248
}
249
250
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_SCREEN_RLE);
251
252
ticalcs_info(" requesting RLE screenshot (cmd = %02x):", cmd);
253
254
pkt->cmd = cmd;
255
retval = nsp_send_data(h, pkt);
256
257
nsp_vtl_pkt_del(pkt);
258
259
return retval;
260
}
261
262
TIEXPORT3 int TICALL nsp_cmd_r_screen_rle(CalcHandle *h, uint8_t *cmd, uint32_t *size, uint8_t **data)
263
{
264
NSPVirtualPacket* pkt;
265
int retval = 0;
266
267
if (h == NULL)
268
{
269
ticalcs_critical("%s: h is NULL", __FUNCTION__);
270
return ERR_INVALID_HANDLE;
271
}
272
if (cmd == NULL || size == NULL || data == NULL)
273
{
274
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
275
return ERR_INVALID_PARAMETER;
276
}
277
278
pkt = nsp_vtl_pkt_new();
279
280
ticalcs_info(" receiving RLE screenshot:");
281
282
pkt->size = *size;
283
retval = nsp_recv_data(h, pkt);
284
if (!retval)
285
{
286
*cmd = pkt->cmd;
287
*size = pkt->size;
288
*data = g_malloc0(pkt->size); // aborts the program if it fails.
289
memcpy(*data, pkt->data, pkt->size);
290
}
291
292
nsp_vtl_pkt_del(pkt);
293
294
return retval;
295
}
296
297
/////////////----------------
298
299
TIEXPORT3 int TICALL nsp_cmd_s_dir_attributes(CalcHandle *h, const char *name)
300
{
301
NSPVirtualPacket* pkt;
302
size_t len;
303
int retval = 0;
304
305
if (h == NULL)
306
{
307
ticalcs_critical("%s: h is NULL", __FUNCTION__);
308
return ERR_INVALID_HANDLE;
309
}
310
if (name == NULL)
311
{
312
ticalcs_critical("%s: name is NULL", __FUNCTION__);
313
return ERR_INVALID_PARAMETER;
314
}
315
316
len = strlen(name) < 8 ? 8 : strlen(name);
317
pkt = nsp_vtl_pkt_new_ex(1 + len + 1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
318
319
ticalcs_info(" unknown directory list command in <%s>:", name);
320
321
pkt->cmd = CMD_FM_ATTRIBUTES;
322
323
pkt->data[0] = 0x01;
324
put_str(pkt->data + 1, name);
325
326
retval = nsp_send_data(h, pkt);
327
328
nsp_vtl_pkt_del(pkt);
329
330
return retval;
331
}
332
333
TIEXPORT3 int TICALL nsp_cmd_r_dir_attributes(CalcHandle *h, uint32_t *size, uint8_t *type, uint32_t *date)
334
{
335
NSPVirtualPacket* pkt;
336
int retval = 0;
337
338
if (h == NULL)
339
{
340
ticalcs_critical("%s: h is NULL", __FUNCTION__);
341
return ERR_INVALID_HANDLE;
342
}
343
344
pkt = nsp_vtl_pkt_new();
345
346
ticalcs_info(" unknown directory list command reply received:");
347
348
retval = nsp_recv_data(h, pkt);
349
if (!retval)
350
{
351
if(pkt->cmd != CMD_FM_ATTRIBUTES)
352
{
353
retval = ERR_CALC_ERROR3 + err_code(pkt->data[0]);
354
goto end;
355
}
356
357
if(size)
358
{
359
//*size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 0)));
360
*size = ( (((uint32_t)pkt->data[0]) << 24)
361
| (((uint32_t)pkt->data[1]) << 16)
362
| (((uint32_t)pkt->data[2]) << 8)
363
| (((uint32_t)pkt->data[3]) ));
364
}
365
if(date)
366
{
367
//*date = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 4)));
368
*date = ( (((uint32_t)pkt->data[4]) << 24)
369
| (((uint32_t)pkt->data[5]) << 16)
370
| (((uint32_t)pkt->data[6]) << 8)
371
| (((uint32_t)pkt->data[7]) ));
372
}
373
if(type)
374
{
375
*type = *(pkt->data + 8);
376
}
377
}
378
379
end:
380
nsp_vtl_pkt_del(pkt);
381
382
return retval;
383
}
384
385
TIEXPORT3 int TICALL nsp_cmd_s_dir_enum_init(CalcHandle *h, const char *name)
386
{
387
NSPVirtualPacket* pkt;
388
size_t len;
389
int retval = 0;
390
391
if (h == NULL)
392
{
393
ticalcs_critical("%s: h is NULL", __FUNCTION__);
394
return ERR_INVALID_HANDLE;
395
}
396
if (name == NULL)
397
{
398
ticalcs_critical("%s: name is NULL", __FUNCTION__);
399
return ERR_INVALID_PARAMETER;
400
}
401
402
len = strlen(name) < 8 ? 8 : strlen(name);
403
404
pkt = nsp_vtl_pkt_new_ex(len + 1, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
405
406
ticalcs_info(" initiating directory listing in <%s>:", name);
407
408
pkt->cmd = CMD_FM_DIRLIST_INIT;
409
put_str(pkt->data, name);
410
411
retval = nsp_send_data(h, pkt);
412
413
nsp_vtl_pkt_del(pkt);
414
415
return retval;
416
}
417
418
TIEXPORT3 int TICALL nsp_cmd_r_dir_enum_init(CalcHandle *h)
419
{
420
return nsp_cmd_r_status(h, NULL);
421
}
422
423
TIEXPORT3 int TICALL nsp_cmd_s_dir_enum_next(CalcHandle *h)
424
{
425
NSPVirtualPacket* pkt;
426
int retval = 0;
427
428
if (h == NULL)
429
{
430
ticalcs_critical("%s: h is NULL", __FUNCTION__);
431
return ERR_INVALID_HANDLE;
432
}
433
434
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
435
if (pkt != NULL)
436
{
437
ticalcs_info(" requesting next directory entry:");
438
439
pkt->cmd = CMD_FM_DIRLIST_NEXT;
440
441
retval = nsp_send_data(h, pkt);
442
443
nsp_vtl_pkt_del(pkt);
444
}
445
else
446
{
447
retval = ERR_MALLOC;
448
}
449
450
return retval;
451
}
452
453
TIEXPORT3 int TICALL nsp_cmd_r_dir_enum_next(CalcHandle *h, char* name, uint32_t *size, uint8_t *type)
454
{
455
NSPVirtualPacket* pkt;
456
uint8_t data_size;
457
//uint32_t date;
458
int o;
459
int retval = 0;
460
461
if (h == NULL)
462
{
463
ticalcs_critical("%s: h is NULL", __FUNCTION__);
464
return ERR_INVALID_HANDLE;
465
}
466
if (name == NULL)
467
{
468
ticalcs_critical("%s: name is NULL", __FUNCTION__);
469
return ERR_INVALID_PARAMETER;
470
}
471
472
pkt = nsp_vtl_pkt_new();
473
474
ticalcs_info(" next directory entry:");
475
476
retval = nsp_recv_data(h, pkt);
477
if (!retval)
478
{
479
if(pkt->cmd != CMD_FM_DIRLIST_ENT)
480
{
481
if(pkt->data[0] == ERR_NO_MORE_TO_LIST)
482
{
483
retval = ERR_EOT;
484
goto end;
485
}
486
else
487
{
488
retval = ERR_CALC_ERROR3 + err_code(pkt->data[0]);
489
goto end;
490
}
491
}
492
493
data_size = pkt->data[1] + 2;
494
strcpy(name, (char *)pkt->data + 2);
495
o = data_size - 10;
496
497
if(size)
498
{
499
// *size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + o)));
500
*size = ( (((uint32_t)pkt->data[o ]) << 24)
501
| (((uint32_t)pkt->data[o + 1]) << 16)
502
| (((uint32_t)pkt->data[o + 2]) << 8)
503
| (((uint32_t)pkt->data[o + 3]) ));
504
}
505
//date = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + o + 4)));
506
if(type)
507
{
508
*type = pkt->data[o + 8];
509
}
510
}
511
512
end:
513
nsp_vtl_pkt_del(pkt);
514
515
return retval;
516
}
517
518
TIEXPORT3 int TICALL nsp_cmd_s_dir_enum_done(CalcHandle *h)
519
{
520
NSPVirtualPacket* pkt;
521
int retval = 0;
522
523
if (h == NULL)
524
{
525
ticalcs_critical("%s: h is NULL", __FUNCTION__);
526
return ERR_INVALID_HANDLE;
527
}
528
529
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
530
531
ticalcs_info(" closing directory listing:");
532
533
pkt->cmd = CMD_FM_DIRLIST_DONE;
534
535
retval = nsp_send_data(h, pkt);
536
537
nsp_vtl_pkt_del(pkt);
538
539
return retval;
540
}
541
542
TIEXPORT3 int TICALL nsp_cmd_r_dir_enum_done(CalcHandle *h)
543
{
544
return nsp_cmd_r_status(h, NULL);
545
}
546
547
/////////////----------------
548
549
TIEXPORT3 int TICALL nsp_cmd_s_put_file(CalcHandle *h, const char *name, uint32_t size)
550
{
551
NSPVirtualPacket* pkt;
552
int o;
553
size_t len;
554
int retval = 0;
555
556
if (h == NULL)
557
{
558
ticalcs_critical("%s: h is NULL", __FUNCTION__);
559
return ERR_INVALID_HANDLE;
560
}
561
if (name == NULL)
562
{
563
ticalcs_critical("%s: name is NULL", __FUNCTION__);
564
return ERR_INVALID_PARAMETER;
565
}
566
567
len = strlen(name) < 8 ? 8 : strlen(name);
568
pkt = nsp_vtl_pkt_new_ex(6 + len, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
569
570
ticalcs_info(" sending variable:");
571
572
pkt->cmd = CMD_FM_PUT_FILE;
573
pkt->data[0] = 0x01;
574
o = put_str(pkt->data + 1, name);
575
o++;
576
577
pkt->data[o+0] = MSB(MSW(size));
578
pkt->data[o+1] = LSB(MSW(size));
579
pkt->data[o+2] = MSB(LSW(size));
580
pkt->data[o+3] = LSB(LSW(size));
581
582
retval = nsp_send_data(h, pkt);
583
584
nsp_vtl_pkt_del(pkt);
585
586
return retval;
587
}
588
589
TIEXPORT3 int TICALL nsp_cmd_r_put_file(CalcHandle *h)
590
{
591
return nsp_cmd_r_file_ok(h);
592
}
593
594
TIEXPORT3 int TICALL nsp_cmd_s_put_file_eot(CalcHandle *h)
595
{
596
NSPVirtualPacket* pkt;
597
int retval = 0;
598
599
if (h == NULL)
600
{
601
ticalcs_critical("%s: h is NULL", __FUNCTION__);
602
return ERR_INVALID_HANDLE;
603
}
604
605
pkt = nsp_vtl_pkt_new_ex(2, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
606
607
ticalcs_info(" sending EOT:");
608
609
pkt->cmd = CMD_FM_PUT_FILE_EOT;
610
pkt->data[0] = 0x01;
611
612
retval = nsp_send_data(h, pkt);
613
614
nsp_vtl_pkt_del(pkt);
615
616
return retval;
617
}
618
619
// No nsp_cmd_r_put_file_eot because the calculator doesn't seem to reply to CMD_FM_PUT_FILE_EOT.
620
621
TIEXPORT3 int TICALL nsp_cmd_s_get_file(CalcHandle *h, const char *name)
622
{
623
NSPVirtualPacket* pkt;
624
size_t len;
625
int retval = 0;
626
627
if (h == NULL)
628
{
629
ticalcs_critical("%s: h is NULL", __FUNCTION__);
630
return ERR_INVALID_HANDLE;
631
}
632
if (name == NULL)
633
{
634
ticalcs_critical("%s: name is NULL", __FUNCTION__);
635
return ERR_INVALID_PARAMETER;
636
}
637
638
len = strlen(name) < 8 ? 8 : strlen(name);
639
640
ticalcs_info(" requesting variable:");
641
642
pkt = nsp_vtl_pkt_new_ex(2 + len, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
643
pkt->cmd = CMD_FM_GET_FILE;
644
pkt->data[0] = 0x01;
645
put_str(pkt->data + 1, name);
646
647
retval = nsp_send_data(h, pkt);
648
649
nsp_vtl_pkt_del(pkt);
650
651
return retval;
652
}
653
654
TIEXPORT3 int TICALL nsp_cmd_r_get_file(CalcHandle *h, uint32_t *size)
655
{
656
NSPVirtualPacket* pkt;
657
int retval = 0;
658
659
if (h == NULL)
660
{
661
ticalcs_critical("%s: h is NULL", __FUNCTION__);
662
return ERR_INVALID_HANDLE;
663
}
664
665
pkt = nsp_vtl_pkt_new();
666
667
ticalcs_info(" file size:");
668
669
retval = nsp_recv_data(h, pkt);
670
671
if (!retval)
672
{
673
674
if(pkt->cmd != CMD_FM_PUT_FILE)
675
{
676
retval = ERR_INVALID_PACKET;
677
goto end;
678
}
679
680
if(size)
681
{
682
// *size = GUINT32_FROM_BE(*((uint32_t *)(pkt->data + 10)));
683
*size = ( (((uint32_t)pkt->data[10]) << 24)
684
| (((uint32_t)pkt->data[11]) << 16)
685
| (((uint32_t)pkt->data[12]) << 8)
686
| (((uint32_t)pkt->data[13]) ));
687
}
688
}
689
690
end:
691
nsp_vtl_pkt_del(pkt);
692
693
return retval;
694
}
695
696
TIEXPORT3 int TICALL nsp_cmd_s_del_file(CalcHandle *h, const char *name)
697
{
698
NSPVirtualPacket* pkt;
699
size_t len;
700
int retval = 0;
701
702
if (h == NULL)
703
{
704
ticalcs_critical("%s: h is NULL", __FUNCTION__);
705
return ERR_INVALID_HANDLE;
706
}
707
if (name == NULL)
708
{
709
ticalcs_critical("%s: name is NULL", __FUNCTION__);
710
return ERR_INVALID_PARAMETER;
711
}
712
713
len = strlen(name) < 8 ? 8 : strlen(name);
714
pkt = nsp_vtl_pkt_new_ex(2 + len, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
715
716
ticalcs_info(" deleting variable:");
717
718
pkt->cmd = CMD_FM_DEL_FILE;
719
pkt->data[0] = 0x01;
720
put_str(pkt->data + 1, name);
721
722
retval = nsp_send_data(h, pkt);
723
724
nsp_vtl_pkt_del(pkt);
725
726
return retval;
727
}
728
729
TIEXPORT3 int TICALL nsp_cmd_r_del_file(CalcHandle *h)
730
{
731
return nsp_cmd_r_status(h, NULL);
732
}
733
734
TIEXPORT3 int TICALL nsp_cmd_s_new_folder(CalcHandle *h, const char *name)
735
{
736
NSPVirtualPacket* pkt;
737
size_t len;
738
int retval = 0;
739
740
if (h == NULL)
741
{
742
ticalcs_critical("%s: h is NULL", __FUNCTION__);
743
return ERR_INVALID_HANDLE;
744
}
745
if (name == NULL)
746
{
747
ticalcs_critical("%s: name is NULL", __FUNCTION__);
748
return ERR_INVALID_PARAMETER;
749
}
750
751
len = strlen(name) < 8 ? 8 : strlen(name);
752
753
pkt = nsp_vtl_pkt_new_ex(2 + len, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
754
755
ticalcs_info(" creating folder:");
756
757
pkt->cmd = CMD_FM_NEW_FOLDER;
758
pkt->data[0] = 0x03;
759
put_str(pkt->data + 1, name);
760
761
retval = nsp_send_data(h, pkt);
762
763
nsp_vtl_pkt_del(pkt);
764
765
return retval;
766
}
767
768
TIEXPORT3 int TICALL nsp_cmd_r_new_folder(CalcHandle *h)
769
{
770
return nsp_cmd_r_status(h, NULL);
771
}
772
773
TIEXPORT3 int TICALL nsp_cmd_s_del_folder(CalcHandle *h, const char *name)
774
{
775
NSPVirtualPacket* pkt;
776
size_t len;
777
int retval = 0;
778
779
if (h == NULL)
780
{
781
ticalcs_critical("%s: h is NULL", __FUNCTION__);
782
return ERR_INVALID_HANDLE;
783
}
784
if (name == NULL)
785
{
786
ticalcs_critical("%s: name is NULL", __FUNCTION__);
787
return ERR_INVALID_PARAMETER;
788
}
789
790
len = strlen(name) < 8 ? 8 : strlen(name);
791
792
pkt = nsp_vtl_pkt_new_ex(2 + len, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
793
794
ticalcs_info(" deleting folder:");
795
796
pkt->cmd = CMD_FM_DEL_FOLDER;
797
pkt->data[0] = 0x03;
798
put_str(pkt->data + 1, name);
799
800
retval = nsp_send_data(h, pkt);
801
802
nsp_vtl_pkt_del(pkt);
803
804
return retval;
805
}
806
807
TIEXPORT3 int TICALL nsp_cmd_r_del_folder(CalcHandle *h)
808
{
809
return nsp_cmd_r_status(h, NULL);
810
}
811
812
TIEXPORT3 int TICALL nsp_cmd_s_copy_file(CalcHandle *h, const char *name, const char *name2)
813
{
814
NSPVirtualPacket* pkt;
815
size_t len;
816
size_t len2;
817
int retval = 0;
818
819
if (h == NULL)
820
{
821
ticalcs_critical("%s: h is NULL", __FUNCTION__);
822
return ERR_INVALID_HANDLE;
823
}
824
if (name == NULL || name2 == NULL)
825
{
826
ticalcs_critical("%s: a parameter is NULL", __FUNCTION__);
827
return ERR_INVALID_PARAMETER;
828
}
829
830
len = strlen(name) < 8 ? 8 : strlen(name);
831
len2 = strlen(name2) < 8 ? 8 : strlen(name2);
832
833
pkt = nsp_vtl_pkt_new_ex(3 + len + len2, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
834
835
ticalcs_info(" copying file:");
836
837
pkt->cmd = CMD_FM_COPY_FILE;
838
pkt->data[0] = 0x01;
839
put_str(pkt->data + 1, name);
840
put_str(pkt->data + 2 + len, name2);
841
842
retval = nsp_send_data(h, pkt);
843
844
nsp_vtl_pkt_del(pkt);
845
846
return retval;
847
}
848
849
TIEXPORT3 int TICALL nsp_cmd_r_copy_file(CalcHandle *h)
850
{
851
return nsp_cmd_r_status(h, NULL);
852
}
853
854
TIEXPORT3 int TICALL nsp_cmd_s_rename_file(CalcHandle *h, const char *name, const char *name2)
855
{
856
NSPVirtualPacket* pkt;
857
size_t len;
858
size_t len2;
859
int retval = 0;
860
861
if (h == NULL)
862
{
863
ticalcs_critical("%s: h is NULL", __FUNCTION__);
864
return ERR_INVALID_HANDLE;
865
}
866
if (name == NULL || name2 == NULL)
867
{
868
ticalcs_critical("%s: a parameter is NULL", __FUNCTION__);
869
return ERR_INVALID_PARAMETER;
870
}
871
872
len = strlen(name) < 8 ? 8 : strlen(name);
873
len2 = strlen(name2) < 8 ? 8 : strlen(name2);
874
875
ticalcs_info(" renaming file:");
876
877
pkt = nsp_vtl_pkt_new_ex(3 + len + len2, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
878
pkt->cmd = CMD_FM_RENAME_FILE;
879
pkt->data[0] = 0x01;
880
put_str(pkt->data + 1, name);
881
put_str(pkt->data + 2 + len, name2);
882
883
retval = nsp_send_data(h, pkt);
884
885
nsp_vtl_pkt_del(pkt);
886
887
return retval;
888
}
889
890
TIEXPORT3 int TICALL nsp_cmd_r_rename_file(CalcHandle *h)
891
{
892
return nsp_cmd_r_status(h, NULL);
893
}
894
895
TIEXPORT3 int TICALL nsp_cmd_s_file_ok(CalcHandle *h)
896
{
897
NSPVirtualPacket* pkt;
898
int retval = 0;
899
900
if (h == NULL)
901
{
902
ticalcs_critical("%s: h is NULL", __FUNCTION__);
903
return ERR_INVALID_HANDLE;
904
}
905
906
pkt = nsp_vtl_pkt_new_ex(0, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
907
908
ticalcs_info(" sending file contents:");
909
910
pkt->cmd = CMD_FM_OK;
911
912
retval = nsp_send_data(h, pkt);
913
914
nsp_vtl_pkt_del(pkt);
915
916
return retval;
917
}
918
919
TIEXPORT3 int TICALL nsp_cmd_r_file_ok(CalcHandle *h)
920
{
921
NSPVirtualPacket* pkt;
922
int retval = 0;
923
924
if (h == NULL)
925
{
926
ticalcs_critical("%s: h is NULL", __FUNCTION__);
927
return ERR_INVALID_HANDLE;
928
}
929
930
pkt = nsp_vtl_pkt_new();
931
932
ticalcs_info(" file status:");
933
934
retval = nsp_recv_data(h, pkt);
935
if (!retval)
936
{
937
if(pkt->cmd != CMD_FM_OK)
938
{
939
if(pkt->cmd == CMD_STATUS)
940
{
941
retval = ERR_CALC_ERROR3 + err_code(pkt->data[0]);
942
}
943
else
944
{
945
retval = ERR_INVALID_PACKET;
946
}
947
}
948
else
949
{
950
ticalcs_info(" ok");
951
}
952
}
953
954
nsp_vtl_pkt_del(pkt);
955
956
return retval;
957
}
958
959
TIEXPORT3 int TICALL nsp_cmd_s_file_contents(CalcHandle *h, uint32_t size, uint8_t *data)
960
{
961
NSPVirtualPacket* pkt;
962
int retval = 0;
963
964
if (h == NULL)
965
{
966
ticalcs_critical("%s: h is NULL", __FUNCTION__);
967
return ERR_INVALID_HANDLE;
968
}
969
if (data == NULL)
970
{
971
ticalcs_critical("%s: data is NULL", __FUNCTION__);
972
return ERR_INVALID_PARAMETER;
973
}
974
975
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_FILE_MGMT);
976
977
ticalcs_info(" sending file contents:");
978
979
pkt->cmd = CMD_FM_CONTENTS;
980
memcpy(pkt->data, data, size);
981
retval = nsp_send_data(h, pkt);
982
983
nsp_vtl_pkt_del(pkt);
984
985
return retval;
986
}
987
988
TIEXPORT3 int TICALL nsp_cmd_r_file_contents(CalcHandle *h, uint32_t *size, uint8_t **data)
989
{
990
NSPVirtualPacket* pkt;
991
int retval = 0;
992
993
if (h == NULL)
994
{
995
ticalcs_critical("%s: h is NULL", __FUNCTION__);
996
return ERR_INVALID_HANDLE;
997
}
998
if (size == NULL || data == NULL)
999
{
1000
ticalcs_critical("%s: an argument is NULL", __FUNCTION__);
1001
return ERR_INVALID_PARAMETER;
1002
}
1003
1004
pkt = nsp_vtl_pkt_new();
1005
1006
ticalcs_info(" receiving file contents:");
1007
1008
pkt->size = *size;
1009
retval = nsp_recv_data(h, pkt);
1010
1011
if (!retval)
1012
{
1013
*size = pkt->size;
1014
*data = g_malloc0(pkt->size);
1015
memcpy(*data, pkt->data, pkt->size);
1016
}
1017
1018
nsp_vtl_pkt_del(pkt);
1019
1020
return retval;
1021
}
1022
1023
/////////////----------------
1024
1025
TIEXPORT3 int TICALL nsp_cmd_s_os_install(CalcHandle *h, uint32_t size)
1026
{
1027
NSPVirtualPacket* pkt;
1028
int retval = 0;
1029
1030
if (h == NULL)
1031
{
1032
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1033
return ERR_INVALID_HANDLE;
1034
}
1035
1036
pkt = nsp_vtl_pkt_new_ex(4, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_OS_INSTALL);
1037
1038
ticalcs_info(" installing OS:");
1039
1040
pkt->cmd = CMD_OS_INSTALL;
1041
pkt->data[0] = MSB(MSW(size));
1042
pkt->data[1] = LSB(MSW(size));
1043
pkt->data[2] = MSB(LSW(size));
1044
pkt->data[3] = LSB(LSW(size));
1045
retval = nsp_send_data(h, pkt);
1046
1047
nsp_vtl_pkt_del(pkt);
1048
1049
return retval;
1050
}
1051
1052
TIEXPORT3 int TICALL nsp_cmd_r_os_install(CalcHandle *h)
1053
{
1054
NSPVirtualPacket* pkt;
1055
int retval = 0;
1056
1057
if (h == NULL)
1058
{
1059
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1060
return ERR_INVALID_HANDLE;
1061
}
1062
1063
pkt = nsp_vtl_pkt_new();
1064
1065
ticalcs_info(" receiving OS installation:");
1066
1067
retval = nsp_recv_data(h, pkt);
1068
1069
if (!retval)
1070
{
1071
if(pkt->cmd != CMD_OS_OK)
1072
{
1073
retval = ERR_INVALID_PACKET;
1074
}
1075
}
1076
1077
nsp_vtl_pkt_del(pkt);
1078
1079
return retval;
1080
}
1081
1082
TIEXPORT3 int TICALL nsp_cmd_s_os_contents(CalcHandle *h, uint32_t size, uint8_t *data)
1083
{
1084
NSPVirtualPacket* pkt;
1085
int retval = 0;
1086
1087
if (h == NULL)
1088
{
1089
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1090
return ERR_INVALID_HANDLE;
1091
}
1092
if (data == NULL)
1093
{
1094
ticalcs_critical("%s: data is NULL", __FUNCTION__);
1095
return ERR_INVALID_PARAMETER;
1096
}
1097
1098
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_OS_INSTALL);
1099
1100
ticalcs_info(" sending OS contents:");
1101
1102
pkt->cmd = CMD_OS_CONTENTS;
1103
memcpy(pkt->data, data, size);
1104
retval = nsp_send_data(h, pkt);
1105
1106
nsp_vtl_pkt_del(pkt);
1107
1108
return retval;
1109
}
1110
1111
TIEXPORT3 int TICALL nsp_cmd_r_progress(CalcHandle *h, uint8_t *value)
1112
{
1113
NSPVirtualPacket* pkt;
1114
int retval = 0;
1115
1116
if (h == NULL)
1117
{
1118
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1119
return ERR_INVALID_HANDLE;
1120
}
1121
if (value == NULL)
1122
{
1123
ticalcs_critical("%s: value is NULL", __FUNCTION__);
1124
return ERR_INVALID_PARAMETER;
1125
}
1126
1127
pkt = nsp_vtl_pkt_new();
1128
1129
ticalcs_info(" OS installation status:");
1130
1131
retval = nsp_recv_data(h, pkt);
1132
if (!retval)
1133
{
1134
*value = pkt->data[0];
1135
1136
switch(pkt->cmd)
1137
{
1138
case CMD_OS_PROGRESS:
1139
ticalcs_info(" %i/100", *value);
1140
break;
1141
case CMD_STATUS:
1142
nsp_vtl_pkt_del(pkt);
1143
retval = ERR_CALC_ERROR3 + err_code(*value);
1144
default:
1145
nsp_vtl_pkt_del(pkt);
1146
retval = ERR_INVALID_PACKET;
1147
}
1148
}
1149
1150
return retval;
1151
}
1152
1153
/////////////----------------
1154
1155
TIEXPORT3 int TICALL nsp_cmd_s_echo(CalcHandle *h, uint32_t size, uint8_t *data)
1156
{
1157
NSPVirtualPacket* pkt;
1158
int retval = 0;
1159
1160
if (h == NULL)
1161
{
1162
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1163
return ERR_INVALID_HANDLE;
1164
}
1165
1166
ticalcs_info(" sending echo:");
1167
1168
pkt = nsp_vtl_pkt_new_ex(size, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_ECHO);
1169
1170
pkt->cmd = 0;
1171
if(data)
1172
{
1173
memcpy(pkt->data, data, size);
1174
}
1175
retval = nsp_send_data(h, pkt);
1176
1177
nsp_vtl_pkt_del(pkt);
1178
1179
return retval;
1180
}
1181
1182
TIEXPORT3 int TICALL nsp_cmd_r_echo(CalcHandle *h, uint32_t *size, uint8_t **data)
1183
{
1184
NSPVirtualPacket* pkt;
1185
int retval = 0;
1186
1187
if (h == NULL)
1188
{
1189
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1190
return ERR_INVALID_HANDLE;
1191
}
1192
1193
pkt = nsp_vtl_pkt_new();
1194
1195
ticalcs_info(" receiving echo:");
1196
1197
retval = nsp_recv_data(h, pkt);
1198
if(size)
1199
{
1200
*size = pkt->size;
1201
}
1202
1203
if(data)
1204
{
1205
*data = g_malloc0(pkt->size);
1206
if(*data)
1207
{
1208
memcpy(*data, pkt->data, pkt->size);
1209
}
1210
else
1211
{
1212
retval = ERR_MALLOC;
1213
}
1214
}
1215
1216
nsp_vtl_pkt_del(pkt);
1217
1218
return retval;
1219
}
1220
1221
/////////////----------------
1222
1223
TIEXPORT3 int TICALL nsp_cmd_s_keypress_event(CalcHandle *h, const uint8_t keycode[3])
1224
{
1225
NSPVirtualPacket * pkt1, * pkt2;
1226
int retval = 0;
1227
1228
if (h == NULL)
1229
{
1230
ticalcs_critical("%s: h is NULL", __FUNCTION__);
1231
return ERR_INVALID_HANDLE;
1232
}
1233
if (keycode == NULL)
1234
{
1235
ticalcs_critical("%s: keycode is NULL", __FUNCTION__);
1236
return ERR_INVALID_PARAMETER;
1237
}
1238
1239
ticalcs_info(" sending keypress event:");
1240
1241
retval = nsp_session_open(h, SID_KEYPRESSES);
1242
if (!retval)
1243
{
1244
pkt1 = nsp_vtl_pkt_new_ex(3, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_KEYPRESSES);
1245
pkt2 = nsp_vtl_pkt_new_ex(25, NSP_SRC_ADDR, nsp_src_port, NSP_DEV_ADDR, NSP_PORT_KEYPRESSES);
1246
1247
pkt1->cmd = 0x01;
1248
pkt1->data[2] = 0x80;
1249
retval = nsp_send_data(h, pkt1);
1250
1251
if (!retval)
1252
{
1253
pkt2->cmd = 0;
1254
pkt2->data[3] = 0x08;
1255
pkt2->data[4] = 0x02;
1256
pkt2->data[5] = keycode[0];
1257
pkt2->data[7] = keycode[1];
1258
pkt2->data[23] = keycode[2];
1259
1260
retval = nsp_send_data(h, pkt2);
1261
}
1262
1263
nsp_vtl_pkt_del(pkt2);
1264
nsp_vtl_pkt_del(pkt1);
1265
1266
if (!retval)
1267
{
1268
retval = nsp_session_close(h);
1269
}
1270
}
1271
1272
return retval;
1273
}
1274
1275
// There doesn't seem to be a need for cmd_r_keypress_event.
Loggerhead is a web-based interface for Breezy
Version: 2.0.1