… | |
… | |
54 | #else |
54 | #else |
55 | #define SEEK_SET 0 |
55 | #define SEEK_SET 0 |
56 | #endif |
56 | #endif |
57 | #endif |
57 | #endif |
58 | |
58 | |
59 | char * uuencode_id = "$Id: uuencode.c,v 1.2 2001/06/11 20:42:37 root Exp $"; |
59 | char * uuencode_id = "$Id: uuencode.c,v 1.3 2002/03/31 20:04:30 root Exp $"; |
60 | |
60 | |
61 | #if 0 |
61 | #if 0 |
62 | /* |
62 | /* |
63 | * the End-Of-Line string. MIME enforces CRLF, so that's what we use. Some |
63 | * the End-Of-Line string. MIME enforces CRLF, so that's what we use. Some |
64 | * implementations of uudecode will complain about a missing end line, since |
64 | * implementations of uudecode will complain about a missing end line, since |
… | |
… | |
108 | */ |
108 | */ |
109 | |
109 | |
110 | #define CTE_UUENC "x-uuencode" |
110 | #define CTE_UUENC "x-uuencode" |
111 | #define CTE_XXENC "x-xxencode" |
111 | #define CTE_XXENC "x-xxencode" |
112 | #define CTE_BINHEX "x-binhex" |
112 | #define CTE_BINHEX "x-binhex" |
|
|
113 | #define CTE_YENC "x-yenc" |
113 | |
114 | |
114 | #define CTE_TYPE(y) (((y)==B64ENCODED) ? "Base64" : \ |
115 | #define CTE_TYPE(y) (((y)==B64ENCODED) ? "Base64" : \ |
115 | ((y)==UU_ENCODED) ? CTE_UUENC : \ |
116 | ((y)==UU_ENCODED) ? CTE_UUENC : \ |
116 | ((y)==XX_ENCODED) ? CTE_XXENC : \ |
117 | ((y)==XX_ENCODED) ? CTE_XXENC : \ |
117 | ((y)==PT_ENCODED) ? "8bit" : \ |
118 | ((y)==PT_ENCODED) ? "8bit" : \ |
118 | ((y)==QP_ENCODED) ? "quoted-printable" : \ |
119 | ((y)==QP_ENCODED) ? "quoted-printable" : \ |
119 | ((y)==BH_ENCODED) ? CTE_BINHEX : "x-oops") |
120 | ((y)==BH_ENCODED) ? CTE_BINHEX : \ |
|
|
121 | ((y)==YENC_ENCODED) ? CTE_YENC : "x-oops") |
120 | |
122 | |
121 | /* |
123 | /* |
122 | * encoding tables |
124 | * encoding tables |
123 | */ |
125 | */ |
124 | |
126 | |
… | |
… | |
212 | |
214 | |
213 | /* |
215 | /* |
214 | * encoded bytes per line |
216 | * encoded bytes per line |
215 | */ |
217 | */ |
216 | |
218 | |
217 | static int bpl[5] = { 0, 45, 57, 45, 45 }; |
219 | static int bpl[8] = { 0, 45, 57, 45, 45, 0, 0, 128 }; |
218 | |
220 | |
219 | /* |
221 | /* |
220 | * tables |
222 | * tables |
221 | */ |
223 | */ |
222 | |
224 | |
… | |
… | |
249 | long line=0; |
251 | long line=0; |
250 | size_t llen; |
252 | size_t llen; |
251 | |
253 | |
252 | if (outfile==NULL || infile==NULL || |
254 | if (outfile==NULL || infile==NULL || |
253 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
255 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
254 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
256 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
255 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
257 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
256 | uustring (S_PARM_CHECK), "UUEncodeStream()"); |
258 | uustring (S_PARM_CHECK), "UUEncodeStream()"); |
257 | return UURET_ILLVAL; |
259 | return UURET_ILLVAL; |
258 | } |
260 | } |
259 | |
261 | |
… | |
… | |
375 | * line break. |
377 | * line break. |
376 | */ |
378 | */ |
377 | |
379 | |
378 | if (itemp[index+1] != 0 && itemp[index+1] != '\n' && |
380 | if (itemp[index+1] != 0 && itemp[index+1] != '\n' && |
379 | (llen >= 75 || |
381 | (llen >= 75 || |
380 | !((itemp[index+1] >= 33 && itemp[index+1] <= 60) || |
382 | (!((itemp[index+1] >= 33 && itemp[index+1] <= 60) || |
381 | (itemp[index+1] >= 62 && itemp[index+1] <= 126)) && |
383 | (itemp[index+1] >= 62 && itemp[index+1] <= 126)) && |
382 | llen >= 73)) { |
384 | llen >= 73))) { |
383 | |
385 | |
384 | *optr++ = '='; |
386 | *optr++ = '='; |
385 | llen++; |
387 | llen++; |
386 | |
388 | |
387 | if (fwrite (otemp, 1, llen, outfile) != llen || |
389 | if (fwrite (otemp, 1, llen, outfile) != llen || |
… | |
… | |
401 | |
403 | |
402 | return UURET_OK; |
404 | return UURET_OK; |
403 | } |
405 | } |
404 | |
406 | |
405 | /* |
407 | /* |
|
|
408 | * Special handling for yEnc |
|
|
409 | */ |
|
|
410 | |
|
|
411 | if (encoding == YENC_ENCODED) { |
|
|
412 | llen = 0; |
|
|
413 | optr = otemp; |
|
|
414 | |
|
|
415 | while (!feof (infile) && (linperfile <= 0 || line < linperfile)) { |
|
|
416 | if ((count = fread (itemp, 1, 128, infile)) != 128) { |
|
|
417 | if (count == 0) { |
|
|
418 | break; |
|
|
419 | } |
|
|
420 | else if (ferror (infile)) { |
|
|
421 | return UURET_IOERR; |
|
|
422 | } |
|
|
423 | } |
|
|
424 | |
|
|
425 | line++; |
|
|
426 | |
|
|
427 | /* |
|
|
428 | * Busy Callback |
|
|
429 | */ |
|
|
430 | |
|
|
431 | if (UUBUSYPOLL(ftell(infile)-progress.foffset,progress.fsize)) { |
|
|
432 | UUMessage (uuencode_id, __LINE__, UUMSG_NOTE, |
|
|
433 | uustring (S_ENCODE_CANCEL)); |
|
|
434 | return UURET_CANCEL; |
|
|
435 | } |
|
|
436 | |
|
|
437 | for (index=0; index<count; index++) { |
|
|
438 | if (llen > 127) { |
|
|
439 | if (fwrite (otemp, 1, llen, outfile) != llen || |
|
|
440 | fwrite ((char *) eolstring, 1, |
|
|
441 | strlen(eolstring), outfile) != strlen (eolstring)) { |
|
|
442 | return UURET_IOERR; |
|
|
443 | } |
|
|
444 | llen = 0; |
|
|
445 | optr = otemp; |
|
|
446 | } |
|
|
447 | |
|
|
448 | switch ((char) ((int) itemp[index] + 42)) { |
|
|
449 | case '\0': |
|
|
450 | case '\t': |
|
|
451 | case '\n': |
|
|
452 | case '\r': |
|
|
453 | case '=': |
|
|
454 | case '\033': |
|
|
455 | *optr++ = '='; |
|
|
456 | *optr++ = (char) ((int) itemp[index] + 42 + 64); |
|
|
457 | llen += 2; |
|
|
458 | break; |
|
|
459 | |
|
|
460 | case '.': |
|
|
461 | if (llen == 0) { |
|
|
462 | *optr++ = '='; |
|
|
463 | *optr++ = (char) ((int) itemp[index] + 42 + 64); |
|
|
464 | llen += 2; |
|
|
465 | } |
|
|
466 | else { |
|
|
467 | *optr++ = (char) ((int) itemp[index] + 42); |
|
|
468 | llen++; |
|
|
469 | } |
|
|
470 | break; |
|
|
471 | |
|
|
472 | default: |
|
|
473 | *optr++ = (char) ((int) itemp[index] + 42); |
|
|
474 | llen++; |
|
|
475 | break; |
|
|
476 | } |
|
|
477 | } |
|
|
478 | } |
|
|
479 | |
|
|
480 | /* |
|
|
481 | * write last line |
|
|
482 | */ |
|
|
483 | |
|
|
484 | if (llen) { |
|
|
485 | if (fwrite (otemp, 1, llen, outfile) != llen || |
|
|
486 | fwrite ((char *) eolstring, 1, |
|
|
487 | strlen(eolstring), outfile) != strlen (eolstring)) { |
|
|
488 | return UURET_IOERR; |
|
|
489 | } |
|
|
490 | } |
|
|
491 | |
|
|
492 | return UURET_OK; |
|
|
493 | } |
|
|
494 | |
|
|
495 | /* |
406 | * Handling for binary encodings |
496 | * Handling for binary encodings |
407 | */ |
497 | */ |
408 | |
498 | |
409 | /* |
499 | /* |
410 | * select charset |
500 | * select charset |
… | |
… | |
450 | |
540 | |
451 | /* |
541 | /* |
452 | * Main encoding |
542 | * Main encoding |
453 | */ |
543 | */ |
454 | |
544 | |
455 | if (encoding == UU_ENCODED || encoding == XX_ENCODED || |
|
|
456 | encoding == B64ENCODED) { |
|
|
457 | for (index=0; index<=count-3; index+=3, llen+=4) { |
545 | for (index=0; index<=count-3; index+=3, llen+=4) { |
458 | *optr++ = table[itemp[index] >> 2]; |
546 | *optr++ = table[itemp[index] >> 2]; |
459 | *optr++ = table[((itemp[index ] & 0x03) << 4)|(itemp[index+1] >> 4)]; |
547 | *optr++ = table[((itemp[index ] & 0x03) << 4)|(itemp[index+1] >> 4)]; |
460 | *optr++ = table[((itemp[index+1] & 0x0f) << 2)|(itemp[index+2] >> 6)]; |
548 | *optr++ = table[((itemp[index+1] & 0x0f) << 2)|(itemp[index+2] >> 6)]; |
461 | *optr++ = table[ itemp[index+2] & 0x3f]; |
549 | *optr++ = table[ itemp[index+2] & 0x3f]; |
462 | } |
|
|
463 | } |
550 | } |
464 | |
551 | |
465 | /* |
552 | /* |
466 | * Special handling for incomplete lines |
553 | * Special handling for incomplete lines |
467 | */ |
554 | */ |
… | |
… | |
537 | |
624 | |
538 | if (outfile==NULL || |
625 | if (outfile==NULL || |
539 | (infile == NULL && infname==NULL) || |
626 | (infile == NULL && infname==NULL) || |
540 | (outfname==NULL && infname==NULL) || |
627 | (outfname==NULL && infname==NULL) || |
541 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
628 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
542 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
629 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
543 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
630 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
544 | uustring (S_PARM_CHECK), "UUEncodeMulti()"); |
631 | uustring (S_PARM_CHECK), "UUEncodeMulti()"); |
545 | return UURET_ILLVAL; |
632 | return UURET_ILLVAL; |
546 | } |
633 | } |
547 | |
634 | |
… | |
… | |
606 | |
693 | |
607 | /* |
694 | /* |
608 | * print sub-header |
695 | * print sub-header |
609 | */ |
696 | */ |
610 | |
697 | |
|
|
698 | if (encoding != YENC_ENCODED) { |
611 | fprintf (outfile, "Content-Type: %s%s", |
699 | fprintf (outfile, "Content-Type: %s%s", |
612 | (mimetype)?mimetype:"Application/Octet-Stream", |
700 | (mimetype)?mimetype:"Application/Octet-Stream", |
613 | eolstring); |
701 | eolstring); |
614 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
702 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
615 | CTE_TYPE(encoding), eolstring); |
703 | CTE_TYPE(encoding), eolstring); |
616 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
704 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
617 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
705 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
618 | fprintf (outfile, "%s", eolstring); |
706 | fprintf (outfile, "%s", eolstring); |
|
|
707 | } |
619 | |
708 | |
620 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
709 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
621 | fprintf (outfile, "begin %o %s%s", |
710 | fprintf (outfile, "begin %o %s%s", |
622 | (themode) ? themode : 0644, |
711 | (themode) ? themode : 0644, |
623 | UUFNameFilter ((outfname)?outfname:infname), |
712 | UUFNameFilter ((outfname)?outfname:infname), |
624 | eolstring); |
713 | eolstring); |
625 | } |
714 | } |
|
|
715 | else if (encoding == YENC_ENCODED) { |
|
|
716 | if (progress.fsize == -1) { |
|
|
717 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
718 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
719 | eolstring); |
|
|
720 | } |
|
|
721 | else { |
|
|
722 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
723 | progress.fsize, |
|
|
724 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
725 | eolstring); |
|
|
726 | } |
|
|
727 | } |
|
|
728 | |
626 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
729 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
627 | if (res != UURET_CANCEL) { |
730 | if (res != UURET_CANCEL) { |
628 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
731 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
629 | uustring (S_ERR_ENCODING), |
732 | uustring (S_ERR_ENCODING), |
630 | UUFNameFilter ((infname)?infname:outfname), |
733 | UUFNameFilter ((infname)?infname:outfname), |
631 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror(res)); |
734 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror(res)); |
632 | } |
735 | } |
633 | progress.action = 0; |
736 | progress.action = 0; |
634 | return res; |
737 | return res; |
635 | } |
738 | } |
|
|
739 | |
636 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
740 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
637 | fprintf (outfile, "%c%s", |
741 | fprintf (outfile, "%c%s", |
638 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
742 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
639 | eolstring); |
743 | eolstring); |
640 | fprintf (outfile, "end%s", eolstring); |
744 | fprintf (outfile, "end%s", eolstring); |
641 | } |
745 | } |
|
|
746 | else if (encoding == YENC_ENCODED) { |
|
|
747 | if (progress.fsize == -1) { |
|
|
748 | fprintf (outfile, "=yend%s", |
|
|
749 | eolstring); |
|
|
750 | } |
|
|
751 | else { |
|
|
752 | fprintf (outfile, "=yend size=%ld%s", |
|
|
753 | progress.fsize, |
|
|
754 | eolstring); |
|
|
755 | } |
|
|
756 | } |
|
|
757 | |
642 | /* |
758 | /* |
643 | * empty line at end does no harm |
759 | * empty line at end does no harm |
644 | */ |
760 | */ |
|
|
761 | |
645 | fprintf (outfile, "%s", eolstring); |
762 | fprintf (outfile, "%s", eolstring); |
646 | |
763 | |
647 | if (infile==NULL) |
764 | if (infile==NULL) |
648 | fclose (theifile); |
765 | fclose (theifile); |
649 | |
766 | |
… | |
… | |
670 | int res; |
787 | int res; |
671 | |
788 | |
672 | if ((outfname==NULL&&infname==NULL) || partno<=0 || |
789 | if ((outfname==NULL&&infname==NULL) || partno<=0 || |
673 | (infile == NULL&&infname==NULL) || outfile==NULL || |
790 | (infile == NULL&&infname==NULL) || outfile==NULL || |
674 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
791 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
675 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
792 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
676 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
793 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
677 | uustring (S_PARM_CHECK), "UUEncodePartial()"); |
794 | uustring (S_PARM_CHECK), "UUEncodePartial()"); |
678 | return UURET_ILLVAL; |
795 | return UURET_ILLVAL; |
679 | } |
796 | } |
680 | |
797 | |
… | |
… | |
756 | |
873 | |
757 | /* |
874 | /* |
758 | * print sub-header |
875 | * print sub-header |
759 | */ |
876 | */ |
760 | |
877 | |
|
|
878 | if (encoding != YENC_ENCODED) { |
761 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
879 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
762 | fprintf (outfile, "Content-Type: %s%s", |
880 | fprintf (outfile, "Content-Type: %s%s", |
763 | (mimetype)?mimetype:"Application/Octet-Stream", |
881 | (mimetype)?mimetype:"Application/Octet-Stream", |
764 | eolstring); |
882 | eolstring); |
765 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
883 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
766 | CTE_TYPE(encoding), eolstring); |
884 | CTE_TYPE(encoding), eolstring); |
767 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
885 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
768 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
886 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
|
|
887 | } |
|
|
888 | |
769 | fprintf (outfile, "%s", eolstring); |
889 | fprintf (outfile, "%s", eolstring); |
770 | |
890 | |
771 | /* |
891 | /* |
772 | * for the first part of UU or XX messages, print a begin line |
892 | * for the first part of UU or XX messages, print a begin line |
773 | */ |
893 | */ |
|
|
894 | |
774 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
895 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
775 | fprintf (outfile, "begin %o %s%s", |
896 | fprintf (outfile, "begin %o %s%s", |
776 | (themode) ? themode : ((filemode)?filemode:0644), |
897 | (themode) ? themode : ((filemode)?filemode:0644), |
777 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
898 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
|
|
899 | } |
|
|
900 | else if (encoding == YENC_ENCODED) { |
|
|
901 | if (numparts != 1) { |
|
|
902 | if (progress.totsize == -1) { |
|
|
903 | fprintf (outfile, "=ybegin part=%d line=128 name=%s%s", |
|
|
904 | partno, |
|
|
905 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
906 | eolstring); |
|
|
907 | } |
|
|
908 | else { |
|
|
909 | fprintf (outfile, "=ybegin part=%d line=128 size=%ld name=%s%s", |
|
|
910 | partno, |
|
|
911 | progress.totsize, |
|
|
912 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
913 | eolstring); |
|
|
914 | } |
|
|
915 | |
|
|
916 | fprintf (outfile, "=ypart begin=%d end=%d%s", |
|
|
917 | (partno-1)*linperfile*128+1, |
|
|
918 | (partno*linperfile*128) < progress.totsize ? |
|
|
919 | (partno*linperfile*128) : progress.totsize, |
|
|
920 | eolstring); |
|
|
921 | } |
|
|
922 | else { |
|
|
923 | if (progress.totsize == -1) { |
|
|
924 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
925 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
926 | eolstring); |
|
|
927 | } |
|
|
928 | else { |
|
|
929 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
930 | progress.totsize, |
|
|
931 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
932 | eolstring); |
|
|
933 | } |
|
|
934 | } |
778 | } |
935 | } |
779 | } |
936 | } |
780 | |
937 | |
781 | /* |
938 | /* |
782 | * update progress information |
939 | * update progress information |
… | |
… | |
807 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
964 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
808 | } |
965 | } |
809 | progress.action = 0; |
966 | progress.action = 0; |
810 | return res; |
967 | return res; |
811 | } |
968 | } |
|
|
969 | |
812 | /* |
970 | /* |
813 | * print end line |
971 | * print end line |
814 | */ |
972 | */ |
|
|
973 | |
815 | if (feof (theifile) && |
974 | if (feof (theifile) && |
816 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
975 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
817 | fprintf (outfile, "%c%s", |
976 | fprintf (outfile, "%c%s", |
818 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
977 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
819 | eolstring); |
978 | eolstring); |
820 | fprintf (outfile, "end%s", eolstring); |
979 | fprintf (outfile, "end%s", eolstring); |
|
|
980 | } |
|
|
981 | else if (encoding == YENC_ENCODED) { |
|
|
982 | if (numparts != 1) { |
|
|
983 | fprintf (outfile, "=yend size=%d part=%d%s", |
|
|
984 | (partno*linperfile*128) < progress.totsize ? |
|
|
985 | linperfile*128 : (progress.totsize-(partno-1)*linperfile*128), |
|
|
986 | partno, |
|
|
987 | eolstring); |
|
|
988 | } |
|
|
989 | else { |
|
|
990 | fprintf (outfile, "=yend size=%d%s", |
|
|
991 | progress.totsize, |
|
|
992 | eolstring); |
|
|
993 | } |
821 | } |
994 | } |
822 | |
995 | |
823 | /* |
996 | /* |
824 | * empty line at end does no harm |
997 | * empty line at end does no harm |
825 | */ |
998 | */ |
… | |
… | |
865 | |
1038 | |
866 | if (outfile==NULL || |
1039 | if (outfile==NULL || |
867 | (infile == NULL&&infname==NULL) || |
1040 | (infile == NULL&&infname==NULL) || |
868 | (outfname==NULL&&infname==NULL) || |
1041 | (outfname==NULL&&infname==NULL) || |
869 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1042 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
870 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1043 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
871 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1044 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
872 | uustring (S_PARM_CHECK), "UUEncodeToStream()"); |
1045 | uustring (S_PARM_CHECK), "UUEncodeToStream()"); |
873 | return UURET_ILLVAL; |
1046 | return UURET_ILLVAL; |
874 | } |
1047 | } |
875 | |
1048 | |
… | |
… | |
919 | fprintf (outfile, "begin %o %s%s", |
1092 | fprintf (outfile, "begin %o %s%s", |
920 | (themode) ? themode : 0644, |
1093 | (themode) ? themode : 0644, |
921 | UUFNameFilter ((outfname)?outfname:infname), |
1094 | UUFNameFilter ((outfname)?outfname:infname), |
922 | eolstring); |
1095 | eolstring); |
923 | } |
1096 | } |
|
|
1097 | else if (encoding == YENC_ENCODED) { |
|
|
1098 | if (progress.fsize == -1) { |
|
|
1099 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
1100 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1101 | eolstring); |
|
|
1102 | } |
|
|
1103 | else { |
|
|
1104 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
1105 | progress.fsize, |
|
|
1106 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1107 | eolstring); |
|
|
1108 | } |
|
|
1109 | } |
|
|
1110 | |
924 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
1111 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
925 | if (res != UURET_CANCEL) { |
1112 | if (res != UURET_CANCEL) { |
926 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1113 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
927 | uustring (S_ERR_ENCODING), |
1114 | uustring (S_ERR_ENCODING), |
928 | UUFNameFilter ((infname)?infname:outfname), |
1115 | UUFNameFilter ((infname)?infname:outfname), |
929 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
1116 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
930 | } |
1117 | } |
931 | progress.action = 0; |
1118 | progress.action = 0; |
932 | return res; |
1119 | return res; |
933 | } |
1120 | } |
|
|
1121 | |
934 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
1122 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
935 | fprintf (outfile, "%c%s", |
1123 | fprintf (outfile, "%c%s", |
936 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1124 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
937 | eolstring); |
1125 | eolstring); |
938 | fprintf (outfile, "end%s", eolstring); |
1126 | fprintf (outfile, "end%s", eolstring); |
939 | } |
1127 | } |
|
|
1128 | else if (encoding == YENC_ENCODED) { |
|
|
1129 | if (progress.fsize == -1) { |
|
|
1130 | fprintf (outfile, "=yend%s", |
|
|
1131 | eolstring); |
|
|
1132 | } |
|
|
1133 | else { |
|
|
1134 | fprintf (outfile, "=yend size=%ld%s", |
|
|
1135 | progress.fsize, |
|
|
1136 | eolstring); |
|
|
1137 | } |
|
|
1138 | } |
|
|
1139 | |
940 | /* |
1140 | /* |
941 | * empty line at end does no harm |
1141 | * empty line at end does no harm |
942 | */ |
1142 | */ |
|
|
1143 | |
943 | fprintf (outfile, "%s", eolstring); |
1144 | fprintf (outfile, "%s", eolstring); |
944 | |
1145 | |
945 | if (infile==NULL) fclose (theifile); |
1146 | if (infile==NULL) fclose (theifile); |
946 | progress.action = 0; |
1147 | progress.action = 0; |
947 | |
1148 | |
… | |
… | |
962 | struct stat finfo; |
1163 | struct stat finfo; |
963 | |
1164 | |
964 | if ((diskname==NULL&&infname==NULL) || |
1165 | if ((diskname==NULL&&infname==NULL) || |
965 | (outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1166 | (outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
966 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1167 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
967 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1168 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
968 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1169 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
969 | uustring (S_PARM_CHECK), "UUEncodeToFile()"); |
1170 | uustring (S_PARM_CHECK), "UUEncodeToFile()"); |
970 | return UURET_ILLVAL; |
1171 | return UURET_ILLVAL; |
971 | } |
1172 | } |
972 | |
1173 | |
… | |
… | |
1130 | if (infile==NULL) fclose (theifile); |
1331 | if (infile==NULL) fclose (theifile); |
1131 | progress.action = 0; |
1332 | progress.action = 0; |
1132 | free (oname); |
1333 | free (oname); |
1133 | return UURET_IOERR; |
1334 | return UURET_IOERR; |
1134 | } |
1335 | } |
|
|
1336 | |
|
|
1337 | if (encoding != YENC_ENCODED) { |
1135 | fprintf (outfile, "%s", eolstring); |
1338 | fprintf (outfile, "%s", eolstring); |
1136 | fprintf (outfile, "_=_ %s", eolstring); |
1339 | fprintf (outfile, "_=_ %s", eolstring); |
1137 | if (numparts == -1) |
1340 | if (numparts == -1) |
1138 | fprintf (outfile, "_=_ Part %03d of file %s%s", |
1341 | fprintf (outfile, "_=_ Part %03d of file %s%s", |
1139 | part, UUFNameFilter ((outfname)?outfname:infname), |
1342 | part, UUFNameFilter ((outfname)?outfname:infname), |
1140 | eolstring); |
1343 | eolstring); |
1141 | else |
1344 | else |
1142 | fprintf (outfile, "_=_ Part %03d of %03d of file %s%s", |
1345 | fprintf (outfile, "_=_ Part %03d of %03d of file %s%s", |
1143 | part, numparts, |
1346 | part, numparts, |
1144 | UUFNameFilter ((outfname)?outfname:infname), |
1347 | UUFNameFilter ((outfname)?outfname:infname), |
1145 | eolstring); |
1348 | eolstring); |
1146 | fprintf (outfile, "_=_ %s", eolstring); |
1349 | fprintf (outfile, "_=_ %s", eolstring); |
1147 | fprintf (outfile, "%s", eolstring); |
1350 | fprintf (outfile, "%s", eolstring); |
|
|
1351 | } |
1148 | |
1352 | |
1149 | if (part==1 && (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1353 | if (part==1 && (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1150 | fprintf (outfile, "begin %o %s%s", |
1354 | fprintf (outfile, "begin %o %s%s", |
1151 | (filemode)?filemode : 0644, |
1355 | (filemode)?filemode : 0644, |
1152 | UUFNameFilter ((outfname)?outfname:infname), |
1356 | UUFNameFilter ((outfname)?outfname:infname), |
1153 | eolstring); |
1357 | eolstring); |
1154 | } |
1358 | } |
|
|
1359 | else if (encoding == YENC_ENCODED) { |
|
|
1360 | if (numparts != 1) { |
|
|
1361 | if (progress.totsize == -1) { |
|
|
1362 | fprintf (outfile, "=ybegin part=%d line=128 name=%s%s", |
|
|
1363 | part, |
|
|
1364 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1365 | eolstring); |
|
|
1366 | } |
|
|
1367 | else { |
|
|
1368 | fprintf (outfile, "=ybegin part=%d line=128 size=%ld name=%s%s", |
|
|
1369 | part, |
|
|
1370 | progress.totsize, |
|
|
1371 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1372 | eolstring); |
|
|
1373 | } |
|
|
1374 | |
|
|
1375 | fprintf (outfile, "=ypart begin=%d end=%d%s", |
|
|
1376 | (part-1)*linperfile*128+1, |
|
|
1377 | (part*linperfile*128) < progress.totsize ? |
|
|
1378 | (part*linperfile*128) : progress.totsize, |
|
|
1379 | eolstring); |
|
|
1380 | } |
|
|
1381 | else { |
|
|
1382 | if (progress.totsize == -1) { |
|
|
1383 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
1384 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1385 | eolstring); |
|
|
1386 | } |
|
|
1387 | else { |
|
|
1388 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
1389 | progress.totsize, |
|
|
1390 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1391 | eolstring); |
|
|
1392 | } |
|
|
1393 | } |
|
|
1394 | } |
|
|
1395 | |
1155 | if ((res = UUEncodeStream (outfile, theifile, |
1396 | if ((res = UUEncodeStream (outfile, theifile, |
1156 | encoding, linperfile)) != UURET_OK) { |
1397 | encoding, linperfile)) != UURET_OK) { |
1157 | if (res != UURET_CANCEL) { |
1398 | if (res != UURET_CANCEL) { |
1158 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1399 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1159 | uustring (S_ERR_ENCODING), |
1400 | uustring (S_ERR_ENCODING), |
… | |
… | |
1165 | fclose (outfile); |
1406 | fclose (outfile); |
1166 | unlink (oname); |
1407 | unlink (oname); |
1167 | FP_free (oname); |
1408 | FP_free (oname); |
1168 | return res; |
1409 | return res; |
1169 | } |
1410 | } |
|
|
1411 | |
1170 | if (feof (theifile) && |
1412 | if (feof (theifile) && |
1171 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1413 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1172 | fprintf (outfile, "%c%s", |
1414 | fprintf (outfile, "%c%s", |
1173 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1415 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1174 | eolstring); |
1416 | eolstring); |
1175 | fprintf (outfile, "end%s", eolstring); |
1417 | fprintf (outfile, "end%s", eolstring); |
1176 | } |
1418 | } |
|
|
1419 | else if (encoding == YENC_ENCODED) { |
|
|
1420 | if (numparts != 1) { |
|
|
1421 | fprintf (outfile, "=yend size=%d part=%d%s", |
|
|
1422 | (part*linperfile*128) < progress.totsize ? |
|
|
1423 | linperfile*128 : (progress.totsize-(part-1)*linperfile*128), |
|
|
1424 | part, |
|
|
1425 | eolstring); |
|
|
1426 | } |
|
|
1427 | else { |
|
|
1428 | fprintf (outfile, "=yend size=%d%s", |
|
|
1429 | progress.totsize, |
|
|
1430 | eolstring); |
|
|
1431 | } |
|
|
1432 | } |
|
|
1433 | |
1177 | /* |
1434 | /* |
1178 | * empty line at end does no harm |
1435 | * empty line at end does no harm |
1179 | */ |
1436 | */ |
|
|
1437 | |
1180 | fprintf (outfile, "%s", eolstring); |
1438 | fprintf (outfile, "%s", eolstring); |
1181 | fclose (outfile); |
1439 | fclose (outfile); |
1182 | } |
1440 | } |
|
|
1441 | |
1183 | if (infile==NULL) fclose (theifile); |
1442 | if (infile==NULL) fclose (theifile); |
1184 | progress.action = 0; |
1443 | progress.action = 0; |
1185 | FP_free (oname); |
1444 | FP_free (oname); |
1186 | return UURET_OK; |
1445 | return UURET_OK; |
1187 | } |
1446 | } |
… | |
… | |
1220 | char *mimetype, *ptr; |
1479 | char *mimetype, *ptr; |
1221 | int res, len; |
1480 | int res, len; |
1222 | |
1481 | |
1223 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1482 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1224 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1483 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1225 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1484 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
1226 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1485 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1227 | uustring (S_PARM_CHECK), "UUE_PrepSingle()"); |
1486 | uustring (S_PARM_CHECK), "UUE_PrepSingle()"); |
1228 | return UURET_ILLVAL; |
1487 | return UURET_ILLVAL; |
1229 | } |
1488 | } |
1230 | |
1489 | |
… | |
… | |
1247 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1506 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1248 | uustring (S_OUT_OF_MEMORY), len); |
1507 | uustring (S_OUT_OF_MEMORY), len); |
1249 | return UURET_NOMEM; |
1508 | return UURET_NOMEM; |
1250 | } |
1509 | } |
1251 | |
1510 | |
|
|
1511 | if (encoding == YENC_ENCODED) { |
1252 | if (subject) |
1512 | if (subject) |
|
|
1513 | sprintf (subline, "- %s - %s (001/001)", oname, subject); |
|
|
1514 | else |
|
|
1515 | sprintf (subline, "- %s - (001/001)", oname); |
|
|
1516 | } |
|
|
1517 | else { |
|
|
1518 | if (subject) |
1253 | sprintf (subline, "%s (001/001) - [ %s ]", subject, oname); |
1519 | sprintf (subline, "%s (001/001) - [ %s ]", subject, oname); |
1254 | else |
1520 | else |
1255 | sprintf (subline, "[ %s ] (001/001)", oname); |
1521 | sprintf (subline, "[ %s ] (001/001)", oname); |
|
|
1522 | } |
1256 | |
1523 | |
1257 | if (from) { |
1524 | if (from) { |
1258 | fprintf (outfile, "From: %s%s", from, eolstring); |
1525 | fprintf (outfile, "From: %s%s", from, eolstring); |
1259 | } |
1526 | } |
1260 | if (destination) { |
1527 | if (destination) { |
… | |
… | |
1267 | |
1534 | |
1268 | if (replyto) { |
1535 | if (replyto) { |
1269 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1536 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1270 | } |
1537 | } |
1271 | |
1538 | |
|
|
1539 | if (encoding != YENC_ENCODED) { |
1272 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1540 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1273 | fprintf (outfile, "Content-Type: %s; name=\"%s\"%s", |
1541 | fprintf (outfile, "Content-Type: %s; name=\"%s\"%s", |
1274 | (mimetype)?mimetype:"Application/Octet-Stream", |
1542 | (mimetype)?mimetype:"Application/Octet-Stream", |
1275 | UUFNameFilter ((outfname)?outfname:infname), |
1543 | UUFNameFilter ((outfname)?outfname:infname), |
1276 | eolstring); |
1544 | eolstring); |
1277 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
1545 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
1278 | CTE_TYPE(encoding), eolstring); |
1546 | CTE_TYPE(encoding), eolstring); |
|
|
1547 | } |
|
|
1548 | |
1279 | fprintf (outfile, "%s", eolstring); |
1549 | fprintf (outfile, "%s", eolstring); |
1280 | |
1550 | |
1281 | res = UUEncodeToStream (outfile, infile, infname, encoding, |
1551 | res = UUEncodeToStream (outfile, infile, infname, encoding, |
1282 | outfname, filemode); |
1552 | outfname, filemode); |
1283 | |
1553 | |
… | |
… | |
1319 | long thesize; |
1589 | long thesize; |
1320 | int res, len; |
1590 | int res, len; |
1321 | |
1591 | |
1322 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1592 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1323 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1593 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1324 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1594 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
1325 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1595 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1326 | uustring (S_PARM_CHECK), "UUE_PrepPartial()"); |
1596 | uustring (S_PARM_CHECK), "UUE_PrepPartial()"); |
1327 | return UURET_ILLVAL; |
1597 | return UURET_ILLVAL; |
1328 | } |
1598 | } |
1329 | |
1599 | |
… | |
… | |
1331 | len = ((subject)?strlen(subject):0) + strlen (oname) + 40; |
1601 | len = ((subject)?strlen(subject):0) + strlen (oname) + 40; |
1332 | |
1602 | |
1333 | /* |
1603 | /* |
1334 | * if first part, get information about the file |
1604 | * if first part, get information about the file |
1335 | */ |
1605 | */ |
|
|
1606 | |
1336 | if (partno == 1) { |
1607 | if (partno == 1) { |
1337 | if (infile==NULL) { |
1608 | if (infile==NULL) { |
1338 | if (stat (infname, &finfo) == -1) { |
1609 | if (stat (infname, &finfo) == -1) { |
1339 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1610 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1340 | uustring (S_NOT_STAT_FILE), |
1611 | uustring (S_NOT_STAT_FILE), |
… | |
… | |
1386 | filemode = (int) finfo.st_mode & 0777; |
1657 | filemode = (int) finfo.st_mode & 0777; |
1387 | thesize = (long) finfo.st_size; |
1658 | thesize = (long) finfo.st_size; |
1388 | } |
1659 | } |
1389 | theifile = infile; |
1660 | theifile = infile; |
1390 | } |
1661 | } |
|
|
1662 | |
1391 | /* |
1663 | /* |
1392 | * if there's one part only, don't use Message/Partial |
1664 | * if there's one part only, don't use Message/Partial |
1393 | */ |
1665 | */ |
1394 | |
1666 | |
1395 | if (numparts == 1) { |
1667 | if (numparts == 1) { |
… | |
… | |
1400 | } |
1672 | } |
1401 | |
1673 | |
1402 | /* |
1674 | /* |
1403 | * we also need a unique ID |
1675 | * we also need a unique ID |
1404 | */ |
1676 | */ |
|
|
1677 | |
1405 | sprintf (mimeid, "UUDV-%ld.%ld.%s", |
1678 | sprintf (mimeid, "UUDV-%ld.%ld.%s", |
1406 | (long) time(NULL), thesize, |
1679 | (long) time(NULL), thesize, |
1407 | (strlen(oname)>16)?"oops":oname); |
1680 | (strlen(oname)>16)?"oops":oname); |
1408 | } |
1681 | } |
1409 | |
1682 | |
… | |
… | |
1412 | uustring (S_OUT_OF_MEMORY), len); |
1685 | uustring (S_OUT_OF_MEMORY), len); |
1413 | if (infile==NULL) fclose (theifile); |
1686 | if (infile==NULL) fclose (theifile); |
1414 | return UURET_NOMEM; |
1687 | return UURET_NOMEM; |
1415 | } |
1688 | } |
1416 | |
1689 | |
|
|
1690 | |
|
|
1691 | if (encoding == YENC_ENCODED) { |
1417 | if (subject) |
1692 | if (subject) |
|
|
1693 | sprintf (subline, "- %s - %s (%03d/%03d)", oname, subject, |
|
|
1694 | partno, numparts); |
|
|
1695 | else |
|
|
1696 | sprintf (subline, "- %s - (%03d/%03d)", oname, |
|
|
1697 | partno, numparts); |
|
|
1698 | } |
|
|
1699 | else { |
|
|
1700 | if (subject) |
1418 | sprintf (subline, "%s (%03d/%03d) - [ %s ]", |
1701 | sprintf (subline, "%s (%03d/%03d) - [ %s ]", |
1419 | subject, partno, numparts, oname); |
1702 | subject, partno, numparts, oname); |
1420 | else |
1703 | else |
1421 | sprintf (subline, "[ %s ] (%03d/%03d)", |
1704 | sprintf (subline, "[ %s ] (%03d/%03d)", |
1422 | oname, partno, numparts); |
1705 | oname, partno, numparts); |
|
|
1706 | } |
1423 | |
1707 | |
1424 | if (from) { |
1708 | if (from) { |
1425 | fprintf (outfile, "From: %s%s", from, eolstring); |
1709 | fprintf (outfile, "From: %s%s", from, eolstring); |
1426 | } |
1710 | } |
1427 | |
1711 | |
… | |
… | |
1435 | |
1719 | |
1436 | if (replyto) { |
1720 | if (replyto) { |
1437 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1721 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1438 | } |
1722 | } |
1439 | |
1723 | |
|
|
1724 | if (encoding != YENC_ENCODED) { |
1440 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1725 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1441 | fprintf (outfile, "Content-Type: Message/Partial; number=%d; total=%d;%s", |
1726 | fprintf (outfile, "Content-Type: Message/Partial; number=%d; total=%d;%s", |
1442 | partno, numparts, eolstring); |
1727 | partno, numparts, eolstring); |
1443 | fprintf (outfile, "\tid=\"%s\"%s", |
1728 | fprintf (outfile, "\tid=\"%s\"%s", |
1444 | mimeid, eolstring); |
1729 | mimeid, eolstring); |
|
|
1730 | } |
|
|
1731 | |
1445 | fprintf (outfile, "%s", eolstring); |
1732 | fprintf (outfile, "%s", eolstring); |
1446 | |
1733 | |
1447 | res = UUEncodePartial (outfile, theifile, |
1734 | res = UUEncodePartial (outfile, theifile, |
1448 | infname, encoding, |
1735 | infname, encoding, |
1449 | (outfname)?outfname:infname, NULL, |
1736 | (outfname)?outfname:infname, NULL, |