forked from quinot/taylor-uucp
-
Notifications
You must be signed in to change notification settings - Fork 0
/
trans.c
1517 lines (1310 loc) · 37.4 KB
/
trans.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* trans.c
Routines to handle file transfers.
Copyright (C) 1992, 1993, 1995, 2002 Ian Lance Taylor
This file is part of the Taylor UUCP package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
The author of the program may be contacted at [email protected].
*/
#include "uucp.h"
#if USE_RCS_ID
const char trans_rcsid[] = "$Id$";
#endif
#include <errno.h>
#include "uudefs.h"
#include "uuconf.h"
#include "prot.h"
#include "system.h"
#include "trans.h"
/* To avoid wasting a lot of time scanning the spool directory, which
might cause the remote system to time out, we limit each scan to
pick up at most a certain number of files. */
#define COMMANDS_PER_SCAN (200)
/* The structure we use when waiting for an acknowledgement of a
confirmed received file in fsent_receive_ack. */
struct sreceive_ack
{
struct sreceive_ack *qnext;
char *zto;
char *ztemp;
boolean fmarked;
};
/* Local functions. */
static void utqueue P((struct stransfer **, struct stransfer *,
boolean fhead));
static void utdequeue P((struct stransfer *));
static void utchanalc P((struct sdaemon *qdaemon, struct stransfer *qtrans));
__inline__ static struct stransfer *qtchan P((int ichan));
__inline__ static void utchanfree P((struct stransfer *qtrans));
static void utfree_queue P((struct stransfer **pq));
static boolean fttime P((struct sdaemon *qdaemon, long *pisecs,
long *pimicros));
static boolean fcheck_queue P((struct sdaemon *qdaemon));
static boolean ftadd_cmd P((struct sdaemon *qdaemon, const char *z,
size_t cdata, int iremote, boolean flast));
static boolean fremote_hangup_reply P((struct stransfer *qtrans,
struct sdaemon *qdaemon));
static void utfree_receive_ack P((struct sreceive_ack *q));
static void utfree_acked P((void));
static boolean flocal_poll_file P((struct stransfer *qtrans,
struct sdaemon *qdaemon));
/* Queue of transfer structures that are ready to start which have
been requested by the local system. These are only permitted to
start when the local system is the master. */
static struct stransfer *qTlocal;
/* Queue of transfer structures that are ready to start which have
been requested by the remote system. These are responses to
commands received from the remote system, and should be started as
soon as possible. */
static struct stransfer *qTremote;
/* Queue of transfer structures that have been started and want to
send information. This should be static, but the 'a' protocol
looks at it, at least for now. */
struct stransfer *qTsend;
/* Queue of transfer structures that have been started and are waiting
to receive information. */
static struct stransfer *qTreceive;
/* Queue of free transfer structures. */
static struct stransfer *qTavail;
/* Array of transfer structures indexed by local channel number. This
is maintained for local jobs. */
static struct stransfer *aqTchan[IMAX_CHAN + 1];
/* Number of local channel numbers currently allocated. */
static int cTchans;
/* Next channel number to allocate. */
static int iTchan;
/* Array of transfer structures indexed by remote channel number.
This is maintained for remote jobs. */
static struct stransfer *aqTremote[IMAX_CHAN + 1];
/* The transaction we are currently receiving. This is used to avoid
getting the time too frequently. */
static struct stransfer *qTtiming_rec;
/* The time from which to charge any received data. This is either
the last time we charged for received data, or the last time
something was put on the empty receive queue. */
static long iTrecsecs;
static long iTrecmicros;
/* The minimum amount of time, in seconds, to wait between times we
check the spool directory, if we are busy transferring data. If we
have nothing to do, we will check the spool directory regardless of
how long ago the last check was. This should probably be
configurable. */
#define CCHECKWAIT (600)
/* The time we last checked the spool directory for work. This is set
from the return value of ixsysdep_process_time, not ixsysdep_time,
for convenience in the routines which use it. */
static long iTchecktime;
/* The size of the command we have read so far in ftadd_cmd. */
static size_t cTcmdlen;
/* A list of structures used when waiting for an acknowledgement of a
confirmed received file in fsent_receive_ack. */
static struct sreceive_ack *qTreceive_ack;
/* Queue up a transfer structure before *pq. This puts it at the head
or the tail of the list headed by *pq. */
static void
utqueue (struct stransfer **pq, struct stransfer *q, boolean fhead)
{
if (*pq == NULL)
{
*pq = q;
q->qprev = q->qnext = q;
}
else
{
q->qnext = *pq;
q->qprev = (*pq)->qprev;
q->qprev->qnext = q;
q->qnext->qprev = q;
if (fhead)
*pq = q;
}
q->pqqueue = pq;
}
/* Dequeue a transfer structure. */
static void
utdequeue (struct stransfer *q)
{
if (q->pqqueue != NULL)
{
if (*(q->pqqueue) == q)
{
if (q->qnext == q)
*(q->pqqueue) = NULL;
else
*(q->pqqueue) = q->qnext;
}
q->pqqueue = NULL;
}
if (q->qprev != NULL)
q->qprev->qnext = q->qnext;
if (q->qnext != NULL)
q->qnext->qprev = q->qprev;
q->qprev = NULL;
q->qnext = NULL;
}
/* Queue up a transfer structure requested by the local system. */
/*ARGSIGNORED*/
boolean
fqueue_local (struct sdaemon *qdaemon ATTRIBUTE_UNUSED, struct stransfer *qtrans)
{
utdequeue (qtrans);
utqueue (&qTlocal, qtrans, FALSE);
return TRUE;
}
/* Queue up a transfer structure requested by the remote system. The
stransfer structure should have the iremote field set. We need to
record it, so that any subsequent data associated with this
channel can be routed to the right place. */
boolean
fqueue_remote (struct sdaemon *qdaemon ATTRIBUTE_UNUSED, struct stransfer *qtrans)
{
DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO, "fqueue_remote: Channel %d",
qtrans->iremote);
if (qtrans->iremote > 0)
aqTremote[qtrans->iremote] = qtrans;
utdequeue (qtrans);
utqueue (&qTremote, qtrans, FALSE);
return TRUE;
}
/* Queue up a transfer with something to send. */
boolean
fqueue_send (struct sdaemon *qdaemon ATTRIBUTE_UNUSED, struct stransfer *qtrans)
{
#if DEBUG > 0
if (qtrans->psendfn == NULL)
ulog (LOG_FATAL, "fqueue_send: Bad call");
#endif
utdequeue (qtrans);
/* Sort the send queue to always send commands before files, and to
sort jobs by grade. */
if (qTsend == NULL)
utqueue (&qTsend, qtrans, FALSE);
else
{
register struct stransfer *q;
boolean ffirst;
ffirst = TRUE;
q = qTsend;
do
{
if (! qtrans->fsendfile && q->fsendfile)
break;
if ((! qtrans->fsendfile || q->fsendfile)
&& UUCONF_GRADE_CMP (qtrans->s.bgrade, q->s.bgrade) < 0)
break;
ffirst = FALSE;
q = q->qnext;
}
while (q != qTsend);
qtrans->qnext = q;
qtrans->qprev = q->qprev;
q->qprev = qtrans;
qtrans->qprev->qnext = qtrans;
if (ffirst)
qTsend = qtrans;
qtrans->pqqueue = &qTsend;
}
return TRUE;
}
/* Queue up a transfer with something to receive. */
boolean
fqueue_receive (struct sdaemon *qdaemon ATTRIBUTE_UNUSED, struct stransfer *qtrans)
{
#if DEBUG > 0
if (qtrans->precfn == NULL)
ulog (LOG_FATAL, "fqueue_receive: Bad call");
#endif
/* If this is the only item on the receive queue, we do not want to
charge it for any time during which we have not been waiting for
anything, so update the receive timestamp. */
if (qTreceive == NULL)
iTrecsecs = ixsysdep_process_time (&iTrecmicros);
utdequeue (qtrans);
utqueue (&qTreceive, qtrans, FALSE);
return TRUE;
}
/* Get a new local channel number. */
static void
utchanalc (struct sdaemon *qdaemon, struct stransfer *qtrans)
{
do
{
++iTchan;
if (iTchan > qdaemon->cchans)
iTchan = 1;
}
while (aqTchan[iTchan] != NULL);
qtrans->ilocal = iTchan;
aqTchan[iTchan] = qtrans;
++cTchans;
}
/* Return the transfer for a channel number. */
__inline__
static struct stransfer *
qtchan (int ic)
{
return aqTchan[ic];
}
/* Clear the channel number for a transfer. */
__inline__
static void
utchanfree (struct stransfer *qt)
{
if (qt->ilocal != 0)
{
aqTchan[qt->ilocal] = NULL;
qt->ilocal = 0;
--cTchans;
}
}
/* Allocate a new transfer structure. */
struct stransfer *
qtransalc (struct scmd *qcmd)
{
register struct stransfer *q;
q = qTavail;
if (q != NULL)
utdequeue (q);
else
q = (struct stransfer *) xmalloc (sizeof (struct stransfer));
q->qnext = NULL;
q->qprev = NULL;
q->pqqueue = NULL;
q->psendfn = NULL;
q->precfn = NULL;
q->pinfo = NULL;
q->fsendfile = FALSE;
q->frecfile = FALSE;
q->e = EFILECLOSED;
q->ipos = 0;
q->fcmd = FALSE;
q->zcmd = NULL;
q->ccmd = 0;
q->ilocal = 0;
q->iremote = 0;
if (qcmd != NULL)
{
q->s = *qcmd;
q->s.zfrom = zbufcpy (qcmd->zfrom);
q->s.zto = zbufcpy (qcmd->zto);
q->s.zuser = zbufcpy (qcmd->zuser);
q->s.zoptions = zbufcpy (qcmd->zoptions);
q->s.ztemp = zbufcpy (qcmd->ztemp);
q->s.znotify = zbufcpy (qcmd->znotify);
q->s.zcmd = zbufcpy (qcmd->zcmd);
}
else
{
q->s.zfrom = NULL;
q->s.zto = NULL;
q->s.zuser = NULL;
q->s.zoptions = NULL;
q->s.ztemp = NULL;
q->s.znotify = NULL;
q->s.zcmd = NULL;
}
q->zlog = NULL;
q->isecs = 0;
q->imicros = 0;
q->cbytes = 0;
return q;
}
/* Free a transfer structure. This does not free any pinfo
information that may have been allocated. */
void
utransfree (struct stransfer *q)
{
ubuffree (q->zcmd);
ubuffree ((char *) q->s.zfrom);
ubuffree ((char *) q->s.zto);
ubuffree ((char *) q->s.zuser);
ubuffree ((char *) q->s.zoptions);
ubuffree ((char *) q->s.ztemp);
ubuffree ((char *) q->s.znotify);
ubuffree ((char *) q->s.zcmd);
utchanfree (q);
if (q->iremote > 0)
{
aqTremote[q->iremote] = NULL;
q->iremote = 0;
}
if (ffileisopen (q->e))
{
(void) ffileclose (q->e);
q->e = EFILECLOSED;
}
#if DEBUG > 0
q->zcmd = NULL;
q->s.zfrom = NULL;
q->s.zto = NULL;
q->s.zuser = NULL;
q->s.zoptions = NULL;
q->s.ztemp = NULL;
q->s.znotify = NULL;
q->s.zcmd = NULL;
q->psendfn = NULL;
q->precfn = NULL;
#endif
/* Avoid any possible confusion in the timing code. */
if (qTtiming_rec == q)
qTtiming_rec = NULL;
utdequeue (q);
utqueue (&qTavail, q, FALSE);
}
/* Free a queue of transfer structures. */
static void
utfree_queue (struct stransfer **pq)
{
while (*pq != NULL)
utransfree (*pq);
}
/* Get the time. This is a wrapper around ixsysdep_process_time. If
enough time has elapsed since the last time we got the time, check
the work queue. */
static boolean
fttime (struct sdaemon *qdaemon, long int *pisecs, long int *pimicros)
{
*pisecs = ixsysdep_process_time (pimicros);
if (*pisecs - iTchecktime >= CCHECKWAIT)
{
if (! fcheck_queue (qdaemon))
return FALSE;
}
return TRUE;
}
/* Gather local commands and queue them up for later processing. Also
recompute time based control values. */
boolean
fqueue (struct sdaemon *qdaemon, boolean *pfany)
{
const struct uuconf_system *qsys;
long ival;
int bgrade;
struct uuconf_timespan *qlocal_size, *qremote_size;
if (pfany != NULL)
*pfany = FALSE;
qsys = qdaemon->qsys;
/* If we are not the caller, the grade will be set during the
initial handshake, although this may be overridden by the
calledtimegrade configuration option. */
if (! qdaemon->fcaller)
{
if (! ftimespan_match (qsys->uuconf_qcalledtimegrade, &ival,
(int *) NULL))
bgrade = qdaemon->bgrade;
else
bgrade = (char) ival;
}
else
{
if (! ftimespan_match (qsys->uuconf_qtimegrade, &ival,
(int *) NULL))
bgrade = '\0';
else
bgrade = (char) ival;
}
/* Determine the maximum sizes we can send and receive. */
if (qdaemon->fcaller)
{
qlocal_size = qsys->uuconf_qcall_local_size;
qremote_size = qsys->uuconf_qcall_remote_size;
}
else
{
qlocal_size = qsys->uuconf_qcalled_local_size;
qremote_size = qsys->uuconf_qcalled_remote_size;
}
if (! ftimespan_match (qlocal_size, &qdaemon->clocal_size, (int *) NULL))
qdaemon->clocal_size = (long) -1;
if (! ftimespan_match (qremote_size, &qdaemon->cremote_size, (int *) NULL))
qdaemon->cremote_size = (long) -1;
if (bgrade == '\0')
return TRUE;
if (! fsysdep_get_work_init (qsys, bgrade, COMMANDS_PER_SCAN))
return FALSE;
while (TRUE)
{
struct scmd s;
if (! fsysdep_get_work (qsys, bgrade, COMMANDS_PER_SCAN, &s))
return FALSE;
if (s.bcmd == 'H')
{
ulog_user ((const char *) NULL);
break;
}
if (s.bcmd == 'P')
{
struct stransfer *qtrans;
/* A poll file. */
ulog_user ((const char *) NULL);
qtrans = qtransalc (&s);
qtrans->psendfn = flocal_poll_file;
if (! fqueue_local (qdaemon, qtrans))
return FALSE;
continue;
}
ulog_user (s.zuser);
switch (s.bcmd)
{
case 'S':
case 'E':
if (! flocal_send_file_init (qdaemon, &s))
return FALSE;
break;
case 'R':
if (! flocal_rec_file_init (qdaemon, &s))
return FALSE;
break;
case 'X':
if (! flocal_xcmd_init (qdaemon, &s))
return FALSE;
break;
#if DEBUG > 0
default:
ulog (LOG_FATAL, "fqueue: Can't happen");
break;
#endif
}
}
if (pfany != NULL)
*pfany = qTlocal != NULL;
iTchecktime = ixsysdep_process_time ((long *) NULL);
return TRUE;
}
/* Clear everything off the work queue. This is used when the call is
complete, or if the call is never made. */
void
uclear_queue (struct sdaemon *qdaemon)
{
int i;
usysdep_get_work_free (qdaemon->qsys);
utfree_queue (&qTlocal);
utfree_queue (&qTremote);
utfree_queue (&qTsend);
utfree_queue (&qTreceive);
cTchans = 0;
iTchan = 0;
qTtiming_rec = NULL;
cTcmdlen = 0;
if (qTreceive_ack != NULL)
utfree_acked ();
for (i = 0; i < IMAX_CHAN + 1; i++)
{
aqTchan[i] = NULL;
aqTremote[i] = NULL;
}
}
/* Recheck the work queue during a conversation. This is only called
if it's been more than CCHECKWAIT seconds since the last time the
queue was checked. */
static boolean
fcheck_queue (struct sdaemon *qdaemon)
{
/* Only check if we are the master, or if there are multiple
channels, or if we aren't already trying to get the other side to
hang up. Otherwise, there's nothing we can do with any new jobs
we might find. */
if (qdaemon->fmaster
|| qdaemon->cchans > 1
|| ! qdaemon->frequest_hangup)
{
boolean fany;
DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO,
"fcheck_queue: Rechecking work queue");
if (! fqueue (qdaemon, &fany))
return FALSE;
/* If we found something to do, and we're not the master, and we
don't have multiple channels to send new jobs over, try to
get the other side to hang up. */
if (fany && ! qdaemon->fmaster && qdaemon->cchans <= 1)
qdaemon->frequest_hangup = TRUE;
}
return TRUE;
}
/* The main transfer loop. The uucico daemon spends essentially all
its time in this function. */
boolean
floop (struct sdaemon *qdaemon)
{
boolean fret;
fret = TRUE;
while (! qdaemon->fhangup)
{
register struct stransfer *q;
#if DEBUG > 1
/* If we're doing any debugging, close the log and debugging
files regularly. This will let people copy them off and
remove them while the conversation is in progresss. */
if (iDebug != 0)
{
ulog_close ();
ustats_close ();
}
#endif
if (qdaemon->fmaster)
{
boolean fhangup;
/* We've managed to become the master, so we no longer want
to request a hangup. */
qdaemon->frequest_hangup = FALSE;
fhangup = FALSE;
if (qdaemon->fhangup_requested
&& qTsend == NULL
&& (qTreceive == NULL || qdaemon->cchans > 1))
{
/* The remote system has requested that we transfer
control by sending CYM after receiving a file. */
DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO,
"floop: Transferring control at remote request");
fhangup = TRUE;
}
else if (qTremote == NULL
&& qTlocal == NULL
&& qTsend == NULL
&& qTreceive == NULL)
{
/* We don't have anything to do. Try to find some new
jobs. If we can't, transfer control. */
if (! fqueue (qdaemon, (boolean *) NULL))
{
fret = FALSE;
break;
}
if (qTlocal == NULL)
{
DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO,
"floop: No work for master");
fhangup = TRUE;
}
}
if (fhangup)
{
if (! (*qdaemon->qproto->pfsendcmd) (qdaemon, "H", 0, 0))
{
fret = FALSE;
break;
}
qdaemon->fmaster = FALSE;
}
}
/* If we are no long the master, clear any requested hangup. We
may have already hung up before checking this variable in the
block above. */
if (! qdaemon->fmaster)
qdaemon->fhangup_requested = FALSE;
/* Immediately queue up any remote jobs. We don't need local
channel numbers for them, since we can disambiguate based on
the remote channel number. */
while (qTremote != NULL)
{
q = qTremote;
utdequeue (q);
utqueue (&qTsend, q, TRUE);
}
/* If we are the master, or if we have multiple channels, try to
queue up additional local jobs. */
if (qdaemon->fmaster || qdaemon->cchans > 1)
{
while (qTlocal != NULL && cTchans < qdaemon->cchans)
{
/* We have room for an additional channel. */
q = qTlocal;
if (! fqueue_send (qdaemon, q))
{
fret = FALSE;
break;
}
utchanalc (qdaemon, q);
}
if (! fret)
break;
}
q = qTsend;
if (q == NULL)
{
ulog_user ((const char *) NULL);
DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO, "floop: Waiting for data");
if (! (*qdaemon->qproto->pfwait) (qdaemon))
{
fret = FALSE;
break;
}
}
else
{
ulog_user (q->s.zuser);
if (! q->fsendfile)
{
/* Technically, we should add the time required for this
call to q->isecs and q->imicros. In practice, the
amount of time required should be sufficiently small
that it can be safely disregarded. */
if (! (*q->psendfn) (q, qdaemon))
{
fret = FALSE;
break;
}
}
else
{
long isecs, imicros;
boolean fcharged;
long cmax_time;
long istart = 0;
long inextsecs = 0, inextmicros;
if (! fttime (qdaemon, &isecs, &imicros))
{
fret = FALSE;
break;
}
fcharged = FALSE;
if (q->zlog != NULL)
{
ulog (LOG_NORMAL, "%s", q->zlog);
ubuffree (q->zlog);
q->zlog = NULL;
}
cmax_time = qdaemon->qsys->uuconf_cmax_file_time;
if (qdaemon->cchans <= 1)
cmax_time = 0;
if (cmax_time > 0)
istart = ixsysdep_time (NULL);
/* We can read the file in a tight loop until we have a
command to send, or the file send has been cancelled,
or we have a remote job to deal with, or the maximum
file send time has been exceeded. We can disregard
any changes to qTlocal since we already have
something to send anyhow. */
while (q == qTsend
&& q->fsendfile
&& qTremote == NULL)
{
char *zdata;
size_t cdata;
long ipos;
zdata = (*qdaemon->qproto->pzgetspace) (qdaemon, &cdata);
if (zdata == NULL)
{
fret = FALSE;
break;
}
if (ffileeof (q->e))
cdata = 0;
else
{
cdata = cfileread (q->e, zdata, cdata);
if (ffileioerror (q->e, cdata))
{
/* There is no way to report a file reading
error, so we just drop the connection. */
ulog (LOG_ERROR, "read: %s", strerror (errno));
fret = FALSE;
break;
}
}
ipos = q->ipos;
q->ipos += cdata;
q->cbytes += cdata;
if (! (*qdaemon->qproto->pfsenddata) (qdaemon, zdata,
cdata, q->ilocal,
q->iremote, ipos))
{
fret = FALSE;
break;
}
if (cdata == 0)
{
/* We must update the time now, because this
call may make an entry in the statistics
file. */
inextsecs = ixsysdep_process_time (&inextmicros);
DEBUG_MESSAGE4 (DEBUG_UUCP_PROTO,
"floop: Charging %ld to %c %s %s",
((inextsecs - isecs) * 1000000
+ inextmicros - imicros),
q->s.bcmd, q->s.zfrom, q->s.zto);
q->isecs += inextsecs - isecs;
q->imicros += inextmicros - imicros;
fcharged = TRUE;
q->fsendfile = FALSE;
if (! (*q->psendfn) (q, qdaemon))
fret = FALSE;
break;
}
if (cmax_time > 0
&& q->qnext != q
&& ixsysdep_time (NULL) - istart >= cmax_time)
{
DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO, "floop: Switch file");
utdequeue (q);
utqueue (&qTsend, q, FALSE);
}
}
if (! fret)
break;
if (! fcharged)
{
inextsecs = ixsysdep_process_time (&inextmicros);
DEBUG_MESSAGE4 (DEBUG_UUCP_PROTO,
"floop: Charging %ld to %c %s %s",
((inextsecs - isecs) * 1000000
+ inextmicros - imicros),
q->s.bcmd, q->s.zfrom, q->s.zto);
q->isecs += inextsecs - isecs;
q->imicros += inextmicros - imicros;
}
if (inextsecs - iTchecktime >= CCHECKWAIT)
{
if (! fcheck_queue (qdaemon))
{
fret = FALSE;
break;
}
}
}
}
}
ulog_user ((const char *) NULL);
(void) (*qdaemon->qproto->pfshutdown) (qdaemon);
if (fret)
uwindow_acked (qdaemon, TRUE);
else
ufailed (qdaemon);
return fret;
}
/* This is called by the protocol routines when they have received
some data. If pfexit is not NULL, *pfexit should be set to TRUE if
the protocol receive loop should exit back to the main floop
routine, above. It is only important to set *pfexit to TRUE if the
main loop called the pfwait entry point, so we need never set it to
TRUE if we just receive data for a file. This routine never sets
*pfexit to FALSE. */
boolean
fgot_data (qdaemon, zfirst, cfirst, zsecond, csecond, ilocal, iremote, ipos,
fallacked, pfexit)
struct sdaemon *qdaemon;
const char *zfirst;
size_t cfirst;
const char *zsecond;
size_t csecond;
int ilocal;
int iremote;
long ipos;
boolean fallacked;
boolean *pfexit;
{
struct stransfer *q;
int cwrote;
boolean fret;
long isecs, imicros;
if (fallacked && qTreceive_ack != NULL)
uwindow_acked (qdaemon, TRUE);
/* Now we have to decide which transfer structure gets the data. If
ilocal is -1, it means that the protocol does not know where to
route the data. In that case we route it to the first transfer
that is waiting for data, or, if none, as a new command. If
ilocal is 0, we either select based on the remote channel number
or we have a new command. */
if (ilocal == -1 && qTreceive != NULL)
q = qTreceive;
else if (ilocal == 0 && iremote > 0 && aqTremote[iremote] != NULL)
q = aqTremote[iremote];
else if (ilocal <= 0)
{
const char *znull;
ulog_user ((const char *) NULL);
/* This data is part of a command. If there is no null
character in the data, this string will be continued by the
next packet. Otherwise this must be the last string in the
command, and we don't care about what comes after the null
byte. */
znull = (const char *) memchr (zfirst, '\0', cfirst);
if (znull != NULL)
fret = ftadd_cmd (qdaemon, zfirst, (size_t) (znull - zfirst),
iremote, TRUE);
else
{
fret = ftadd_cmd (qdaemon, zfirst, cfirst, iremote, FALSE);
if (fret && csecond > 0)
{
znull = (const char *) memchr (zsecond, '\0', csecond);
if (znull != NULL)
fret = ftadd_cmd (qdaemon, zsecond,
(size_t) (znull - zsecond), iremote, TRUE);
else
fret = ftadd_cmd (qdaemon, zsecond, csecond, iremote, FALSE);
}
}
if (pfexit != NULL && (qdaemon->fhangup || qTremote != NULL))
*pfexit = TRUE;
/* Time spent waiting for a new command is not charged to
anybody. */
if (! fttime (qdaemon, &iTrecsecs, &iTrecmicros))
fret = FALSE;
return fret;
}
else