![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to send.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 send.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 ! root 1: /* send.c ! 2: Routines to send a file. ! 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 send_rcsid[] = "$Id: send.c,v 1.1 93/07/30 07:54:01 bin Exp Locker: bin $"; ! 30: #endif ! 31: ! 32: #include <errno.h> ! 33: ! 34: #include "uudefs.h" ! 35: #include "uuconf.h" ! 36: #include "system.h" ! 37: #include "prot.h" ! 38: #include "trans.h" ! 39: ! 40: /* We keep this information in the pinfo field of the stransfer ! 41: structure. */ ! 42: struct ssendinfo ! 43: { ! 44: /* Local user to send mail to (may be NULL). */ ! 45: char *zmail; ! 46: /* Full file name. */ ! 47: char *zfile; ! 48: /* Number of bytes in file. */ ! 49: long cbytes; ! 50: /* TRUE if this was a local request. */ ! 51: boolean flocal; ! 52: /* TRUE if this is a spool directory file. */ ! 53: boolean fspool; ! 54: /* TRUE if the file has been completely sent. */ ! 55: boolean fsent; ! 56: /* Execution file for sending an unsupported E request. */ ! 57: char *zexec; ! 58: }; ! 59: ! 60: /* Local functions. */ ! 61: ! 62: static void usfree_send P((struct stransfer *qtrans)); ! 63: static boolean flocal_send_fail P((struct stransfer *qtrans, ! 64: struct scmd *qcmd, ! 65: const struct uuconf_system *qsys, ! 66: const char *zwhy)); ! 67: static boolean flocal_send_request P((struct stransfer *qtrans, ! 68: struct sdaemon *qdaemon)); ! 69: static boolean flocal_send_await_reply P((struct stransfer *qtrans, ! 70: struct sdaemon *qdaemon, ! 71: const char *zdata, size_t cdata)); ! 72: static boolean flocal_send_cancelled P((struct stransfer *qtrans, ! 73: struct sdaemon *qdaemon)); ! 74: static boolean flocal_send_open_file P((struct stransfer *qtrans, ! 75: struct sdaemon *qdaemon)); ! 76: static boolean fremote_rec_fail P((struct sdaemon *qdaemon, ! 77: enum tfailure twhy, int iremote)); ! 78: static boolean fremote_rec_fail_send P((struct stransfer *qtrans, ! 79: struct sdaemon *qdaemon)); ! 80: static boolean fremote_rec_reply P((struct stransfer *qtrans, ! 81: struct sdaemon *qdaemon)); ! 82: static boolean fsend_file_end P((struct stransfer *qtrans, ! 83: struct sdaemon *qdaemon)); ! 84: static boolean fsend_await_confirm P((struct stransfer *qtrans, ! 85: struct sdaemon *qdaemon, ! 86: const char *zdata, size_t cdata)); ! 87: static boolean fsend_exec_file_init P((struct stransfer *qtrans, ! 88: struct sdaemon *qdaemon)); ! 89: static void usadd_exec_line P((char **pz, size_t *pcalc, size_t *pclen, ! 90: int bcmd, const char *z1, const char *z2)); ! 91: static boolean fsend_exec_file P((struct stransfer *qtrans, ! 92: struct sdaemon *qdaemon)); ! 93: ! 94: /* Free up a send stransfer structure. */ ! 95: ! 96: static void ! 97: usfree_send (qtrans) ! 98: struct stransfer *qtrans; ! 99: { ! 100: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 101: ! 102: if (qinfo != NULL) ! 103: { ! 104: ubuffree (qinfo->zmail); ! 105: ubuffree (qinfo->zfile); ! 106: ubuffree (qinfo->zexec); ! 107: xfree (qtrans->pinfo); ! 108: } ! 109: ! 110: utransfree (qtrans); ! 111: } ! 112: ! 113: /* Set up a local request to send a file. This may be called before ! 114: we have even tried to call the remote system. ! 115: ! 116: If we are using a traditional protocol, which doesn't support ! 117: channel numbers and doesn't permit the file to be sent until an ! 118: acknowledgement has been received, the sequence of function calls ! 119: looks like this: ! 120: ! 121: flocal_send_file_init --> fqueue_local ! 122: flocal_send_request (sends S request) --> fqueue_receive ! 123: flocal_send_await_reply (waits for SY) --> fqueue_send ! 124: flocal_send_open_file (opens file, calls pffile) --> fqueue_send ! 125: send file ! 126: fsend_file_end (calls pffile) --> fqueue_receive ! 127: fsend_await_confirm (waits for CY) ! 128: ! 129: If flocal_send_await_reply gets an SN, it deletes the request. If ! 130: the SY reply contains a file position at which to start sending, ! 131: flocal_send_await_reply sets qinfo->ipos. ! 132: ! 133: This gets more complex if the protocol supports channels. In that ! 134: case, we want to start sending the file data immediately, to avoid ! 135: the round trip delay between flocal_send_request and ! 136: flocal_send_await_reply. To do this, flocal_send_request calls ! 137: fqueue_send rather than fqueue_receive. The main execution ! 138: sequence looks like this: ! 139: ! 140: flocal_send_file_init --> fqueue_local ! 141: flocal_send_request (sends S request) --> fqueue_send ! 142: flocal_send_open_file (opens file, calls pffile) --> fqueue_send ! 143: send file ! 144: fsend_file_end (calls pffile) --> fqueue_receive ! 145: sometime: flocal_send_await_reply (waits for SY) ! 146: fsend_await_confirm (waits for CY) ! 147: ! 148: In this case flocal_send_await_reply must be run before ! 149: fsend_await_confirm; it may be run anytime after ! 150: flocal_send_request. ! 151: ! 152: If flocal_send_await_reply is called before the entire file has ! 153: been sent: if it gets an SN, it calls flocal_send_cancelled to send ! 154: an empty data block to inform the remote system that the file ! 155: transfer has stopped. If it gets a file position request, it must ! 156: adjust the file position accordingly. ! 157: ! 158: If flocal_send_await_reply is called after the entire file has been ! 159: sent: if it gets an SN, it can simply delete the request. It can ! 160: ignore any file position request. ! 161: ! 162: If the request is not deleted, flocal_send_await_reply must arrange ! 163: for the next string to be passed to fsend_await_confirm. ! 164: Presumably fsend_await_confirm will only be called after the entire ! 165: file has been sent. ! 166: ! 167: Just to make things even more complex, these same routines support ! 168: sending execution requests, since that is much like sending a file. ! 169: For an execution request, the bcmd character will be E rather than ! 170: S. If an execution request is being sent to a system which does ! 171: not support them, it must be sent as two S requests instead. The ! 172: second one will be the execution file, but no actual file is ! 173: created; instead the zexec and znext fields in the ssendinfo ! 174: structure are used. So if the bcmd character is E, then if the ! 175: zexec field is NULL, the data file is being sent, otherwise the ! 176: fake execution file is being sent. */ ! 177: ! 178: boolean ! 179: flocal_send_file_init (qdaemon, qcmd) ! 180: struct sdaemon *qdaemon; ! 181: struct scmd *qcmd; ! 182: { ! 183: const struct uuconf_system *qsys; ! 184: boolean fspool; ! 185: char *zfile; ! 186: long cbytes; ! 187: struct ssendinfo *qinfo; ! 188: struct stransfer *qtrans; ! 189: ! 190: qsys = qdaemon->qsys; ! 191: ! 192: if (qdaemon->fcaller ! 193: ? ! qsys->uuconf_fcall_transfer ! 194: : ! qsys->uuconf_fcalled_transfer) ! 195: { ! 196: /* uux or uucp should have already made sure that the transfer ! 197: is possible, but it might have changed since then. */ ! 198: if (! qsys->uuconf_fcall_transfer ! 199: && ! qsys->uuconf_fcalled_transfer) ! 200: return flocal_send_fail ((struct stransfer *) NULL, qcmd, qsys, ! 201: "not permitted to transfer files"); ! 202: ! 203: /* We can't do the request now, but it may get done later. */ ! 204: return TRUE; ! 205: } ! 206: ! 207: /* The 'C' option means that the file has been copied to the spool ! 208: directory. */ ! 209: if (strchr (qcmd->zoptions, 'C') == NULL ! 210: && ! fspool_file (qcmd->zfrom)) ! 211: { ! 212: fspool = FALSE; ! 213: if (! fin_directory_list (qcmd->zfrom, ! 214: qsys->uuconf_pzlocal_send, ! 215: qsys->uuconf_zpubdir, TRUE, ! 216: TRUE, qcmd->zuser)) ! 217: return flocal_send_fail ((struct stransfer *) NULL, qcmd, qsys, ! 218: "not permitted to send"); ! 219: zfile = zbufcpy (qcmd->zfrom); ! 220: } ! 221: else ! 222: { ! 223: fspool = TRUE; ! 224: zfile = zsysdep_spool_file_name (qsys, qcmd->ztemp, qcmd->pseq); ! 225: if (zfile == NULL) ! 226: return FALSE; ! 227: } ! 228: ! 229: /* Make sure we meet any local size restrictions. The connection ! 230: may not have been opened at this point, so we can't check remote ! 231: size restrictions. */ ! 232: cbytes = csysdep_size (zfile); ! 233: if (cbytes < 0) ! 234: { ! 235: ubuffree (zfile); ! 236: if (cbytes != -1) ! 237: return FALSE; ! 238: /* A cbytes value of -1 means that the file does not exist. ! 239: This can happen legitimately if it has already been sent from ! 240: the spool directory. */ ! 241: if (! fspool) ! 242: return flocal_send_fail ((struct stransfer *) NULL, qcmd, qsys, ! 243: "does not exist"); ! 244: (void) fsysdep_did_work (qcmd->pseq); ! 245: return TRUE; ! 246: } ! 247: ! 248: if (qdaemon->clocal_size != -1 ! 249: && qdaemon->clocal_size < cbytes) ! 250: { ! 251: ubuffree (zfile); ! 252: ! 253: if (qdaemon->cmax_ever == -2) ! 254: { ! 255: long c1, c2; ! 256: ! 257: c1 = cmax_size_ever (qsys->uuconf_qcall_local_size); ! 258: c2 = cmax_size_ever (qsys->uuconf_qcalled_local_size); ! 259: if (c1 > c2) ! 260: qdaemon->cmax_ever = c1; ! 261: else ! 262: qdaemon->cmax_ever = c2; ! 263: } ! 264: ! 265: if (qdaemon->cmax_ever != -1 ! 266: && qdaemon->cmax_ever < qcmd->cbytes) ! 267: return flocal_send_fail ((struct stransfer *) NULL, qcmd, qsys, ! 268: "too large to send"); ! 269: ! 270: return TRUE; ! 271: } ! 272: ! 273: /* We are now prepared to send the command to the remote system. We ! 274: queue up a transfer request to send the command when we are ! 275: ready. */ ! 276: qinfo = (struct ssendinfo *) xmalloc (sizeof (struct ssendinfo)); ! 277: if (strchr (qcmd->zoptions, 'm') == NULL) ! 278: qinfo->zmail = NULL; ! 279: else ! 280: qinfo->zmail = zbufcpy (qcmd->zuser); ! 281: qinfo->zfile = zfile; ! 282: qinfo->cbytes = cbytes; ! 283: qinfo->flocal = TRUE; ! 284: qinfo->fspool = fspool; ! 285: qinfo->fsent = FALSE; ! 286: qinfo->zexec = NULL; ! 287: ! 288: qtrans = qtransalc (qcmd); ! 289: qtrans->psendfn = flocal_send_request; ! 290: qtrans->pinfo = (pointer) qinfo; ! 291: ! 292: return fqueue_local (qdaemon, qtrans); ! 293: } ! 294: ! 295: /* Clean up after a failing local send request. If zwhy is not NULL, ! 296: this reports an error to the log file and to the user. */ ! 297: ! 298: static boolean ! 299: flocal_send_fail (qtrans, qcmd, qsys, zwhy) ! 300: struct stransfer *qtrans; ! 301: struct scmd *qcmd; ! 302: const struct uuconf_system *qsys; ! 303: const char *zwhy; ! 304: { ! 305: if (zwhy != NULL) ! 306: { ! 307: char *zfree; ! 308: ! 309: if (qcmd->bcmd != 'E') ! 310: zfree = NULL; ! 311: else ! 312: { ! 313: zfree = zbufalc (sizeof "Execution of \"\": " ! 314: + strlen (qcmd->zcmd) ! 315: + strlen (zwhy)); ! 316: sprintf (zfree, "Execution of \"%s\": %s", qcmd->zcmd, zwhy); ! 317: zwhy = zfree; ! 318: } ! 319: ! 320: ulog (LOG_ERROR, "%s: %s", qcmd->zfrom, zwhy); ! 321: (void) fmail_transfer (FALSE, qcmd->zuser, (const char *) NULL, ! 322: zwhy, qcmd->zfrom, (const char *) NULL, ! 323: qcmd->zto, qsys->uuconf_zname, ! 324: zsysdep_save_temp_file (qcmd->pseq)); ! 325: ! 326: ubuffree (zfree); ! 327: } ! 328: ! 329: (void) fsysdep_did_work (qcmd->pseq); ! 330: ! 331: if (qtrans != NULL) ! 332: usfree_send (qtrans); ! 333: ! 334: return TRUE; ! 335: } ! 336: ! 337: /* This is called when we are ready to send the request to the remote ! 338: system. We form the request and send it over. If the protocol ! 339: does not support multiple channels, we start waiting for the ! 340: response; otherwise we can start sending the file immediately. */ ! 341: ! 342: static boolean ! 343: flocal_send_request (qtrans, qdaemon) ! 344: struct stransfer *qtrans; ! 345: struct sdaemon *qdaemon; ! 346: { ! 347: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 348: char *zsend; ! 349: const char *znotify; ! 350: char absize[20]; ! 351: boolean fret; ! 352: ! 353: /* Make sure the file meets any remote size restrictions. */ ! 354: if (qdaemon->cmax_receive != -1 ! 355: && qdaemon->cmax_receive < qinfo->cbytes) ! 356: return flocal_send_fail (qtrans, &qtrans->s, qdaemon->qsys, ! 357: "too large for receiver"); ! 358: ! 359: /* Construct the notify string to send. If we are going to send a ! 360: size or an execution command, it must be non-empty. */ ! 361: znotify = qtrans->s.znotify; ! 362: if (znotify == NULL) ! 363: znotify = ""; ! 364: if ((qdaemon->ifeatures & FEATURE_SIZES) != 0 ! 365: || (qtrans->s.bcmd == 'E' ! 366: && (qdaemon->ifeatures & FEATURE_EXEC) != 0)) ! 367: { ! 368: if (*znotify == '\0') ! 369: znotify = "\"\""; ! 370: } ! 371: else ! 372: { ! 373: /* We don't need a notify string. Some crufty UUCP code can't ! 374: handle a pair of double quotes. */ ! 375: if (strcmp (znotify, "\"\"") == 0) ! 376: znotify = ""; ! 377: } ! 378: ! 379: /* Construct the size string to send. */ ! 380: if ((qdaemon->ifeatures & FEATURE_SIZES) == 0 ! 381: && (qtrans->s.bcmd != 'E' ! 382: || (qdaemon->ifeatures & FEATURE_EXEC) == 0)) ! 383: absize[0] = '\0'; ! 384: else if ((qdaemon->ifeatures & FEATURE_V103) == 0) ! 385: sprintf (absize, "0x%lx", (unsigned long) qinfo->cbytes); ! 386: else ! 387: sprintf (absize, "%ld", qinfo->cbytes); ! 388: ! 389: zsend = zbufalc (strlen (qtrans->s.zfrom) + strlen (qtrans->s.zto) ! 390: + strlen (qtrans->s.zuser) + strlen (qtrans->s.zoptions) ! 391: + strlen (qtrans->s.ztemp) + strlen (znotify) ! 392: + strlen (absize) ! 393: + (qtrans->s.zcmd != NULL ? strlen (qtrans->s.zcmd) : 0) ! 394: + 50); ! 395: ! 396: /* If this an execution request and the other side supports ! 397: execution requests, we send an E command. Otherwise we send an S ! 398: command. The case of an execution request when we are sending ! 399: the fake execution file is handled just like an S request at this ! 400: point. */ ! 401: if (qtrans->s.bcmd == 'E' ! 402: && (qdaemon->ifeatures & FEATURE_EXEC) != 0) ! 403: { ! 404: /* Send the string ! 405: E zfrom zto zuser zoptions ztemp imode znotify size zcmd ! 406: to the remote system. We put a '-' in front of the (possibly ! 407: empty) options and a '0' in front of the mode. */ ! 408: sprintf (zsend, "E %s %s %s -%s %s 0%o %s %s %s", qtrans->s.zfrom, ! 409: qtrans->s.zto, qtrans->s.zuser, qtrans->s.zoptions, ! 410: qtrans->s.ztemp, qtrans->s.imode, znotify, absize, ! 411: qtrans->s.zcmd); ! 412: } ! 413: else ! 414: { ! 415: const char *zoptions, *zdummy; ! 416: ! 417: /* Send the string ! 418: S zfrom zto zuser zoptions ztemp imode znotify ! 419: to the remote system. We put a '-' in front of the (possibly ! 420: empty) options and a '0' in front of the mode. If size ! 421: negotiation is supported, we also send the size; in this case ! 422: if znotify is empty we must send it as "". If this is really ! 423: an execution request, we have to simplify the options string ! 424: to remove the various execution options which may confuse the ! 425: remote system. SVR4 expects a string "dummy" between the ! 426: notify string and the size; I don't know why. */ ! 427: if (qtrans->s.bcmd != 'E') ! 428: zoptions = qtrans->s.zoptions; ! 429: else if (strchr (qtrans->s.zoptions, 'C') != NULL) ! 430: { ! 431: /* This should set zoptions to "C", but at least one UUCP ! 432: program gets confused by it. That means that it will ! 433: fail in certain cases, but I suppose we might as well ! 434: kowtow to compatibility. This shouldn't matter to any ! 435: other program, I hope. */ ! 436: zoptions = ""; ! 437: } ! 438: else ! 439: zoptions = "c"; ! 440: ! 441: if ((qdaemon->ifeatures & FEATURE_SVR4) != 0) ! 442: zdummy = " dummy "; ! 443: else ! 444: zdummy = " "; ! 445: ! 446: sprintf (zsend, "S %s %s %s -%s %s 0%o %s%s%s", qtrans->s.zfrom, ! 447: qtrans->s.zto, qtrans->s.zuser, zoptions, ! 448: qtrans->s.ztemp, qtrans->s.imode, znotify, zdummy, ! 449: absize); ! 450: } ! 451: ! 452: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, zsend, qtrans->ilocal, ! 453: qtrans->iremote); ! 454: ubuffree (zsend); ! 455: if (! fret) ! 456: { ! 457: usfree_send (qtrans); ! 458: return FALSE; ! 459: } ! 460: ! 461: /* If we are using a protocol which can make multiple channels, then ! 462: we can open and send the file whenever we are ready. This is ! 463: because we will be able to distinguish the response by the ! 464: channel it is directed to. This assumes that every protocol ! 465: which supports multiple channels also supports sending the file ! 466: position in mid-stream, since otherwise we would not be able to ! 467: restart files. */ ! 468: qtrans->fcmd = TRUE; ! 469: qtrans->psendfn = flocal_send_open_file; ! 470: qtrans->precfn = flocal_send_await_reply; ! 471: ! 472: if (qdaemon->qproto->cchans > 1) ! 473: return fqueue_send (qdaemon, qtrans); ! 474: else ! 475: return fqueue_receive (qdaemon, qtrans); ! 476: } ! 477: ! 478: /* This is called when a reply is received for the send request. As ! 479: described at length above, if the protocol supports multiple ! 480: channels we may be in the middle of sending the file, or we may ! 481: even finished sending the file. */ ! 482: ! 483: static boolean ! 484: flocal_send_await_reply (qtrans, qdaemon, zdata, cdata) ! 485: struct stransfer *qtrans; ! 486: struct sdaemon *qdaemon; ! 487: const char *zdata; ! 488: size_t cdata; ! 489: { ! 490: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 491: char bcmd; ! 492: ! 493: if (qtrans->s.bcmd == 'E' ! 494: && (qdaemon->ifeatures & FEATURE_EXEC) != 0) ! 495: bcmd = 'E'; ! 496: else ! 497: bcmd = 'S'; ! 498: if (zdata[0] != bcmd ! 499: || (zdata[1] != 'Y' && zdata[1] != 'N')) ! 500: { ! 501: ulog (LOG_ERROR, "%s: Bad response to %c request: \"%s\"", ! 502: qtrans->s.zfrom, bcmd, zdata); ! 503: usfree_send (qtrans); ! 504: return FALSE; ! 505: } ! 506: ! 507: if (zdata[1] == 'N') ! 508: { ! 509: const char *zerr; ! 510: boolean fnever; ! 511: ! 512: fnever = TRUE; ! 513: if (zdata[2] == '2') ! 514: zerr = "permission denied by remote"; ! 515: else if (zdata[2] == '4') ! 516: { ! 517: zerr = "remote cannot create work files"; ! 518: fnever = FALSE; ! 519: } ! 520: else if (zdata[2] == '6') ! 521: { ! 522: zerr = "too large for remote now"; ! 523: fnever = FALSE; ! 524: } ! 525: else if (zdata[2] == '7') ! 526: { ! 527: /* The file is too large to ever send. */ ! 528: zerr = "too large for remote"; ! 529: } ! 530: else if (zdata[2] == '8') ! 531: { ! 532: /* The file was already received by the remote system. This ! 533: is not an error, it just means that the ack from the ! 534: remote was lost in the previous conversation, and there ! 535: is no need to resend the file. */ ! 536: zerr = NULL; ! 537: } ! 538: else ! 539: zerr = "unknown reason"; ! 540: ! 541: if (! fnever) ! 542: { ! 543: if (qtrans->s.bcmd == 'E') ! 544: ulog (LOG_ERROR, "Execution of \"%s\": %s", qtrans->s.zcmd, ! 545: zerr); ! 546: else ! 547: ulog (LOG_ERROR, "%s: %s", qtrans->s.zfrom, zerr); ! 548: } ! 549: else ! 550: { ! 551: if (! flocal_send_fail ((struct stransfer *) NULL, &qtrans->s, ! 552: qdaemon->qsys, zerr)) ! 553: return FALSE; ! 554: } ! 555: ! 556: /* If the protocol does not support multiple channels, we can ! 557: simply remove the transaction. Otherwise we must make sure ! 558: the remote side knows that we have finished sending the file ! 559: data. If we have already sent the entire file, there will be ! 560: no confusion. */ ! 561: if (qdaemon->qproto->cchans == 1 || qinfo->fsent) ! 562: { ! 563: usfree_send (qtrans); ! 564: return TRUE; ! 565: } ! 566: else ! 567: { ! 568: qtrans->psendfn = flocal_send_cancelled; ! 569: qtrans->precfn = NULL; ! 570: qtrans->fsendfile = FALSE; ! 571: return fqueue_send (qdaemon, qtrans); ! 572: } ! 573: } ! 574: ! 575: /* A number following the SY or EY is the file position to start ! 576: sending from. If we are already sending the file, we must set ! 577: the position accordingly. */ ! 578: if (zdata[2] != '\0') ! 579: { ! 580: long cskip; ! 581: ! 582: cskip = strtol ((char *) (zdata + 2), (char **) NULL, 0); ! 583: if (cskip > 0 && qtrans->ipos < cskip) ! 584: { ! 585: if (qtrans->fsendfile && ! qinfo->fsent) ! 586: { ! 587: if (! ffileseek (qtrans->e, cskip)) ! 588: { ! 589: ulog (LOG_ERROR, "seek: %s", strerror (errno)); ! 590: usfree_send (qtrans); ! 591: return FALSE; ! 592: } ! 593: } ! 594: qtrans->ipos = cskip; ! 595: } ! 596: } ! 597: ! 598: /* Now queue up to send the file or to wait for the confirmation. ! 599: We already set psendfn at the end of flocal_send_request. If the ! 600: protocol supports multiple channels, we have already called ! 601: fqueue_send; calling it again would move the request in the ! 602: queue, which would make the log file a bit confusing. */ ! 603: qtrans->precfn = fsend_await_confirm; ! 604: if (qinfo->fsent) ! 605: return fqueue_receive (qdaemon, qtrans); ! 606: else if (qdaemon->qproto->cchans <= 1) ! 607: return fqueue_send (qdaemon, qtrans); ! 608: else ! 609: return TRUE; ! 610: } ! 611: ! 612: /* Open the file, if any, and prepare to send it. */ ! 613: ! 614: static boolean ! 615: flocal_send_open_file (qtrans, qdaemon) ! 616: struct stransfer *qtrans; ! 617: struct sdaemon *qdaemon; ! 618: { ! 619: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 620: const char *zuser; ! 621: ! 622: /* If this is not a fake execution file, open it. */ ! 623: if (qinfo->zexec == NULL) ! 624: { ! 625: /* If there is an ! in the user name, this is a remote request ! 626: queued up by fremote_xcmd_init. */ ! 627: zuser = qtrans->s.zuser; ! 628: if (strchr (zuser, '!') != NULL) ! 629: zuser = NULL; ! 630: ! 631: qtrans->e = esysdep_open_send (qdaemon->qsys, qinfo->zfile, ! 632: ! qinfo->fspool, zuser); ! 633: if (! ffileisopen (qtrans->e)) ! 634: { ! 635: (void) fmail_transfer (FALSE, qtrans->s.zuser, ! 636: (const char *) NULL, ! 637: "cannot open file", ! 638: qtrans->s.zfrom, (const char *) NULL, ! 639: qtrans->s.zto, ! 640: qdaemon->qsys->uuconf_zname, ! 641: zsysdep_save_temp_file (qtrans->s.pseq)); ! 642: (void) fsysdep_did_work (qtrans->s.pseq); ! 643: usfree_send (qtrans); ! 644: ! 645: /* Unfortunately, there is no way to cancel a file send ! 646: after we've already put it in progress. So we have to ! 647: return FALSE to drop the connection. */ ! 648: return FALSE; ! 649: } ! 650: } ! 651: ! 652: /* If flocal_send_await_reply has received a reply with a file ! 653: position, it will have set qtrans->ipos to the position at which ! 654: to start. */ ! 655: if (qtrans->ipos > 0) ! 656: { ! 657: if (qinfo->zexec != NULL) ! 658: { ! 659: if (qtrans->ipos > qtrans->cbytes) ! 660: qtrans->ipos = qtrans->cbytes; ! 661: } ! 662: else ! 663: { ! 664: if (! ffileseek (qtrans->e, qtrans->ipos)) ! 665: { ! 666: ulog (LOG_ERROR, "seek: %s", strerror (errno)); ! 667: usfree_send (qtrans); ! 668: return FALSE; ! 669: } ! 670: } ! 671: } ! 672: ! 673: /* We don't bother to log sending the execution file. */ ! 674: if (qinfo->zexec == NULL) ! 675: { ! 676: const char *zsend; ! 677: char *zalc; ! 678: ! 679: if (qtrans->s.bcmd != 'E') ! 680: { ! 681: zsend = qtrans->s.zfrom; ! 682: zalc = NULL; ! 683: } ! 684: else ! 685: { ! 686: zalc = zbufalc (strlen (qtrans->s.zcmd) + sizeof " ()" ! 687: + strlen (qtrans->s.zfrom)); ! 688: sprintf (zalc, "%s (%s)", qtrans->s.zcmd, qtrans->s.zfrom); ! 689: zsend = zalc; ! 690: } ! 691: qtrans->zlog = zbufalc (sizeof "Sending " + strlen (zsend)); ! 692: sprintf (qtrans->zlog, "Sending %s", zsend); ! 693: ubuffree (zalc); ! 694: } ! 695: ! 696: if (qdaemon->qproto->pffile != NULL) ! 697: { ! 698: boolean fhandled; ! 699: ! 700: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, TRUE, TRUE, ! 701: qinfo->cbytes, &fhandled)) ! 702: { ! 703: usfree_send (qtrans); ! 704: return FALSE; ! 705: } ! 706: ! 707: if (fhandled) ! 708: return TRUE; ! 709: } ! 710: ! 711: if (qinfo->zexec != NULL) ! 712: qtrans->psendfn = fsend_exec_file; ! 713: else ! 714: { ! 715: qtrans->fsendfile = TRUE; ! 716: qtrans->psendfn = fsend_file_end; ! 717: } ! 718: ! 719: return fqueue_send (qdaemon, qtrans); ! 720: } ! 721: ! 722: /* Cancel a file send by sending an empty buffer. This is only called ! 723: for a protocol which supports multiple channels. It is needed ! 724: so that both systems agree as to when a channel is no longer ! 725: needed. */ ! 726: ! 727: static boolean ! 728: flocal_send_cancelled (qtrans, qdaemon) ! 729: struct stransfer *qtrans; ! 730: struct sdaemon *qdaemon; ! 731: { ! 732: char *zdata; ! 733: size_t cdata; ! 734: boolean fret; ! 735: ! 736: zdata = (*qdaemon->qproto->pzgetspace) (qdaemon, &cdata); ! 737: if (zdata == NULL) ! 738: { ! 739: usfree_send (qtrans); ! 740: return FALSE; ! 741: } ! 742: ! 743: fret = (*qdaemon->qproto->pfsenddata) (qdaemon, zdata, (size_t) 0, ! 744: qtrans->ilocal, qtrans->iremote, ! 745: qtrans->ipos); ! 746: usfree_send (qtrans); ! 747: return fret; ! 748: } ! 749: ! 750: /* A remote request to receive a file (meaning that we have to send a ! 751: file). The sequence of functions calls is as follows: ! 752: ! 753: fremote_rec_file_init (open file) --> fqueue_remote ! 754: fremote_rec_reply (send RY, call pffile) --> fqueue_send ! 755: send file ! 756: fsend_file_end (calls pffile) --> fqueue_receive ! 757: fsend_await_confirm (waits for CY) ! 758: */ ! 759: ! 760: boolean ! 761: fremote_rec_file_init (qdaemon, qcmd, iremote) ! 762: struct sdaemon *qdaemon; ! 763: struct scmd *qcmd; ! 764: int iremote; ! 765: { ! 766: const struct uuconf_system *qsys; ! 767: char *zfile; ! 768: long cbytes; ! 769: unsigned int imode; ! 770: openfile_t e; ! 771: struct ssendinfo *qinfo; ! 772: struct stransfer *qtrans; ! 773: ! 774: qsys = qdaemon->qsys; ! 775: ! 776: if (! qsys->uuconf_fsend_request) ! 777: { ! 778: ulog (LOG_ERROR, "%s: not permitted to send files to remote", ! 779: qcmd->zfrom); ! 780: return fremote_rec_fail (qdaemon, FAILURE_PERM, iremote); ! 781: } ! 782: ! 783: if (fspool_file (qcmd->zfrom)) ! 784: { ! 785: ulog (LOG_ERROR, "%s: not permitted to send", qcmd->zfrom); ! 786: return fremote_rec_fail (qdaemon, FAILURE_PERM, iremote); ! 787: } ! 788: ! 789: zfile = zsysdep_local_file (qcmd->zfrom, qsys->uuconf_zpubdir); ! 790: if (zfile != NULL) ! 791: { ! 792: char *zbased; ! 793: ! 794: zbased = zsysdep_add_base (zfile, qcmd->zto); ! 795: ubuffree (zfile); ! 796: zfile = zbased; ! 797: } ! 798: if (zfile == NULL) ! 799: return fremote_rec_fail (qdaemon, FAILURE_PERM, iremote); ! 800: ! 801: if (! fin_directory_list (zfile, qsys->uuconf_pzremote_send, ! 802: qsys->uuconf_zpubdir, TRUE, TRUE, ! 803: (const char *) NULL)) ! 804: { ! 805: ulog (LOG_ERROR, "%s: not permitted to send", zfile); ! 806: ubuffree (zfile); ! 807: return fremote_rec_fail (qdaemon, FAILURE_PERM, iremote); ! 808: } ! 809: ! 810: /* If the file is larger than the amount of space the other side ! 811: reported, we can't send it. Should we adjust this check based on ! 812: the restart position? */ ! 813: cbytes = csysdep_size (zfile); ! 814: if (cbytes != -1 ! 815: && ((qcmd->cbytes != -1 && qcmd->cbytes < cbytes) ! 816: || (qdaemon->cremote_size != -1 ! 817: && qdaemon->cremote_size < cbytes) ! 818: || (qdaemon->cmax_receive != -1 ! 819: && qdaemon->cmax_receive < cbytes))) ! 820: { ! 821: ulog (LOG_ERROR, "%s: too large to send", zfile); ! 822: ubuffree (zfile); ! 823: return fremote_rec_fail (qdaemon, FAILURE_SIZE, iremote); ! 824: } ! 825: ! 826: imode = ixsysdep_file_mode (zfile); ! 827: ! 828: e = esysdep_open_send (qsys, zfile, TRUE, (const char *) NULL); ! 829: if (! ffileisopen (e)) ! 830: { ! 831: ubuffree (zfile); ! 832: return fremote_rec_fail (qdaemon, FAILURE_OPEN, iremote); ! 833: } ! 834: ! 835: /* If the remote requested that the file send start from a ! 836: particular position, arrange to do so. */ ! 837: if (qcmd->ipos > 0) ! 838: { ! 839: if (! ffileseek (e, qcmd->ipos)) ! 840: { ! 841: ulog (LOG_ERROR, "seek: %s", strerror (errno)); ! 842: ubuffree (zfile); ! 843: return FALSE; ! 844: } ! 845: } ! 846: ! 847: qinfo = (struct ssendinfo *) xmalloc (sizeof (struct ssendinfo)); ! 848: qinfo->zmail = NULL; ! 849: qinfo->zfile = zfile; ! 850: qinfo->cbytes = cbytes; ! 851: qinfo->flocal = FALSE; ! 852: qinfo->fspool = FALSE; ! 853: qinfo->fsent = FALSE; ! 854: qinfo->zexec = NULL; ! 855: ! 856: qtrans = qtransalc (qcmd); ! 857: qtrans->psendfn = fremote_rec_reply; ! 858: qtrans->iremote = iremote; ! 859: qtrans->pinfo = (pointer) qinfo; ! 860: qtrans->e = e; ! 861: qtrans->ipos = qcmd->ipos; ! 862: qtrans->s.imode = imode; ! 863: ! 864: return fqueue_remote (qdaemon, qtrans); ! 865: } ! 866: ! 867: /* Reply to a receive request from the remote system, and prepare to ! 868: start sending the file. */ ! 869: ! 870: static boolean ! 871: fremote_rec_reply (qtrans, qdaemon) ! 872: struct stransfer *qtrans; ! 873: struct sdaemon *qdaemon; ! 874: { ! 875: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 876: char absend[50]; ! 877: ! 878: sprintf (absend, "RY 0%o 0x%lx", qtrans->s.imode, ! 879: (unsigned long) qinfo->cbytes); ! 880: if (! (*qdaemon->qproto->pfsendcmd) (qdaemon, absend, qtrans->ilocal, ! 881: qtrans->iremote)) ! 882: { ! 883: (void) ffileclose (qtrans->e); ! 884: usfree_send (qtrans); ! 885: return FALSE; ! 886: } ! 887: ! 888: qtrans->zlog = zbufalc (sizeof "Sending " + strlen (qtrans->s.zfrom)); ! 889: sprintf (qtrans->zlog, "Sending %s", qtrans->s.zfrom); ! 890: ! 891: if (qdaemon->qproto->pffile != NULL) ! 892: { ! 893: boolean fhandled; ! 894: ! 895: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, TRUE, TRUE, ! 896: qinfo->cbytes, &fhandled)) ! 897: { ! 898: usfree_send (qtrans); ! 899: return FALSE; ! 900: } ! 901: ! 902: if (fhandled) ! 903: return TRUE; ! 904: } ! 905: ! 906: qtrans->fsendfile = TRUE; ! 907: qtrans->psendfn = fsend_file_end; ! 908: qtrans->precfn = fsend_await_confirm; ! 909: ! 910: return fqueue_send (qdaemon, qtrans); ! 911: } ! 912: ! 913: /* If we can't send a file as requested by the remote system, queue up ! 914: a failure reply which will be sent when possible. */ ! 915: ! 916: static boolean ! 917: fremote_rec_fail (qdaemon, twhy, iremote) ! 918: struct sdaemon *qdaemon; ! 919: enum tfailure twhy; ! 920: int iremote; ! 921: { ! 922: enum tfailure *ptinfo; ! 923: struct stransfer *qtrans; ! 924: ! 925: ptinfo = (enum tfailure *) xmalloc (sizeof (enum tfailure)); ! 926: *ptinfo = twhy; ! 927: ! 928: qtrans = qtransalc ((struct scmd *) NULL); ! 929: qtrans->psendfn = fremote_rec_fail_send; ! 930: qtrans->iremote = iremote; ! 931: qtrans->pinfo = (pointer) ptinfo; ! 932: ! 933: return fqueue_remote (qdaemon, qtrans); ! 934: } ! 935: ! 936: /* Send a failure string for a receive command to the remote system; ! 937: this is called when we are ready to reply to the command. */ ! 938: ! 939: static boolean ! 940: fremote_rec_fail_send (qtrans, qdaemon) ! 941: struct stransfer *qtrans; ! 942: struct sdaemon *qdaemon; ! 943: { ! 944: enum tfailure *ptinfo = (enum tfailure *) qtrans->pinfo; ! 945: const char *z; ! 946: boolean fret; ! 947: ! 948: switch (*ptinfo) ! 949: { ! 950: case FAILURE_PERM: ! 951: case FAILURE_OPEN: ! 952: z = "RN2"; ! 953: break; ! 954: case FAILURE_SIZE: ! 955: z = "RN6"; ! 956: break; ! 957: default: ! 958: z = "RN"; ! 959: break; ! 960: } ! 961: ! 962: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, z, qtrans->ilocal, ! 963: qtrans->iremote); ! 964: xfree (qtrans->pinfo); ! 965: utransfree (qtrans); ! 966: return fret; ! 967: } ! 968: ! 969: /* This is called when the main loop has finished sending a file. It ! 970: prepares to wait for a response from the remote system. Note that ! 971: if this is a local request and the protocol supports multiple ! 972: channels, we may not even have received a confirmation of the send ! 973: request. */ ! 974: ! 975: static boolean ! 976: fsend_file_end (qtrans, qdaemon) ! 977: struct stransfer *qtrans; ! 978: struct sdaemon *qdaemon; ! 979: { ! 980: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 981: ! 982: if (qdaemon->qproto->pffile != NULL) ! 983: { ! 984: boolean fhandled; ! 985: ! 986: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, FALSE, TRUE, ! 987: (long) -1, &fhandled)) ! 988: { ! 989: usfree_send (qtrans); ! 990: return FALSE; ! 991: } ! 992: ! 993: if (fhandled) ! 994: return TRUE; ! 995: } ! 996: ! 997: qinfo->fsent = TRUE; ! 998: ! 999: /* qtrans->precfn should have been set by a previous function. */ ! 1000: qtrans->fcmd = TRUE; ! 1001: return fqueue_receive (qdaemon, qtrans); ! 1002: } ! 1003: ! 1004: /* Handle the confirmation string received after sending a file. */ ! 1005: ! 1006: /*ARGSUSED*/ ! 1007: static boolean ! 1008: fsend_await_confirm (qtrans, qdaemon, zdata, cdata) ! 1009: struct stransfer *qtrans; ! 1010: struct sdaemon *qdaemon; ! 1011: const char *zdata; ! 1012: size_t cdata; ! 1013: { ! 1014: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 1015: boolean fnever; ! 1016: const char *zerr; ! 1017: ! 1018: if (qinfo->zexec == NULL) ! 1019: (void) ffileclose (qtrans->e); ! 1020: ! 1021: fnever = FALSE; ! 1022: if (zdata[0] != 'C' ! 1023: || (zdata[1] != 'Y' && zdata[1] != 'N')) ! 1024: { ! 1025: zerr = "bad confirmation from remote"; ! 1026: ulog (LOG_ERROR, "%s: %s \"%s\"", qtrans->s.zfrom, zerr, zdata); ! 1027: } ! 1028: else if (zdata[1] == 'N') ! 1029: { ! 1030: fnever = TRUE; ! 1031: if (zdata[2] == '5') ! 1032: { ! 1033: zerr = "file could not be stored in final location"; ! 1034: ulog (LOG_ERROR, "%s: %s", qtrans->s.zfrom, zerr); ! 1035: } ! 1036: else ! 1037: { ! 1038: zerr = "file send failed for unknown reason"; ! 1039: ulog (LOG_ERROR, "%s: %s \"%s\"", qtrans->s.zfrom, zerr, zdata); ! 1040: } ! 1041: } ! 1042: else ! 1043: { ! 1044: zerr = NULL; ! 1045: ! 1046: /* If we receive CYM, it means that the other side wants us to ! 1047: hang up so that they can send us something. The ! 1048: fhangup_requested field is checked in the main loop. */ ! 1049: if (zdata[2] == 'M' && qdaemon->fmaster) ! 1050: { ! 1051: DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO, ! 1052: "fsend_await_confirm: Remote has requested transfer of control"); ! 1053: qdaemon->fhangup_requested = TRUE; ! 1054: } ! 1055: } ! 1056: ! 1057: ustats (zerr == NULL, qtrans->s.zuser, qdaemon->qsys->uuconf_zname, ! 1058: TRUE, qtrans->cbytes, qtrans->isecs, qtrans->imicros, ! 1059: qdaemon->fmaster); ! 1060: ! 1061: if (zerr == NULL) ! 1062: { ! 1063: /* If this is an execution request, and the remote system ! 1064: doesn't support execution requests, we have to set up the ! 1065: fake execution file and loop around again. */ ! 1066: if (qtrans->s.bcmd == 'E' ! 1067: && (qdaemon->ifeatures & FEATURE_EXEC) == 0 ! 1068: && qinfo->zexec == NULL) ! 1069: return fsend_exec_file_init (qtrans, qdaemon); ! 1070: ! 1071: /* Send mail about the transfer if requested. */ ! 1072: if (qinfo->zmail != NULL && *qinfo->zmail != '\0') ! 1073: (void) fmail_transfer (TRUE, qtrans->s.zuser, qinfo->zmail, ! 1074: (const char *) NULL, ! 1075: qtrans->s.zfrom, (const char *) NULL, ! 1076: qtrans->s.zto, qdaemon->qsys->uuconf_zname, ! 1077: (const char *) NULL); ! 1078: ! 1079: if (qtrans->s.pseq != NULL) ! 1080: (void) fsysdep_did_work (qtrans->s.pseq); ! 1081: } ! 1082: else ! 1083: { ! 1084: /* If the file send failed, we only try to save the file and ! 1085: send mail if it was requested locally and it will never ! 1086: succeed. We send mail to qinfo->zmail if set, otherwise to ! 1087: qtrans->s.zuser. I hope this is reasonable. */ ! 1088: if (fnever && qinfo->flocal) ! 1089: { ! 1090: (void) fmail_transfer (FALSE, qtrans->s.zuser, qinfo->zmail, ! 1091: zerr, qtrans->s.zfrom, (const char *) NULL, ! 1092: qtrans->s.zto, qdaemon->qsys->uuconf_zname, ! 1093: zsysdep_save_temp_file (qtrans->s.pseq)); ! 1094: (void) fsysdep_did_work (qtrans->s.pseq); ! 1095: } ! 1096: } ! 1097: ! 1098: usfree_send (qtrans); ! 1099: ! 1100: return TRUE; ! 1101: } ! 1102: ! 1103: /* Prepare to send an execution file to a system which does not ! 1104: support execution requests. We build the execution file in memory, ! 1105: and then call flocal_send_request as though we were sending a real ! 1106: file. Instead of sending a file, the code in flocal_send_open_file ! 1107: will arrange to call fsend_exec_file which will send data out of ! 1108: the buffer we have created. */ ! 1109: ! 1110: static boolean ! 1111: fsend_exec_file_init (qtrans, qdaemon) ! 1112: struct stransfer *qtrans; ! 1113: struct sdaemon *qdaemon; ! 1114: { ! 1115: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 1116: char *zxqtfile; ! 1117: char abtname[CFILE_NAME_LEN]; ! 1118: char abxname[CFILE_NAME_LEN]; ! 1119: char *z; ! 1120: size_t calc, clen; ! 1121: ! 1122: z = NULL; ! 1123: calc = 0; ! 1124: clen = 0; ! 1125: ! 1126: usadd_exec_line (&z, &calc, &clen, 'U', qtrans->s.zuser, ! 1127: qdaemon->zlocalname); ! 1128: usadd_exec_line (&z, &calc, &clen, 'F', qtrans->s.zto, ""); ! 1129: usadd_exec_line (&z, &calc, &clen, 'I', qtrans->s.zto, ""); ! 1130: if (strchr (qtrans->s.zoptions, 'N') != NULL) ! 1131: usadd_exec_line (&z, &calc, &clen, 'N', "", ""); ! 1132: if (strchr (qtrans->s.zoptions, 'Z') != NULL) ! 1133: usadd_exec_line (&z, &calc, &clen, 'Z', "", ""); ! 1134: if (strchr (qtrans->s.zoptions, 'R') != NULL) ! 1135: usadd_exec_line (&z, &calc, &clen, 'R', qtrans->s.znotify, ""); ! 1136: if (strchr (qtrans->s.zoptions, 'e') != NULL) ! 1137: usadd_exec_line (&z, &calc, &clen, 'e', "", ""); ! 1138: usadd_exec_line (&z, &calc, &clen, 'C', qtrans->s.zcmd, ""); ! 1139: ! 1140: qinfo->zexec = z; ! 1141: qinfo->cbytes = clen; ! 1142: ! 1143: zxqtfile = zsysdep_data_file_name (qdaemon->qsys, qdaemon->zlocalname, ! 1144: BDEFAULT_UUX_GRADE, TRUE, abtname, ! 1145: (char *) NULL, abxname); ! 1146: if (zxqtfile == NULL) ! 1147: { ! 1148: usfree_send (qtrans); ! 1149: return FALSE; ! 1150: } ! 1151: ubuffree (zxqtfile); ! 1152: ! 1153: ubuffree ((char *) qtrans->s.zfrom); ! 1154: qtrans->s.zfrom = zbufcpy (abtname); ! 1155: ubuffree ((char *) qtrans->s.zto); ! 1156: qtrans->s.zto = zbufcpy (abxname); ! 1157: ubuffree ((char *) qtrans->s.zoptions); ! 1158: qtrans->s.zoptions = zbufcpy ("C"); ! 1159: ubuffree ((char *) qtrans->s.ztemp); ! 1160: qtrans->s.ztemp = zbufcpy (abtname); ! 1161: ! 1162: qtrans->psendfn = flocal_send_request; ! 1163: qtrans->precfn = NULL; ! 1164: qtrans->ipos = 0; ! 1165: qtrans->cbytes = 0; ! 1166: qtrans->isecs = 0; ! 1167: qtrans->imicros = 0; ! 1168: qinfo->fsent = FALSE; ! 1169: ! 1170: return fqueue_send (qdaemon, qtrans); ! 1171: } ! 1172: ! 1173: /* Add a line to the fake execution file. */ ! 1174: ! 1175: static void ! 1176: usadd_exec_line (pz, pcalc, pclen, bcmd, z1, z2) ! 1177: char **pz; ! 1178: size_t *pcalc; ! 1179: size_t *pclen; ! 1180: int bcmd; ! 1181: const char *z1; ! 1182: const char *z2; ! 1183: { ! 1184: size_t c1, c2; ! 1185: char *znew; ! 1186: ! 1187: c1 = strlen (z1); ! 1188: c2 = strlen (z2); ! 1189: ! 1190: if (*pclen + c1 + c2 + 4 >= *pcalc) ! 1191: { ! 1192: *pcalc += c1 + c2 + 100; ! 1193: znew = zbufalc (*pcalc); ! 1194: if (*pclen > 0) ! 1195: { ! 1196: memcpy (znew, *pz, *pclen); ! 1197: ubuffree (*pz); ! 1198: } ! 1199: *pz = znew; ! 1200: } ! 1201: ! 1202: znew = *pz + *pclen; ! 1203: *znew++ = bcmd; ! 1204: if (*z1 != '\0') ! 1205: { ! 1206: *znew++ = ' '; ! 1207: memcpy (znew, z1, c1); ! 1208: znew += c1; ! 1209: if (*z2 != '\0') ! 1210: { ! 1211: *znew++ = ' '; ! 1212: memcpy (znew, z2, c2); ! 1213: znew += c2; ! 1214: } ! 1215: } ! 1216: ! 1217: /* In some bizarre non-Unix case we might have to worry about the ! 1218: newline here. We don't know how a newline is normally written ! 1219: out to a file, but whatever is written to a file is what we will ! 1220: normally transfer. If that is not simply \n then this fake ! 1221: execution file will not look like other execution files. */ ! 1222: *znew++ = '\n'; ! 1223: ! 1224: *pclen = znew - *pz; ! 1225: } ! 1226: ! 1227: /* This routine is called to send the contents of the fake execution ! 1228: file. Normally file data is sent by the floop routine in trans.c, ! 1229: but since we don't have an actual file we must do it here. This ! 1230: routine sends the complete buffer, followed by a zero length ! 1231: packet, and then calls fsend_file_end. */ ! 1232: ! 1233: static boolean ! 1234: fsend_exec_file (qtrans, qdaemon) ! 1235: struct stransfer *qtrans; ! 1236: struct sdaemon *qdaemon; ! 1237: { ! 1238: struct ssendinfo *qinfo = (struct ssendinfo *) qtrans->pinfo; ! 1239: char *zdata; ! 1240: size_t cdata; ! 1241: size_t csend; ! 1242: ! 1243: zdata = (*qdaemon->qproto->pzgetspace) (qdaemon, &cdata); ! 1244: if (zdata == NULL) ! 1245: { ! 1246: usfree_send (qtrans); ! 1247: return FALSE; ! 1248: } ! 1249: ! 1250: csend = qinfo->cbytes - qtrans->ipos; ! 1251: if (csend > cdata) ! 1252: csend = cdata; ! 1253: ! 1254: memcpy (zdata, qinfo->zexec + qtrans->ipos, csend); ! 1255: ! 1256: if (! (*qdaemon->qproto->pfsenddata) (qdaemon, zdata, csend, ! 1257: qtrans->ilocal, qtrans->iremote, ! 1258: qtrans->ipos)) ! 1259: { ! 1260: usfree_send (qtrans); ! 1261: return FALSE; ! 1262: } ! 1263: ! 1264: qtrans->cbytes += csend; ! 1265: qtrans->ipos += csend; ! 1266: ! 1267: if (csend == 0) ! 1268: return fsend_file_end (qtrans, qdaemon); ! 1269: ! 1270: /* Leave the job on the send queue. */ ! 1271: ! 1272: return TRUE; ! 1273: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.