Debian Codegraph @

src/arq/arq.cxx

raw
1 // ----------------------------------------------------------------------------
2 // Copyright (C) 2014
3 // David Freese, W1HKJ
4 //
5 // This file is part of flmsg
6 //
7 // flmsg 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 3 of the License, or
10 // (at your option) any later version.
11 //
12 // flmsg 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, see <http://www.gnu.org/licenses/>.
19 // ----------------------------------------------------------------------------
20
21 #include <config.h>
22
23 #include <sys/time.h>
24
25 #include <iostream>
26 #include <sstream>
27 #include <cmath>
28
29 #include "arq.h"
30 #include "status.h"
31 #include "xml_io.h"
32 #include "flmsg_arq.h"
33 #include "gettext.h"
34
35 static pthread_t arq_thread;
36 static pthread_mutex_t arq_mutex = PTHREAD_MUTEX_INITIALIZER;
37 static arq *inst = NULL;
38
39 static bool first_rtry = true;
40
41 std::string arqstates[] = {
42 "ARQ_DOWN", "TIMEDOUT", "ABORT", "ARQ_CONNECTING", "ARQ_CONNECTED",
43 "WAITING", "WAITFORACK", "ARQ_DISCONNECT", "ARQ_DISCONNECTING",
44 "ABORTING", "STOPPED"};
45
46 std::string arq::upcase(std::string s)
47 {
48 for (size_t i = 0; i < s.length(); i++)
49 s[i] = toupper(s[i]);
50 return s;
51 }
52
53 arq::arq()
54 {
55 do_sendfnc = NULL;
56 do_getc1 = NULL;
57 do_rcvfnc = NULL;
58 do_printRX = NULL;
59 do_printTX = NULL;
60 do_printLOG = NULL;
61 do_printTALK = NULL;
62 do_abortfnc = NULL;
63 do_disconnectfnc = NULL;
64 do_rxUrCall = NULL;
65 do_qualityfnc = NULL;
66 do_printSTATUS = NULL;
67
68 UrCall.erase();
69 MyCall.erase();
70
71 // queues //
72 TxTextQueue.clear();
73 RxTextQueue.clear();
74
75 exponent = EXPONENT;
76
77 // static status
78
79 LinkState = ARQ_DOWN; // ARQ link is initially down
80 sender = false;
81
82 retries = getRetries();
83
84 loopcount = 0;
85 xfrsize = 0;
86 str_xfrsize = "";
87 lastblock = ' ';
88 timeout = -1;
89 retrytime = rtry();
90
91 arq_running = false;
92 arq_exit = false;
93 arqreset = false;
94
95 }
96
97 void arq::resetTx()
98 {
99 TxTextQueue.clear();
100 }
101
102 void arq::resetRx()
103 {
104 RxTextQueue.clear();
105 }
106
107 void arq::reset()
108 {
109 resetTx();
110 resetRx();
111 blknbr = 0;
112 timeout = -1;
113 LinkState = ARQ_DOWN;
114 sender = false;
115 disconnectfnc();
116 str_blknbr = "000";
117 retrytime = rtry();
118 }
119
120 // Checksum of std::string s
121 std::string arq::checksum(std::string &s)
122 {
123 framecrc.reset();
124 return framecrc.scrc16(s);
125 }
126
127 void arq::addToTxQue(std::string s)
128 {
129 if (s.empty()) return;
130 TxTextQueue.assign(s);
131 }
132
133 std::string arq::calls()
134 {
135 std::string s;
136 s.assign(MyCall);
137 s.append(ARQ_DLE);
138 s.append(UrCall);
139 s.append(ARQ_DLE);
140 return s;
141 }
142
143 // Connect
144 // e.g.: '~1cW1HKJ;KH6TY;12345;XXXX~4'
145 //
146 void arq::connectFrame()
147 {
148 reset();
149 std::string Frame;
150 Frame.append(ARQ_SOF);
151 Frame += CONREQ;
152 Frame.append(calls());
153 Frame.append(str_xfrsize);
154 Frame.append(ARQ_DLE);
155 Frame.append(checksum(Frame));
156
157 Frame.append(ARQ_EOF);
158
159 LinkState = ARQ_CONNECTING;
160 sender = true;
161
162 printLOG("send CONREQ", "");
163
164 addToTxQue(Frame);
165 lastblock = CONREQ;
166 }
167
168
169 // Connect acknowledge
170 // e.g: '~1CKH6TY;W1HKJ;XXXX~4'
171 //
172 void arq::conackFrame ()
173 {
174 reset();
175
176 if (progStatus.ID_off) {
177 set_fldigi_rxid(0);
178 set_fldigi_txid(0);
179 }
180
181 std::string Frame;
182 Frame.append(ARQ_SOF);
183 Frame += CONACK;
184
185 Frame.append(calls());
186
187 Frame.append(checksum(Frame));
188 Frame.append(ARQ_EOF);
189
190 printLOG("send CONACK", "");
191
192 addToTxQue(Frame);
193 lastblock = CONACK;
194 }
195
196 void arq::ackFrame()
197 {
198 std::string Frame;
199 Frame.append(ARQ_SOF);
200 Frame += ACK;
201
202 Frame.append(calls());
203 Frame.append(str_blknbr);
204
205 Frame.append(ARQ_DLE);
206
207 Frame.append(checksum(Frame));
208 Frame.append(ARQ_EOF);
209
210 printLOG("send ACK", "");
211
212 addToTxQue(Frame);
213 lastblock = ACK;
214 }
215
216 void arq::nakFrame()
217 {
218 std::string Frame;
219 Frame.append(ARQ_SOF);
220 Frame += NAK;
221
222 Frame.append(calls());
223 Frame.append(checksum(Frame));
224 Frame.append(ARQ_EOF);
225
226 printLOG("send NAK", "");
227
228 addToTxQue(Frame);
229 lastblock = NAK;
230 }
231
232 // Disconnect session
233
234 void arq::disconnectFrame()
235 {
236 std::string Frame;
237 Frame.append(ARQ_SOF);
238 Frame += DISREQ;
239
240 Frame.append(calls());
241 Frame.append(checksum(Frame));
242 Frame.append(ARQ_EOF);
243
244 printLOG("send DISCON", "");
245
246 addToTxQue(Frame);
247
248 lastblock = DISREQ;
249
250 sender = true;
251 }
252
253 void sked_reset(void *)
254 {
255 inst->exec_arqreset();
256 }
257
258 void arq::disackFrame()
259 {
260 std::string Frame;
261 Frame.append(ARQ_SOF);
262 Frame += DISACK;
263
264 Frame.append(calls());
265 Frame.append(checksum(Frame));
266 Frame.append(ARQ_EOF);
267
268 printLOG("send DISACK", "");
269
270 addToTxQue(Frame);
271
272 lastblock = DISACK;
273
274 }
275
276 // poll
277 void arq::pollFrame()
278 {
279 std::string Frame;
280 Frame.append(ARQ_SOF);
281 Frame += POLL;
282
283 Frame.append(calls());
284 Frame.append(checksum(Frame));
285 Frame.append(ARQ_EOF);
286
287 printLOG("send POLL", "");
288
289 addToTxQue(Frame);
290 lastblock = POLL;
291 }
292
293 // Text frame
294 static std::string lastframe;
295
296 void arq::dataFrame()
297 {
298 char msg[200] = "send DATA";
299 std::string Frame;
300 static char szbknbr[12];
301 payload = xmttext.substr(0, buffer_length);
302 last_buffer_length = buffer_length;
303
304 Frame.append(ARQ_SOF);
305 Frame += DATA;
306
307 Frame.append(calls());
308 blknbr++;
309 snprintf(szbknbr, sizeof(szbknbr), "%03d", blknbr);
310 str_blknbr = szbknbr;
311 Frame.append(szbknbr);
312 Frame.append(ARQ_DLE);
313 Frame.append(payload);
314
315 Frame.append(checksum(Frame));
316 Frame.append(ARQ_EOF);
317
318 if (xfrsize) {
319 qualityfnc( 1.0 * (xfrsize - xmttext.length()) / xfrsize);
320 snprintf(msg, sizeof(msg),"send DATA %0.1f %%", 100.0 * (xfrsize - xmttext.length()) / xfrsize);
321 }
322 printLOG(msg, "");
323
324 lastframe = Frame;
325 lastblock = DATA;
326
327 addToTxQue(Frame);
328 }
329
330 //=====================================================================
331
332 bool arq::rightCALLS()
333 {
334 // test call signs
335 // requesting stations callsign
336 std::string testcall;
337 size_t p1 = 1, p2 = rcvPayLoad.find(ARQ_DLE, p1);
338 if (p2 != std::string::npos) {
339 testcall = upcase(rcvPayLoad.substr(p1, p2 - p1));
340 if (UrCall != testcall) {
341 printLOG("Wrong call", "");
342 return false;
343 }
344 p1 = p2+1;
345 p2 = rcvPayLoad.find(ARQ_DLE, p1);
346 if (p2 != std::string::npos) {
347 testcall = upcase(rcvPayLoad.substr(p1, p2 - p1));
348 if (testcall != MyCall) {
349 printLOG("Not my call", "");
350 return false;
351 }
352 } else
353 return false;
354 } else
355 return false;
356
357 rcvPayLoad.erase(0, p2+1);
358
359 return true;
360 }
361
362 void arq::parseCONREQ()
363 {
364 size_t p1 = 1, p2 = rcvPayLoad.find(ARQ_DLE);
365 if (p2 == std::string::npos) {
366 printLOG("CONREQ no calls", "");
367 return;
368 }
369 std::string testcall = upcase(rcvPayLoad.substr(p1, p2 - p1));
370
371 if ((LinkState == ARQ_CONNECTED) && (UrCall != testcall) )
372 return; // disallow multiple connects
373
374 // requesting stations callsign
375 UrCall = testcall;
376
377 p1 = p2 + 1;
378 p2 = rcvPayLoad.find(ARQ_DLE, p1);
379 testcall = upcase(rcvPayLoad.substr(p1, p2 - p1));
380 if (testcall != MyCall) {
381 printLOG("CONREQ not my call", "");
382 UrCall.clear();
383 rxUrCall(UrCall);
384 return;
385 }
386
387 rxUrCall(UrCall);
388
389 p2++;
390 int sz;
391 sscanf(rcvPayLoad.substr(p2).c_str(), "%d", &sz);
392 xfrsize = sz;
393
394 TxTextQueue.clear();
395 RxTextQueue.clear();
396 arqfname.clear();
397
398 printLOG("received CONREQ", "");
399
400 conackFrame();
401
402 LinkState = ARQ_CONNECTED;
403 }
404
405 void arq::parseCONACK()
406 {
407 if (!rightCALLS()) return;
408
409 if (progStatus.ID_off) {
410 set_fldigi_rxid(0);
411 set_fldigi_txid(0);
412 }
413
414 RxTextQueue.clear();
415
416 printLOG("received CONACK", "");
417
418 dataFrame();
419
420 LinkState = ARQ_CONNECTED;
421 }
422
423 void arq::parseDISREQ()
424 {
425 if (!rightCALLS() || (LinkState != ARQ_CONNECTED)) return;
426
427 TxTextQueue.clear();
428
429 printLOG("received DISREQ", "");
430
431 disackFrame();
432 }
433
434 void arq::parseDISACK()
435 {
436 if (!rightCALLS()) return;
437 printLOG("received DISACK", "");
438 exec_arqreset();
439 }
440
441 void arq::parsePOLL()
442 {
443 if (!rightCALLS() || (LinkState != ARQ_CONNECTED)) return;
444
445 printLOG("received POLL", "");
446
447 ackFrame();
448 }
449
450 void arq::parseDATA()
451 {
452 if (!rightCALLS() || (LinkState != ARQ_CONNECTED)) return;
453
454 char msg[200] = "received DATA";
455
456 size_t pos = rcvPayLoad.find(ARQ_DLE);
457 if (pos == std::string::npos) return;
458 std::string str_test = rcvPayLoad.substr(0, pos);
459 if (str_test != str_blknbr) {
460 str_blknbr = str_test;
461 rcvPayLoad.erase(0, pos + 1);
462 RxTextQueue.append(rcvPayLoad);
463 if (xfrsize) {
464 qualityfnc( 1.0 * RxTextQueue.length() / xfrsize);
465 snprintf(msg, sizeof(msg),"received DATA %0.1f %%", 100.0 * RxTextQueue.length() / xfrsize);
466 }
467 if (xfrsize == RxTextQueue.length()) {
468 qualityfnc(1.0);
469 std::string fname = "message";
470 size_t p = std::string::npos;
471 if ((p = RxTextQueue.find("[ARQ:fn ")) != std::string::npos) {
472 p += 8;
473 size_t p2 = RxTextQueue.find("]", p);
474 if (p2 != std::string::npos)
475 fname = RxTextQueue.substr(p, p2 - p);
476 }
477 snprintf(msg, sizeof(msg),
478 "%s\"%s\" from %s",
479 sRcvd.c_str(),
480 fname.c_str(),
481 UrCall.c_str());
482 escape(false, RxTextQueue);
483 printRX(RxTextQueue);
484 RxTextQueue.clear();
485 }
486 }
487 printLOG(msg, "");
488
489 ackFrame();
490 }
491
492 void arq::parseACK()
493 {
494 if (!rightCALLS() || (LinkState != ARQ_CONNECTED)) return;
495
496 printLOG("received ACK", "");
497
498 size_t pos = rcvPayLoad.find(ARQ_DLE);
499 if (pos == std::string::npos) return;
500
501 if (str_blknbr == rcvPayLoad.substr(0, pos)) {
502 xmttext.erase(0, last_buffer_length);
503 if (!xmttext.empty())
504 dataFrame();
505 else {
506 qualityfnc(1.0);
507 std::string msg = "Transferred \"";
508 msg.append(arqfname).append("\" to ").append(UrCall);
509 printLOG(msg, "");
510 disconnect();
511 }
512 } else {
513 addToTxQue(lastframe);
514 }
515 }
516
517 void arq::parseNAK()
518 {
519 if (!rightCALLS() || (LinkState != ARQ_CONNECTED)) return;
520
521 printLOG("received NAK", "");
522 printLOG("resend DATA FRAME", "");
523
524 addToTxQue(lastframe);
525 }
526
527 void arq::parseFrame(std::string txt)
528 {
529 txt = noCR(txt);
530
531 Ccrc16 testcrc;
532 size_t len = txt.length();
533
534 if (len < 15) return;
535
536 rcvPayLoad = txt.substr(0, len - strlen(ARQ_EOF) - 4);
537
538 std::string sRcvdCRC = testcrc.scrc16( rcvPayLoad );
539
540 std::string rxCRC = txt.substr(len - strlen(ARQ_EOF) - 4, 4);
541
542 if (sRcvdCRC != rxCRC ) { // failed CRC test
543 retrytime = rtry();
544 timeout = getRetries() * retrytime;
545 printLOG("failed CRC test", "");
546 if (!sender && (LinkState == ARQ_CONNECTED))
547 nakFrame();
548 return;
549 }
550
551 rcvPayLoad.erase(0, strlen(ARQ_SOF));
552
553 switch (rcvPayLoad[0]) {
554 case CONREQ :
555 printLOG("<RX>", txt);
556 parseCONREQ();
557 break;
558 case CONACK :
559 printLOG("<RX>", txt);
560 parseCONACK();
561 break;
562 case DISREQ :
563 if (LinkState >= ARQ_CONNECTED)
564 printLOG("<RX>", txt);
565 parseDISREQ();
566 break;
567 case DISACK :
568 if (LinkState >= ARQ_CONNECTED)
569 printLOG("<RX>", txt);
570 parseDISACK();
571 break;
572 case POLL :
573 if (LinkState == ARQ_CONNECTED)
574 printLOG("<RX>", txt);
575 parsePOLL();
576 break;
577 case ACK:
578 if (LinkState == ARQ_CONNECTED)
579 printLOG("<RX>", txt);
580 parseACK();
581 break;
582 case NAK:
583 if (LinkState == ARQ_CONNECTED)
584 printLOG("<RX>", txt);
585 parseNAK();
586 break;
587 case DATA :
588 if (LinkState == ARQ_CONNECTED)
589 printLOG("<RX>", txt);
590 parseDATA();
591 break;
592 default :
593 nakFrame();
594 }
595 retrytime = rtry();
596 timeout = getRetries() * retrytime;
597 }
598
599
600 //=====================================================================
601 void arq::setbuffer_length()
602 {
603 if (exponent == 4) buffer_length = 16;
604 else if (exponent == 5) buffer_length = 32;
605 else if (exponent == 6) buffer_length = 64;
606 else if (exponent == 7) buffer_length = 128;
607 else if (exponent == 8) buffer_length = 256;
608 else if (exponent == 9) buffer_length = 512;
609 else if (exponent == 10) buffer_length = 1024;
610 else buffer_length = 128;
611 }
612
613 void arq::connect()
614 {
615 for (size_t i = 0; i < UrCall.length(); i++)
616 UrCall[i] = toupper(UrCall[i]);
617
618 rxUrCall(UrCall);
619
620 first_rtry = true;
621 TxTextQueue.clear();
622 connectFrame();
623 retries = getRetries();
624 LinkState = ARQ_CONNECTING;
625
626 }
627
628 void arq::disconnect()
629 {
630 disconnectFrame();
631 retries = getRetries();
632 LinkState = ARQ_DISCONNECT;
633 }
634
635 void arq::escape(bool encode, std::string &s)
636 {
637 if (encode) {
638 size_t p = s.find(ESC_CHR);
639 while (p != std::string::npos) {
640 p++;
641 s.insert(p, 1, ESC_CHR);
642 p = s.find(ESC_CHR, p+1);
643 }
644 } else {
645 std::string dblesc;
646 dblesc += ESC_CHR; dblesc += ESC_CHR;
647 size_t p = s.find(dblesc);
648 while (p != std::string::npos) {
649 s.erase(p,1);
650 p = s.find(dblesc, p+1);
651 }
652 }
653 }
654
655 void arq::sendtext(std::string call, std::string s)
656 {
657 char s_xfrsize[20];
658
659 if (LinkState != ARQ_DOWN) return;
660 xmttext = s;
661 escape(true, xmttext);
662 xfrsize = xmttext.length();
663 snprintf(s_xfrsize, sizeof(s_xfrsize), "%d", (int)xfrsize);
664 str_xfrsize = s_xfrsize;
665 UrCall = call;
666 if (progStatus.ID_on) {
667 set_fldigi_rxid(1);
668 set_fldigi_txid(1);
669 }
670
671 arqfname.clear();
672 size_t p = std::string::npos;
673 if ((p = s.find("[ARQ:fn ")) != std::string::npos) {
674 p += 8;
675 size_t p2 = s.find("]", p);
676 if (p2 != std::string::npos)
677 arqfname = s.substr(p, p2 - p);
678 }
679
680 connect();
681 }
682
683 // received a NAK resend the last frame
684 // add retry countdown etc.
685
686 void arq::resendFrame()
687 {
688 addToTxQue(lastframe);
689
690 printLOG("received NAK", "");
691 }
692
693 extern void arqlog(std::string, std::string);
694
695 int arq::rtry()
696 {
697 nomFrame.clear();
698 nomFrame.append(ARQ_SOF);
699 nomFrame += 'A';
700 nomFrame.append (MyCall);
701 nomFrame.append(ARQ_DLE);
702 nomFrame.append("AA9AAA/8");
703 nomFrame.append(ARQ_DLE);
704 nomFrame.append(std::string(16,'B'));
705 nomFrame.append("1234");
706 nomFrame.append(ARQ_EOF);
707
708 float response_delay = transmit_time(nomFrame);
709 if (response_delay < 5.0) response_delay = 5.0;
710 response_delay *= 1000.0; // in milliseconds
711 response_delay *= (1.0 + (0.5 * rand() / RAND_MAX));
712 int idelay = floorf(response_delay/ ARQLOOPTIME);
713
714 if (first_rtry) {
715 std::stringstream str;
716 str << "Wait " << idelay * ARQLOOPTIME / 1000.0 << " sec's before retry";
717 printLOG(str.str(), "");
718 first_rtry = false;
719 }
720
721 return idelay;
722 }
723
724 void arq::exec_arqreset()
725 {
726 MilliSleep(1000);
727
728 LinkState = ARQ_DOWN;
729 retries = getRetries();
730 retrytime = rtry();
731 timeout = -1;
732 xfrsize = 0;
733 xfrsize = 0;
734 sender = false;
735
736 RxTextQueue.clear();
737 TxTextQueue.clear();
738
739 printLOG("DISCONNECTED","");
740 rxUrCall("");
741 qualityfnc(0);
742
743 if (progStatus.ID_on) {
744 set_fldigi_rxid(1);
745 set_fldigi_txid(1);
746 }
747 disconnectfnc();
748 }
749
750 static std::string rxbuf = " ";
751 static char chkchar = ' ';
752 void arq::rcv_chars()
753 {
754 char c;
755 while (getc1(c) == true) {
756 chkchar = rxbuf[0];
757 rxbuf[0] = rxbuf[1];
758 rxbuf[1] = c;
759 if ((rxbuf == ARQ_SOF) && (chkchar != ESC_CHR)) {
760 RxFrameQueue.clear();
761 RxFrameQueue.append(rxbuf);
762 } else if (RxFrameQueue.find(ARQ_SOF) == 0) {
763 retrytime = rtry();
764 timeout = getRetries() * retrytime;
765 if ((rxbuf == ARQ_EOF) && (chkchar != ESC_CHR)) {
766 RxFrameQueue += c;
767 parseFrame(RxFrameQueue);
768 RxFrameQueue.clear();
769 goto retfunc;
770 } else
771 RxFrameQueue += c;
772 } else if ((rxbuf == ARQ_EOF) && (chkchar != ESC_CHR)) {
773 RxFrameQueue.clear();
774 }
775 if (RxFrameQueue.length() > 1200)
776 exec_arqreset();
777 }
778 retfunc:
779 if (trx()) return;
780 //!OK_to_transmit()) return;
781
782 if (LinkState != ARQ_DOWN) {
783 --timeout;
784 if (timeout == 0) {
785 std::string fname = "";
786 std::string msg = sTout;
787 size_t p = std::string::npos;
788 fname = arqfname;
789 if (fname.empty()) {
790 if ((p = RxTextQueue.find("[ARQ:fn ")) != std::string::npos) {
791 p += 8;
792 size_t p2 = RxTextQueue.find("]", p);
793 if (p2 != std::string::npos)
794 fname = RxTextQueue.substr(p, p2 - p);
795 }
796 }
797 if (fname.empty()) fname.assign(_("Filename not known"));
798 msg.append(fname);
799 msg.append(sColon).append(UrCall);
800 printLOG(msg, "");
801 exec_arqreset();
802 }
803 }
804 }
805
806 void arq::sendchars()
807 {
808 if (!OK_to_transmit()) {
809 return;
810 }
811 if (RxFrameQueue.find(ARQ_SOF) == 0) {
812 return;
813 }
814
815 // test for non response if this is the sending station
816 if (LinkState != arq::ARQ_DOWN) {
817 if (sender) {
818 retrytime--;
819 if (retrytime == 0) {
820 retries--;
821 if (retries == 0) {
822 std::string failtext = sRtry;
823 failtext.append(UrCall);
824 failtext.append(sColon);
825 failtext.append(arqfname);
826 failtext.append(sColon);
827 switch (lastblock) {
828 case DATA: failtext.append("DATA block"); break;
829 case POLL: failtext.append("POLL block"); break;
830 case CONREQ: failtext.append("CONREQ block"); break;
831 case DISREQ: failtext.append("DISREQ block"); break;
832 }
833 printLOG("<TX>", failtext);
834 exec_arqreset();
835 return;
836 }
837
838 std::stringstream s;
839 s << "Resend " << retries;
840 printLOG("<TX>", s.str());
841 retrytime = rtry();
842
843 if (lastblock == DATA) pollFrame();
844 if (lastblock == POLL) pollFrame();
845 else if (lastblock == CONREQ) connectFrame();
846 else if (lastblock == DISREQ) disconnectFrame();
847
848 printLOG("<TX>", TxTextQueue);
849
850 sendfnc(TxTextQueue.insert(0," \n"));
851
852 TxTextQueue.clear();
853
854 return;
855 }
856 }
857 }
858
859 // transmit new data
860
861 if (TxTextQueue.empty() )
862 return;
863
864 printLOG("<TX>", TxTextQueue);
865
866 sendfnc(TxTextQueue.insert(0," \n"));
867
868 retrytime = rtry();
869
870 if (lastblock == DISACK) exec_arqreset();
871
872 TxTextQueue.clear();
873
874 return;
875 }
876
877 //----------------------------------------------------------------------
878 // friend process of arq class
879 // operates in a separate thread
880 // all called by reference functions must use Fl::wait(fn,...)
881 // to isolate the UI thread from the arq thread
882 //----------------------------------------------------------------------
883
884 void * arqloop(void *)
885 {
886 int looptime = ARQLOOPTIME;
887
888 while (1) {
889 MilliSleep(
890 inst->LinkState == arq::ARQ_DOWN ? looptime * 10 : looptime);
891 if (inst->arq_exit) break;
892 {
893 guard_lock arqlock( &arq_mutex );
894 if (inst->arqreset) {
895 inst->exec_arqreset();
896 inst->arqreset = false;
897 }
898 inst->rcv_chars();
899 inst->sendchars();
900 }
901 }
902 return NULL;
903 }
904
905 void arq::start_arq()
906 {
907 if (arq_running) return; // ONLY ONE instance allowed
908 inst = this;
909
910 if (pthread_create(&arq_thread, NULL, arqloop, NULL) < 0) {
911 LOG_ERROR("arq init: pthread_create failed");
912 arq_running = false;
913 inst = NULL;
914 return;
915 }
916 if (progStatus.ID_on) {
917 set_fldigi_rxid(1);
918 set_fldigi_txid(1);
919 }
920 arq_running = true;
921 }
922
923 void arq::reset_arq() {
924 arqreset = true;
925 }
926
927 void arq::exit_arq() {
928 if (arq_running == false) return;
929 {
930 guard_lock arqlock( &arq_mutex );
931 arq_exit = true;
932 }
933 pthread_join(arq_thread, NULL);
934 arq_running = false;
935
936 }
937 //---------------------------------------------------------------------