![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to protf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to protf.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 ! root 1: /* protf.c ! 2: The 'f' protocol. ! 3: ! 4: Copyright (C) 1991, 1992 Ian Lance Taylor ! 5: ! 6: This file is part of the Taylor UUCP package. ! 7: ! 8: This program is free software; you can redistribute it and/or ! 9: modify it under the terms of the GNU General Public License as ! 10: published by the Free Software Foundation; either version 2 of the ! 11: License, or (at your option) any later version. ! 12: ! 13: This program is distributed in the hope that it will be useful, but ! 14: WITHOUT ANY WARRANTY; without even the implied warranty of ! 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 16: General Public License for more details. ! 17: ! 18: You should have received a copy of the GNU General Public License ! 19: along with this program; if not, write to the Free Software ! 20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 21: ! 22: The author of the program may be contacted at [email protected] or ! 23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254. ! 24: */ ! 25: ! 26: #include "uucp.h" ! 27: ! 28: #if USE_RCS_ID ! 29: const char protf_rcsid[] = "$Id: protf.c,v 1.1 93/07/30 07:53:18 bin Exp Locker: bin $"; ! 30: #endif ! 31: ! 32: #include <ctype.h> ! 33: #include <errno.h> ! 34: ! 35: #include "uudefs.h" ! 36: #include "uuconf.h" ! 37: #include "conn.h" ! 38: #include "trans.h" ! 39: #include "system.h" ! 40: #include "prot.h" ! 41: ! 42: /* This implementation is based on code by Piet Beertema, CWI, ! 43: Amsterdam, Sep 1984. ! 44: ! 45: This code implements the 'f' protocol, which requires a ! 46: flow-controlled error-free seven-bit data path. It does check for ! 47: errors, but only at the end of each file transmission, so a noisy ! 48: line without error correcting modems will be unusable. ! 49: ! 50: The conversion to seven bit data is done as follows, where b ! 51: represents the character to convert: ! 52: ! 53: 0 <= b <= 037: 0172, b + 0100 (0100 to 0137) ! 54: 040 <= b <= 0171: b ( 040 to 0171) ! 55: 0172 <= b <= 0177: 0173, b - 0100 ( 072 to 077) ! 56: 0200 <= b <= 0237: 0174, b - 0100 (0100 to 0137) ! 57: 0240 <= b <= 0371: 0175, b - 0200 ( 040 to 0171) ! 58: 0372 <= b <= 0377: 0176, b - 0300 ( 072 to 077) ! 59: ! 60: This causes all output bytes to be in the range 040 to 0176; these ! 61: are the printable ASCII characters. */ ! 62: ! 63: /* This structure is used to hold information when dealing with the ! 64: end of file acknowledgement. */ ! 65: ! 66: struct sfinfo ! 67: { ! 68: /* The functions from the generic code. */ ! 69: boolean (*psendfn) P((struct stransfer *qtrans, struct sdaemon *qdaemon)); ! 70: boolean (*precfn) P((struct stransfer *qtrans, struct sdaemon *qdaemon, ! 71: const char *zdata, size_t cdata)); ! 72: /* The info pointer from the generic code. */ ! 73: pointer pinfo; ! 74: /* The character to send after receiving the checksum. */ ! 75: char bsend; ! 76: }; ! 77: ! 78: /* Internal functions. */ ! 79: static boolean ffprocess_data P((struct sdaemon *qdaemon, ! 80: boolean *pfexit, size_t *pcneed)); ! 81: static boolean ffawait_ack P((struct stransfer *qtrans, ! 82: struct sdaemon *qdaemon, ! 83: const char *zdata, size_t cdata)); ! 84: static boolean ffawait_cksum P((struct stransfer *qtrans, ! 85: struct sdaemon *qdaemon, ! 86: const char *zdata, size_t cdata)); ! 87: static boolean ffsend_ack P((struct stransfer *qtrans, ! 88: struct sdaemon *qdaemon)); ! 89: ! 90: /* The size of the buffer we allocate to store outgoing data in. */ ! 91: #define CFBUFSIZE (256) ! 92: ! 93: /* The timeout to wait for data to arrive before giving up. */ ! 94: static int cFtimeout = 120; ! 95: ! 96: /* The maximum number of retries. */ ! 97: static int cFmaxretries = 2; ! 98: ! 99: /* The buffer we allocate for outgoing data. */ ! 100: static char *zFbuf; ! 101: ! 102: /* TRUE if we are receiving a file rather than a command. */ ! 103: static boolean fFfile; ! 104: ! 105: /* The checksum so far. */ ! 106: static unsigned int iFcheck; ! 107: ! 108: /* The last special byte (0172 to 0176) or 0 if none. */ ! 109: static char bFspecial; ! 110: ! 111: /* The number of times we have retried this file. */ ! 112: static int cFretries; ! 113: ! 114: /* Whether this file has been acknowledged. */ ! 115: static boolean fFacked; ! 116: ! 117: struct uuconf_cmdtab asFproto_params[] = ! 118: { ! 119: { "timeout", UUCONF_CMDTABTYPE_INT, (pointer) &cFtimeout, NULL }, ! 120: { "retries", UUCONF_CMDTABTYPE_INT, (pointer) &cFmaxretries, NULL }, ! 121: { NULL, 0, NULL, NULL } ! 122: }; ! 123: ! 124: /* Statistics. */ ! 125: ! 126: /* The number of data bytes sent in files. */ ! 127: static long cFsent_data; ! 128: ! 129: /* The number of actual bytes sent in files. */ ! 130: static long cFsent_bytes; ! 131: ! 132: /* The number of data bytes received in files. */ ! 133: static long cFrec_data; ! 134: ! 135: /* The number of actual bytes received in files. */ ! 136: static long cFrec_bytes; ! 137: ! 138: /* The number of file retries when sending. */ ! 139: static long cFsend_retries; ! 140: ! 141: /* The number of file retries when receiving. */ ! 142: static long cFrec_retries; ! 143: ! 144: /* Start the protocol. */ ! 145: ! 146: boolean ! 147: ffstart (qdaemon, pzlog) ! 148: struct sdaemon *qdaemon; ! 149: char **pzlog; ! 150: { ! 151: *pzlog = NULL; ! 152: ! 153: cFsent_data = 0; ! 154: cFsent_bytes = 0; ! 155: cFrec_data = 0; ! 156: cFrec_bytes = 0; ! 157: cFsend_retries = 0; ! 158: cFrec_retries = 0; ! 159: ! 160: /* Use XON/XOFF handshaking. */ ! 161: if (! fconn_set (qdaemon->qconn, PARITYSETTING_DEFAULT, ! 162: STRIPSETTING_SEVENBITS, XONXOFF_ON)) ! 163: return FALSE; ! 164: ! 165: /* We sleep to allow the other side to reset the terminal; this is ! 166: what Mr. Beertema's code does. */ ! 167: usysdep_sleep (2); ! 168: ! 169: return TRUE; ! 170: } ! 171: ! 172: /* Shutdown the protocol. */ ! 173: ! 174: /*ARGSIGNORED*/ ! 175: boolean ! 176: ffshutdown (qdaemon) ! 177: struct sdaemon *qdaemon; ! 178: { ! 179: xfree ((pointer) zFbuf); ! 180: zFbuf = NULL; ! 181: ulog (LOG_NORMAL, ! 182: "Protocol 'f': sent %ld bytes for %ld, received %ld bytes for %ld", ! 183: cFsent_bytes, cFsent_data, cFrec_bytes, cFrec_data); ! 184: if (cFsend_retries != 0 || cFrec_retries != 0) ! 185: ulog (LOG_NORMAL, "Protocol 'f' file retries: %ld sending, %ld receiving", ! 186: cFsend_retries, cFrec_retries); ! 187: cFtimeout = 120; ! 188: cFmaxretries = 2; ! 189: return TRUE; ! 190: } ! 191: ! 192: /* Send a command string. We just send the string followed by a carriage ! 193: return. */ ! 194: ! 195: /*ARGSUSED*/ ! 196: boolean ! 197: ffsendcmd (qdaemon, z, ilocal, iremote) ! 198: struct sdaemon *qdaemon; ! 199: const char *z; ! 200: int ilocal; ! 201: int iremote; ! 202: { ! 203: size_t clen; ! 204: char *zalc; ! 205: boolean fret; ! 206: ! 207: DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO, "ffsendcmd: Sending command \"%s\"", z); ! 208: ! 209: clen = strlen (z); ! 210: zalc = zbufalc (clen + 2); ! 211: memcpy (zalc, z, clen); ! 212: zalc[clen] = '\r'; ! 213: zalc[clen + 1] = '\0'; ! 214: fret = fsend_data (qdaemon->qconn, zalc, clen + 1, TRUE); ! 215: ubuffree (zalc); ! 216: return fret; ! 217: } ! 218: ! 219: /* Get space to be filled with data. We allocate the space from the ! 220: heap. */ ! 221: ! 222: /*ARGSIGNORED*/ ! 223: char * ! 224: zfgetspace (qdaemon, pclen) ! 225: struct sdaemon *qdaemon; ! 226: size_t *pclen; ! 227: { ! 228: *pclen = CFBUFSIZE; ! 229: if (zFbuf == NULL) ! 230: zFbuf = (char *) xmalloc (CFBUFSIZE); ! 231: return zFbuf; ! 232: } ! 233: ! 234: /* Send out a data packet. We have to encode the data into seven bits ! 235: and accumulate a checksum. */ ! 236: ! 237: /*ARGSIGNORED*/ ! 238: boolean ! 239: ffsenddata (qdaemon, zdata, cdata, ilocal, iremote, ipos) ! 240: struct sdaemon *qdaemon; ! 241: char *zdata; ! 242: size_t cdata; ! 243: int ilocal; ! 244: int iremote; ! 245: long ipos; ! 246: { ! 247: char ab[CFBUFSIZE * 2]; ! 248: char *ze; ! 249: register unsigned int itmpchk; ! 250: ! 251: cFsent_data += cdata; ! 252: ! 253: ze = ab; ! 254: itmpchk = iFcheck; ! 255: while (cdata-- > 0) ! 256: { ! 257: register int b; ! 258: ! 259: /* Rotate the checksum left. */ ! 260: if ((itmpchk & 0x8000) == 0) ! 261: itmpchk <<= 1; ! 262: else ! 263: { ! 264: itmpchk <<= 1; ! 265: ++itmpchk; ! 266: } ! 267: ! 268: /* Add the next byte into the checksum. */ ! 269: b = *zdata++ & 0xff; ! 270: itmpchk += b; ! 271: ! 272: /* Encode the byte. */ ! 273: if (b <= 0177) ! 274: { ! 275: if (b <= 037) ! 276: { ! 277: *ze++ = '\172'; ! 278: *ze++ = (char) (b + 0100); ! 279: } ! 280: else if (b <= 0171) ! 281: *ze++ = (char) b; ! 282: else ! 283: { ! 284: *ze++ = '\173'; ! 285: *ze++ = (char) (b - 0100); ! 286: } ! 287: } ! 288: else ! 289: { ! 290: if (b <= 0237) ! 291: { ! 292: *ze++ = '\174'; ! 293: *ze++ = (char) (b - 0100); ! 294: } ! 295: else if (b <= 0371) ! 296: { ! 297: *ze++ = '\175'; ! 298: *ze++ = (char) (b - 0200); ! 299: } ! 300: else ! 301: { ! 302: *ze++ = '\176'; ! 303: *ze++ = (char) (b - 0300); ! 304: } ! 305: } ! 306: } ! 307: ! 308: iFcheck = itmpchk; ! 309: ! 310: cFsent_bytes += ze - ab; ! 311: ! 312: /* Passing FALSE tells fsend_data not to bother looking for incoming ! 313: information, since we really don't expect any. */ ! 314: return fsend_data (qdaemon->qconn, ab, (size_t) (ze - ab), FALSE); ! 315: } ! 316: ! 317: /* Process data and return the amount of data we are looking for in ! 318: *pcneed. The 'f' protocol doesn't really reveal this, but when ! 319: transferring file we know that we need at least seven characters ! 320: for the checksum. */ ! 321: ! 322: static boolean ! 323: ffprocess_data (qdaemon, pfexit, pcneed) ! 324: struct sdaemon *qdaemon; ! 325: boolean *pfexit; ! 326: size_t *pcneed; ! 327: { ! 328: int i; ! 329: register unsigned int itmpchk; ! 330: ! 331: *pfexit = FALSE; ! 332: if (pcneed != NULL) ! 333: *pcneed = 1; ! 334: ! 335: if (! fFfile) ! 336: { ! 337: /* A command continues until a '\r' character, which we turn ! 338: into '\0' before calling fgot_data. */ ! 339: while (iPrecstart != iPrecend) ! 340: { ! 341: for (i = iPrecstart; i < CRECBUFLEN && i != iPrecend; i++) ! 342: { ! 343: if (abPrecbuf[i] == '\r') ! 344: { ! 345: int istart; ! 346: ! 347: DEBUG_MESSAGE1 (DEBUG_PROTO, ! 348: "ffprocess_data: Got %d command bytes", ! 349: i - iPrecstart + 1); ! 350: ! 351: abPrecbuf[i] = '\0'; ! 352: istart = iPrecstart; ! 353: iPrecstart = (i + 1) % CRECBUFLEN; ! 354: if (pcneed != NULL) ! 355: *pcneed = 0; ! 356: return fgot_data (qdaemon, abPrecbuf + istart, ! 357: (size_t) (i - istart + 1), ! 358: (const char *) NULL, (size_t) 0, ! 359: -1, -1, (long) -1, TRUE, pfexit); ! 360: } ! 361: } ! 362: ! 363: DEBUG_MESSAGE1 (DEBUG_PROTO, ! 364: "ffprocess_data: Got %d command bytes", ! 365: i - iPrecstart); ! 366: ! 367: if (! fgot_data (qdaemon, abPrecbuf + iPrecstart, ! 368: (size_t) (i - iPrecstart), ! 369: (const char *) NULL, (size_t) 0, ! 370: -1, -1, (long) -1, TRUE, pfexit)) ! 371: return FALSE; ! 372: ! 373: iPrecstart = i % CRECBUFLEN; ! 374: } ! 375: ! 376: return TRUE; ! 377: } ! 378: ! 379: /* Here the data is destined for a file, and we must decode it. */ ! 380: ! 381: itmpchk = iFcheck; ! 382: ! 383: while (iPrecstart != iPrecend) ! 384: { ! 385: char *zstart, *zto, *zfrom; ! 386: int c; ! 387: ! 388: zto = zfrom = zstart = abPrecbuf + iPrecstart; ! 389: ! 390: c = iPrecend - iPrecstart; ! 391: if (c < 0) ! 392: c = CRECBUFLEN - iPrecstart; ! 393: ! 394: while (c-- != 0) ! 395: { ! 396: int b; ! 397: ! 398: b = *zfrom++ & 0xff; ! 399: if (b < 040 || b > 0176) ! 400: { ! 401: ulog (LOG_ERROR, "Illegal byte %d", b); ! 402: continue; ! 403: } ! 404: ! 405: /* Characters >= 0172 are always special characters. The ! 406: only legal pair of consecutive special characters ! 407: are 0176 0176 which immediately precede the four ! 408: digit checksum. */ ! 409: if (b >= 0172) ! 410: { ! 411: if (bFspecial != 0) ! 412: { ! 413: if (bFspecial != 0176 || b != 0176) ! 414: { ! 415: ulog (LOG_ERROR, "Illegal bytes %d %d", ! 416: bFspecial, b); ! 417: bFspecial = 0; ! 418: continue; ! 419: } ! 420: ! 421: /* Pass any initial data. */ ! 422: if (zto != zstart) ! 423: { ! 424: /* Don't count the checksum in the received bytes. */ ! 425: cFrec_bytes += zfrom - zstart - 2; ! 426: cFrec_data += zto - zstart; ! 427: if (! fgot_data (qdaemon, zstart, ! 428: (size_t) (zto - zstart), ! 429: (const char *) NULL, (size_t) 0, ! 430: -1, -1, (long) -1, TRUE, pfexit)) ! 431: return FALSE; ! 432: } ! 433: ! 434: /* The next characters we want to read are the ! 435: checksum, so skip the second 0176. */ ! 436: iPrecstart = (iPrecstart + zfrom - zstart) % CRECBUFLEN; ! 437: ! 438: iFcheck = itmpchk; ! 439: ! 440: /* Tell fgot_data that we've read the entire file by ! 441: passing 0 length data. This will wind up calling ! 442: fffile to verify the checksum. We set *pcneed to ! 443: 0 because we don't want to read any more data ! 444: from the port, since we may have already read the ! 445: checksum. */ ! 446: if (pcneed != NULL) ! 447: *pcneed = 0; ! 448: return fgot_data (qdaemon, (const char *) NULL, ! 449: (size_t) 0, (const char *) NULL, ! 450: (size_t) 0, -1, -1, (long) -1, ! 451: TRUE, pfexit); ! 452: } ! 453: ! 454: /* Here we have encountered a special character that ! 455: does not follow another special character. */ ! 456: bFspecial = (char) b; ! 457: } ! 458: else ! 459: { ! 460: int bnext; ! 461: ! 462: /* Here we have encountered a nonspecial character. */ ! 463: ! 464: switch (bFspecial) ! 465: { ! 466: default: ! 467: bnext = b; ! 468: break; ! 469: case 0172: ! 470: bnext = b - 0100; ! 471: break; ! 472: case 0173: ! 473: case 0174: ! 474: bnext = b + 0100; ! 475: break; ! 476: case 0175: ! 477: bnext = b + 0200; ! 478: break; ! 479: case 0176: ! 480: bnext = b + 0300; ! 481: break; ! 482: } ! 483: ! 484: *zto++ = (char) bnext; ! 485: bFspecial = 0; ! 486: ! 487: /* Rotate the checksum left. */ ! 488: if ((itmpchk & 0x8000) == 0) ! 489: itmpchk <<= 1; ! 490: else ! 491: { ! 492: itmpchk <<= 1; ! 493: ++itmpchk; ! 494: } ! 495: ! 496: /* Add the next byte into the checksum. */ ! 497: itmpchk += bnext; ! 498: } ! 499: } ! 500: ! 501: if (zto != zstart) ! 502: { ! 503: DEBUG_MESSAGE1 (DEBUG_PROTO, ! 504: "ffprocess_data: Got %d bytes", ! 505: zto - zstart); ! 506: ! 507: cFrec_data += zto - zstart; ! 508: if (! fgot_data (qdaemon, zstart, (size_t) (zto - zstart), ! 509: (const char *) NULL, (size_t) 0, ! 510: -1, -1, (long) -1, TRUE, pfexit)) ! 511: return FALSE; ! 512: } ! 513: ! 514: cFrec_bytes += zfrom - zstart; ! 515: ! 516: iPrecstart = (iPrecstart + zfrom - zstart) % CRECBUFLEN; ! 517: } ! 518: ! 519: iFcheck = itmpchk; ! 520: ! 521: if (pcneed != NULL) ! 522: { ! 523: /* At this point we may have seen the first 0176 in the checksum ! 524: but not the second. The checksum is at least seven ! 525: characters long (0176 0176 a b c d \r). This won't help ! 526: much, but reading seven characters is a lot better than ! 527: reading two, which is what I saw in a 2400 baud log file. */ ! 528: if (bFspecial == 0176) ! 529: *pcneed = 6; ! 530: else ! 531: *pcneed = 7; ! 532: } ! 533: ! 534: return TRUE; ! 535: } ! 536: ! 537: /* Wait for data to come in and process it until we've finished a ! 538: command or a file. */ ! 539: ! 540: boolean ! 541: ffwait (qdaemon) ! 542: struct sdaemon *qdaemon; ! 543: { ! 544: while (TRUE) ! 545: { ! 546: boolean fexit; ! 547: size_t cneed, crec; ! 548: ! 549: if (! ffprocess_data (qdaemon, &fexit, &cneed)) ! 550: return FALSE; ! 551: if (fexit) ! 552: return TRUE; ! 553: ! 554: if (cneed > 0) ! 555: { ! 556: /* We really want to do something like get all available ! 557: characters, then sleep for half a second and get all ! 558: available characters again, and keep this up until we ! 559: don't get anything after sleeping. */ ! 560: if (! freceive_data (qdaemon->qconn, cneed, &crec, cFtimeout, TRUE)) ! 561: return FALSE; ! 562: if (crec == 0) ! 563: { ! 564: ulog (LOG_ERROR, "Timed out waiting for data"); ! 565: return FALSE; ! 566: } ! 567: } ! 568: } ! 569: } ! 570: ! 571: /* File level operations. Reset the checksums when starting to send ! 572: or receive a file, and output the checksum when we've finished ! 573: sending a file. */ ! 574: ! 575: /*ARGSUSED*/ ! 576: boolean ! 577: fffile (qdaemon, qtrans, fstart, fsend, cbytes, pfhandled) ! 578: struct sdaemon *qdaemon; ! 579: struct stransfer *qtrans; ! 580: boolean fstart; ! 581: boolean fsend; ! 582: long cbytes; ! 583: boolean *pfhandled; ! 584: { ! 585: DEBUG_MESSAGE3 (DEBUG_PROTO, "fffile: fstart %s; fsend %s; fFacked %s", ! 586: fstart ? "true" : "false", fsend ? "true" : "false", ! 587: fFacked ? "true" : "false"); ! 588: ! 589: *pfhandled = FALSE; ! 590: ! 591: if (fstart) ! 592: { ! 593: iFcheck = 0xffff; ! 594: cFretries = 0; ! 595: fFacked = FALSE; ! 596: if (! fsend) ! 597: { ! 598: bFspecial = 0; ! 599: fFfile = TRUE; ! 600: } ! 601: return TRUE; ! 602: } ! 603: else ! 604: { ! 605: struct sfinfo *qinfo; ! 606: ! 607: /* We need to handle the checksum and the acknowledgement. If ! 608: we get a successful ACK, we set fFacked to TRUE and call the ! 609: send or receive function by hand. This will wind up calling ! 610: here again, so if fFacked is TRUE we just return out and let ! 611: the send or receive function do whatever it does. This is a ! 612: bit of a hack. */ ! 613: if (fFacked) ! 614: { ! 615: fFacked = FALSE; ! 616: return TRUE; ! 617: } ! 618: ! 619: if (fsend) ! 620: { ! 621: char ab[sizeof "\176\176ABCD\r"]; ! 622: ! 623: /* Send the final checksum. */ ! 624: sprintf (ab, "\176\176%04x\r", iFcheck & 0xffff); ! 625: if (! fsend_data (qdaemon->qconn, ab, (size_t) 7, TRUE)) ! 626: return FALSE; ! 627: ! 628: /* Now wait for the acknowledgement. */ ! 629: fFfile = FALSE; ! 630: qinfo = (struct sfinfo *) xmalloc (sizeof (struct sfinfo)); ! 631: qinfo->psendfn = qtrans->psendfn; ! 632: qinfo->precfn = qtrans->precfn; ! 633: qinfo->pinfo = qtrans->pinfo; ! 634: qtrans->psendfn = NULL; ! 635: qtrans->precfn = ffawait_ack; ! 636: qtrans->pinfo = (pointer) qinfo; ! 637: qtrans->fcmd = TRUE; ! 638: ! 639: *pfhandled = TRUE; ! 640: ! 641: return fqueue_receive (qdaemon, qtrans); ! 642: } ! 643: else ! 644: { ! 645: /* Wait for the checksum. */ ! 646: fFfile = FALSE; ! 647: qinfo = (struct sfinfo *) xmalloc (sizeof (struct sfinfo)); ! 648: qinfo->psendfn = qtrans->psendfn; ! 649: qinfo->precfn = qtrans->precfn; ! 650: qinfo->pinfo = qtrans->pinfo; ! 651: qtrans->psendfn = NULL; ! 652: qtrans->precfn = ffawait_cksum; ! 653: qtrans->pinfo = (pointer) qinfo; ! 654: qtrans->fcmd = TRUE; ! 655: ! 656: *pfhandled = TRUE; ! 657: ! 658: return fqueue_receive (qdaemon, qtrans); ! 659: } ! 660: } ! 661: } ! 662: ! 663: /* Wait for the ack after sending a file and the checksum. */ ! 664: ! 665: static boolean ! 666: ffawait_ack (qtrans, qdaemon, zdata, cdata) ! 667: struct stransfer *qtrans; ! 668: struct sdaemon *qdaemon; ! 669: const char *zdata; ! 670: size_t cdata; ! 671: { ! 672: struct sfinfo *qinfo = (struct sfinfo *) qtrans->pinfo; ! 673: ! 674: qtrans->precfn = NULL; ! 675: ! 676: /* An R means to retry sending the file. */ ! 677: if (*zdata == 'R') ! 678: { ! 679: if (! ffileisopen (qtrans->e)) ! 680: { ! 681: ulog (LOG_ERROR, "Request to resent non-file"); ! 682: return FALSE; ! 683: } ! 684: ! 685: ++cFretries; ! 686: if (cFretries > cFmaxretries) ! 687: { ! 688: ulog (LOG_ERROR, "Too many retries"); ! 689: return FALSE; ! 690: } ! 691: ! 692: ulog (LOG_NORMAL, "Resending file"); ! 693: if (! ffilerewind (qtrans->e)) ! 694: { ! 695: ulog (LOG_ERROR, "rewind: %s", strerror (errno)); ! 696: return FALSE; ! 697: } ! 698: qtrans->ipos = (long) 0; ! 699: ! 700: iFcheck = 0xffff; ! 701: ++cFsend_retries; ! 702: ! 703: qtrans->psendfn = qinfo->psendfn; ! 704: qtrans->precfn = qinfo->precfn; ! 705: qtrans->pinfo = qinfo->pinfo; ! 706: xfree ((pointer) qinfo); ! 707: qtrans->fsendfile = TRUE; ! 708: ! 709: return fqueue_send (qdaemon, qtrans); ! 710: } ! 711: ! 712: if (*zdata != 'G') ! 713: { ! 714: DEBUG_MESSAGE1 (DEBUG_PROTO, "fffile: Got \"%s\"", zdata); ! 715: ulog (LOG_ERROR, "File send failed"); ! 716: return FALSE; ! 717: } ! 718: ! 719: qtrans->psendfn = qinfo->psendfn; ! 720: qtrans->precfn = qinfo->precfn; ! 721: qtrans->pinfo = qinfo->pinfo; ! 722: xfree ((pointer) qinfo); ! 723: ! 724: /* Now call the send function by hand after setting fFacked to TRUE. ! 725: Since fFacked is true fffile will simply return out, and the send ! 726: function can do whatever it what was going to do. */ ! 727: fFacked = TRUE; ! 728: return (*qtrans->psendfn) (qtrans, qdaemon); ! 729: } ! 730: ! 731: /* This function is called when the checksum arrives. */ ! 732: ! 733: /*ARGSUSED*/ ! 734: static boolean ! 735: ffawait_cksum (qtrans, qdaemon, zdata, cdata) ! 736: struct stransfer *qtrans; ! 737: struct sdaemon *qdaemon; ! 738: const char *zdata; ! 739: size_t cdata; ! 740: { ! 741: struct sfinfo *qinfo = (struct sfinfo *) qtrans->pinfo; ! 742: unsigned int icheck; ! 743: ! 744: qtrans->precfn = NULL; ! 745: ! 746: if (! isxdigit (zdata[0]) ! 747: || ! isxdigit (zdata[1]) ! 748: || ! isxdigit (zdata[2]) ! 749: || ! isxdigit (zdata[3]) ! 750: || zdata[4] != '\0') ! 751: { ! 752: ulog (LOG_ERROR, "Bad checksum format"); ! 753: xfree (qtrans->pinfo); ! 754: return FALSE; ! 755: } ! 756: ! 757: icheck = (unsigned int) strtol ((char *) zdata, (char **) NULL, 16); ! 758: ! 759: if (icheck != (iFcheck & 0xffff)) ! 760: { ! 761: DEBUG_MESSAGE2 (DEBUG_PROTO | DEBUG_ABNORMAL, ! 762: "Checksum failed; calculated 0x%x, got 0x%x", ! 763: iFcheck & 0xffff, icheck); ! 764: ! 765: if (! ffileisopen (qtrans->e)) ! 766: { ! 767: ulog (LOG_ERROR, "Failed to get non-file"); ! 768: return FALSE; ! 769: } ! 770: ! 771: ++cFretries; ! 772: if (cFretries > cFmaxretries) ! 773: { ! 774: ulog (LOG_ERROR, "Too many retries"); ! 775: qinfo->bsend = 'Q'; ! 776: } ! 777: else ! 778: { ! 779: ulog (LOG_NORMAL, "File being resent"); ! 780: ! 781: /* This bit of code relies on the receive code setting ! 782: qtrans->s.ztemp to the full name of the temporary file ! 783: being used. */ ! 784: qtrans->e = esysdep_truncate (qtrans->e, qtrans->s.ztemp); ! 785: if (! ffileisopen (qtrans->e)) ! 786: return FALSE; ! 787: qtrans->ipos = (long) 0; ! 788: ! 789: iFcheck = 0xffff; ! 790: bFspecial = 0; ! 791: fFfile = TRUE; ! 792: ++cFrec_retries; ! 793: ! 794: /* Send an R to tell the other side to resend the file. */ ! 795: qinfo->bsend = 'R'; ! 796: } ! 797: } ! 798: else ! 799: { ! 800: /* Send a G to tell the other side the file was received ! 801: correctly. */ ! 802: qinfo->bsend = 'G'; ! 803: } ! 804: ! 805: qtrans->psendfn = ffsend_ack; ! 806: ! 807: return fqueue_send (qdaemon, qtrans); ! 808: } ! 809: ! 810: /* Send the acknowledgement, and then possible wait for the resent ! 811: file. */ ! 812: ! 813: static boolean ! 814: ffsend_ack (qtrans, qdaemon) ! 815: struct stransfer *qtrans; ! 816: struct sdaemon *qdaemon; ! 817: { ! 818: struct sfinfo *qinfo = (struct sfinfo *) qtrans->pinfo; ! 819: char ab[2]; ! 820: ! 821: ab[0] = qinfo->bsend; ! 822: ab[1] = '\0'; ! 823: if (! ffsendcmd (qdaemon, ab, 0, 0)) ! 824: return FALSE; ! 825: ! 826: qtrans->psendfn = qinfo->psendfn; ! 827: qtrans->precfn = qinfo->precfn; ! 828: qtrans->pinfo = qinfo->pinfo; ! 829: xfree ((pointer) qinfo); ! 830: ! 831: if (ab[0] == 'Q') ! 832: return FALSE; ! 833: if (ab[0] == 'R') ! 834: { ! 835: qtrans->frecfile = TRUE; ! 836: return fqueue_receive (qdaemon, qtrans); ! 837: } ! 838: ! 839: fFacked = TRUE; ! 840: return (*qtrans->precfn) (qtrans, qdaemon, (const char *) NULL, ! 841: (size_t) 0); ! 842: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.