… | |
… | |
44 | |
44 | |
45 | #include <uudeview.h> |
45 | #include <uudeview.h> |
46 | #include <uuint.h> |
46 | #include <uuint.h> |
47 | #include <fptools.h> |
47 | #include <fptools.h> |
48 | #include <uustring.h> |
48 | #include <uustring.h> |
|
|
49 | #include <crc32.h> |
49 | |
50 | |
50 | /* for braindead systems */ |
51 | /* for braindead systems */ |
51 | #ifndef SEEK_SET |
52 | #ifndef SEEK_SET |
52 | #ifdef L_BEGIN |
53 | #ifdef L_BEGIN |
53 | #define SEEK_SET L_BEGIN |
54 | #define SEEK_SET L_BEGIN |
54 | #else |
55 | #else |
55 | #define SEEK_SET 0 |
56 | #define SEEK_SET 0 |
56 | #endif |
57 | #endif |
57 | #endif |
58 | #endif |
58 | |
59 | |
59 | char * uuencode_id = "$Id: uuencode.c,v 1.2 2001/06/11 20:42:37 root Exp $"; |
60 | char * uuencode_id = "$Id: uuencode.c,v 1.2.2.4 2003/11/06 13:08:23 root Exp $"; |
60 | |
61 | |
61 | #if 0 |
62 | #if 0 |
62 | /* |
63 | /* |
63 | * the End-Of-Line string. MIME enforces CRLF, so that's what we use. Some |
64 | * 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 |
65 | * implementations of uudecode will complain about a missing end line, since |
… | |
… | |
108 | */ |
109 | */ |
109 | |
110 | |
110 | #define CTE_UUENC "x-uuencode" |
111 | #define CTE_UUENC "x-uuencode" |
111 | #define CTE_XXENC "x-xxencode" |
112 | #define CTE_XXENC "x-xxencode" |
112 | #define CTE_BINHEX "x-binhex" |
113 | #define CTE_BINHEX "x-binhex" |
|
|
114 | #define CTE_YENC "x-yenc" |
113 | |
115 | |
114 | #define CTE_TYPE(y) (((y)==B64ENCODED) ? "Base64" : \ |
116 | #define CTE_TYPE(y) (((y)==B64ENCODED) ? "Base64" : \ |
115 | ((y)==UU_ENCODED) ? CTE_UUENC : \ |
117 | ((y)==UU_ENCODED) ? CTE_UUENC : \ |
116 | ((y)==XX_ENCODED) ? CTE_XXENC : \ |
118 | ((y)==XX_ENCODED) ? CTE_XXENC : \ |
117 | ((y)==PT_ENCODED) ? "8bit" : \ |
119 | ((y)==PT_ENCODED) ? "8bit" : \ |
118 | ((y)==QP_ENCODED) ? "quoted-printable" : \ |
120 | ((y)==QP_ENCODED) ? "quoted-printable" : \ |
119 | ((y)==BH_ENCODED) ? CTE_BINHEX : "x-oops") |
121 | ((y)==BH_ENCODED) ? CTE_BINHEX : \ |
|
|
122 | ((y)==YENC_ENCODED) ? CTE_YENC : "x-oops") |
120 | |
123 | |
121 | /* |
124 | /* |
122 | * encoding tables |
125 | * encoding tables |
123 | */ |
126 | */ |
124 | |
127 | |
… | |
… | |
212 | |
215 | |
213 | /* |
216 | /* |
214 | * encoded bytes per line |
217 | * encoded bytes per line |
215 | */ |
218 | */ |
216 | |
219 | |
217 | static int bpl[5] = { 0, 45, 57, 45, 45 }; |
220 | static int bpl[8] = { 0, 45, 57, 45, 45, 0, 0, 128 }; |
218 | |
221 | |
219 | /* |
222 | /* |
220 | * tables |
223 | * tables |
221 | */ |
224 | */ |
222 | |
225 | |
… | |
… | |
238 | /* |
241 | /* |
239 | * Encode one part of the data stream |
242 | * Encode one part of the data stream |
240 | */ |
243 | */ |
241 | |
244 | |
242 | static int |
245 | static int |
243 | UUEncodeStream (FILE *outfile, FILE *infile, int encoding, long linperfile) |
246 | UUEncodeStream (FILE *outfile, FILE *infile, int encoding, long linperfile, crc32_t *crc, crc32_t *pcrc) |
244 | { |
247 | { |
245 | uchar *itemp = (uchar *) uuestr_itemp; |
248 | unsigned char *itemp = (char *) uuestr_itemp; |
246 | uchar *otemp = (uchar *) uuestr_otemp; |
249 | unsigned char *otemp = (char *) uuestr_otemp; |
247 | unsigned char *optr, *table, *tptr; |
250 | unsigned char *optr, *table, *tptr; |
248 | int index, count; |
251 | int index, count; |
249 | long line=0; |
252 | long line=0; |
250 | size_t llen; |
253 | size_t llen; |
251 | |
254 | |
252 | if (outfile==NULL || infile==NULL || |
255 | if (outfile==NULL || infile==NULL || |
253 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
256 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
254 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
257 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
255 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
258 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
256 | uustring (S_PARM_CHECK), "UUEncodeStream()"); |
259 | uustring (S_PARM_CHECK), "UUEncodeStream()"); |
257 | return UURET_ILLVAL; |
260 | return UURET_ILLVAL; |
258 | } |
261 | } |
259 | |
262 | |
… | |
… | |
262 | * read line oriented. |
265 | * read line oriented. |
263 | */ |
266 | */ |
264 | |
267 | |
265 | if (encoding == PT_ENCODED || encoding == QP_ENCODED) { |
268 | if (encoding == PT_ENCODED || encoding == QP_ENCODED) { |
266 | while (!feof (infile) && (linperfile <= 0 || line < linperfile)) { |
269 | while (!feof (infile) && (linperfile <= 0 || line < linperfile)) { |
267 | if (FP_fgets (itemp, 255, infile) == NULL) { |
270 | if (_FP_fgets (itemp, 255, infile) == NULL) { |
268 | break; |
271 | break; |
269 | } |
272 | } |
270 | |
273 | |
271 | itemp[255] = '\0'; |
274 | itemp[255] = '\0'; |
272 | count = strlen (itemp); |
275 | count = strlen (itemp); |
… | |
… | |
375 | * line break. |
378 | * line break. |
376 | */ |
379 | */ |
377 | |
380 | |
378 | if (itemp[index+1] != 0 && itemp[index+1] != '\n' && |
381 | if (itemp[index+1] != 0 && itemp[index+1] != '\n' && |
379 | (llen >= 75 || |
382 | (llen >= 75 || |
380 | !((itemp[index+1] >= 33 && itemp[index+1] <= 60) || |
383 | (!((itemp[index+1] >= 33 && itemp[index+1] <= 60) || |
381 | (itemp[index+1] >= 62 && itemp[index+1] <= 126)) && |
384 | (itemp[index+1] >= 62 && itemp[index+1] <= 126)) && |
382 | llen >= 73)) { |
385 | llen >= 73))) { |
383 | |
386 | |
384 | *optr++ = '='; |
387 | *optr++ = '='; |
385 | llen++; |
388 | llen++; |
386 | |
389 | |
387 | if (fwrite (otemp, 1, llen, outfile) != llen || |
390 | if (fwrite (otemp, 1, llen, outfile) != llen || |
… | |
… | |
401 | |
404 | |
402 | return UURET_OK; |
405 | return UURET_OK; |
403 | } |
406 | } |
404 | |
407 | |
405 | /* |
408 | /* |
|
|
409 | * Special handling for yEnc |
|
|
410 | */ |
|
|
411 | |
|
|
412 | if (encoding == YENC_ENCODED) { |
|
|
413 | llen = 0; |
|
|
414 | optr = otemp; |
|
|
415 | |
|
|
416 | while (!feof (infile) && (linperfile <= 0 || line < linperfile)) { |
|
|
417 | if ((count = fread (itemp, 1, 128, infile)) != 128) { |
|
|
418 | if (count == 0) { |
|
|
419 | break; |
|
|
420 | } |
|
|
421 | else if (ferror (infile)) { |
|
|
422 | return UURET_IOERR; |
|
|
423 | } |
|
|
424 | } |
|
|
425 | |
|
|
426 | if (pcrc) |
|
|
427 | *pcrc = crc32(*pcrc, itemp, count); |
|
|
428 | if (crc) |
|
|
429 | *crc = crc32(*crc, itemp, count); |
|
|
430 | |
|
|
431 | line++; |
|
|
432 | |
|
|
433 | /* |
|
|
434 | * Busy Callback |
|
|
435 | */ |
|
|
436 | |
|
|
437 | if (UUBUSYPOLL(ftell(infile)-progress.foffset,progress.fsize)) { |
|
|
438 | UUMessage (uuencode_id, __LINE__, UUMSG_NOTE, |
|
|
439 | uustring (S_ENCODE_CANCEL)); |
|
|
440 | return UURET_CANCEL; |
|
|
441 | } |
|
|
442 | |
|
|
443 | for (index=0; index<count; index++) { |
|
|
444 | if (llen > 127) { |
|
|
445 | if (fwrite (otemp, 1, llen, outfile) != llen || |
|
|
446 | fwrite ((char *) eolstring, 1, |
|
|
447 | strlen(eolstring), outfile) != strlen (eolstring)) { |
|
|
448 | return UURET_IOERR; |
|
|
449 | } |
|
|
450 | llen = 0; |
|
|
451 | optr = otemp; |
|
|
452 | } |
|
|
453 | |
|
|
454 | switch ((char) ((int) itemp[index] + 42)) { |
|
|
455 | case '\0': |
|
|
456 | case '\t': |
|
|
457 | case '\n': |
|
|
458 | case '\r': |
|
|
459 | case '=': |
|
|
460 | case '\033': |
|
|
461 | *optr++ = '='; |
|
|
462 | *optr++ = (char) ((int) itemp[index] + 42 + 64); |
|
|
463 | llen += 2; |
|
|
464 | break; |
|
|
465 | |
|
|
466 | case '.': |
|
|
467 | if (llen == 0) { |
|
|
468 | *optr++ = '='; |
|
|
469 | *optr++ = (char) ((int) itemp[index] + 42 + 64); |
|
|
470 | llen += 2; |
|
|
471 | } |
|
|
472 | else { |
|
|
473 | *optr++ = (char) ((int) itemp[index] + 42); |
|
|
474 | llen++; |
|
|
475 | } |
|
|
476 | break; |
|
|
477 | |
|
|
478 | default: |
|
|
479 | *optr++ = (char) ((int) itemp[index] + 42); |
|
|
480 | llen++; |
|
|
481 | break; |
|
|
482 | } |
|
|
483 | } |
|
|
484 | } |
|
|
485 | |
|
|
486 | /* |
|
|
487 | * write last line |
|
|
488 | */ |
|
|
489 | |
|
|
490 | if (llen) { |
|
|
491 | if (fwrite (otemp, 1, llen, outfile) != llen || |
|
|
492 | fwrite ((char *) eolstring, 1, |
|
|
493 | strlen(eolstring), outfile) != strlen (eolstring)) { |
|
|
494 | return UURET_IOERR; |
|
|
495 | } |
|
|
496 | } |
|
|
497 | |
|
|
498 | return UURET_OK; |
|
|
499 | } |
|
|
500 | |
|
|
501 | /* |
406 | * Handling for binary encodings |
502 | * Handling for binary encodings |
407 | */ |
503 | */ |
408 | |
504 | |
409 | /* |
505 | /* |
410 | * select charset |
506 | * select charset |
… | |
… | |
450 | |
546 | |
451 | /* |
547 | /* |
452 | * Main encoding |
548 | * Main encoding |
453 | */ |
549 | */ |
454 | |
550 | |
455 | if (encoding == UU_ENCODED || encoding == XX_ENCODED || |
|
|
456 | encoding == B64ENCODED) { |
|
|
457 | for (index=0; index<=count-3; index+=3, llen+=4) { |
551 | for (index=0; index<=count-3; index+=3, llen+=4) { |
458 | *optr++ = table[itemp[index] >> 2]; |
552 | *optr++ = table[itemp[index] >> 2]; |
459 | *optr++ = table[((itemp[index ] & 0x03) << 4)|(itemp[index+1] >> 4)]; |
553 | *optr++ = table[((itemp[index ] & 0x03) << 4)|(itemp[index+1] >> 4)]; |
460 | *optr++ = table[((itemp[index+1] & 0x0f) << 2)|(itemp[index+2] >> 6)]; |
554 | *optr++ = table[((itemp[index+1] & 0x0f) << 2)|(itemp[index+2] >> 6)]; |
461 | *optr++ = table[ itemp[index+2] & 0x3f]; |
555 | *optr++ = table[ itemp[index+2] & 0x3f]; |
462 | } |
|
|
463 | } |
556 | } |
464 | |
557 | |
465 | /* |
558 | /* |
466 | * Special handling for incomplete lines |
559 | * Special handling for incomplete lines |
467 | */ |
560 | */ |
… | |
… | |
532 | mimemap *miter=mimetable; |
625 | mimemap *miter=mimetable; |
533 | struct stat finfo; |
626 | struct stat finfo; |
534 | int res, themode; |
627 | int res, themode; |
535 | FILE *theifile; |
628 | FILE *theifile; |
536 | char *ptr; |
629 | char *ptr; |
|
|
630 | crc32_t crc; |
|
|
631 | crc32_t *crcptr=NULL; |
537 | |
632 | |
538 | if (outfile==NULL || |
633 | if (outfile==NULL || |
539 | (infile == NULL && infname==NULL) || |
634 | (infile == NULL && infname==NULL) || |
540 | (outfname==NULL && infname==NULL) || |
635 | (outfname==NULL && infname==NULL) || |
541 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
636 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
542 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
637 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
543 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
638 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
544 | uustring (S_PARM_CHECK), "UUEncodeMulti()"); |
639 | uustring (S_PARM_CHECK), "UUEncodeMulti()"); |
545 | return UURET_ILLVAL; |
640 | return UURET_ILLVAL; |
546 | } |
641 | } |
547 | |
642 | |
… | |
… | |
573 | progress.fsize = (long) finfo.st_size; |
668 | progress.fsize = (long) finfo.st_size; |
574 | } |
669 | } |
575 | theifile = infile; |
670 | theifile = infile; |
576 | } |
671 | } |
577 | |
672 | |
578 | if (progress.fsize <= 0) |
673 | if (progress.fsize < 0) |
579 | progress.fsize = -1; |
674 | progress.fsize = -1; |
580 | |
675 | |
581 | FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
676 | _FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
582 | |
677 | |
583 | progress.partno = 1; |
678 | progress.partno = 1; |
584 | progress.numparts = 1; |
679 | progress.numparts = 1; |
585 | progress.percent = 0; |
680 | progress.percent = 0; |
586 | progress.foffset = 0; |
681 | progress.foffset = 0; |
… | |
… | |
591 | * looking at the file's extension. If it is unknown, default to |
686 | * looking at the file's extension. If it is unknown, default to |
592 | * Application/Octet-Stream |
687 | * Application/Octet-Stream |
593 | */ |
688 | */ |
594 | |
689 | |
595 | if (mimetype == NULL) { |
690 | if (mimetype == NULL) { |
596 | if ((ptr = FP_strrchr ((outfname)?outfname:infname, '.'))) { |
691 | if ((ptr = _FP_strrchr ((outfname)?outfname:infname, '.'))) { |
597 | while (miter->extension && FP_stricmp (ptr+1, miter->extension) != 0) |
692 | while (miter->extension && _FP_stricmp (ptr+1, miter->extension) != 0) |
598 | miter++; |
693 | miter++; |
599 | mimetype = miter->mimetype; |
694 | mimetype = miter->mimetype; |
600 | } |
695 | } |
601 | } |
696 | } |
602 | |
697 | |
… | |
… | |
606 | |
701 | |
607 | /* |
702 | /* |
608 | * print sub-header |
703 | * print sub-header |
609 | */ |
704 | */ |
610 | |
705 | |
|
|
706 | if (encoding != YENC_ENCODED) { |
611 | fprintf (outfile, "Content-Type: %s%s", |
707 | fprintf (outfile, "Content-Type: %s%s", |
612 | (mimetype)?mimetype:"Application/Octet-Stream", |
708 | (mimetype)?mimetype:"Application/Octet-Stream", |
613 | eolstring); |
709 | eolstring); |
614 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
710 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
615 | CTE_TYPE(encoding), eolstring); |
711 | CTE_TYPE(encoding), eolstring); |
616 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
712 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
617 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
713 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
618 | fprintf (outfile, "%s", eolstring); |
714 | fprintf (outfile, "%s", eolstring); |
|
|
715 | } |
619 | |
716 | |
620 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
717 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
621 | fprintf (outfile, "begin %o %s%s", |
718 | fprintf (outfile, "begin %o %s%s", |
622 | (themode) ? themode : 0644, |
719 | (themode) ? themode : 0644, |
623 | UUFNameFilter ((outfname)?outfname:infname), |
720 | UUFNameFilter ((outfname)?outfname:infname), |
624 | eolstring); |
721 | eolstring); |
625 | } |
722 | } |
|
|
723 | else if (encoding == YENC_ENCODED) { |
|
|
724 | crc = crc32(0L, Z_NULL, 0); |
|
|
725 | crcptr = &crc; |
|
|
726 | if (progress.fsize == -1) { |
|
|
727 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
728 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
729 | eolstring); |
|
|
730 | } |
|
|
731 | else { |
|
|
732 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
733 | progress.fsize, |
|
|
734 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
735 | eolstring); |
|
|
736 | } |
|
|
737 | } |
|
|
738 | |
626 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
739 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0, crcptr, NULL)) != UURET_OK) { |
627 | if (res != UURET_CANCEL) { |
740 | if (res != UURET_CANCEL) { |
628 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
741 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
629 | uustring (S_ERR_ENCODING), |
742 | uustring (S_ERR_ENCODING), |
630 | UUFNameFilter ((infname)?infname:outfname), |
743 | UUFNameFilter ((infname)?infname:outfname), |
631 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror(res)); |
744 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror(res)); |
632 | } |
745 | } |
633 | progress.action = 0; |
746 | progress.action = 0; |
634 | return res; |
747 | return res; |
635 | } |
748 | } |
|
|
749 | |
636 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
750 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
637 | fprintf (outfile, "%c%s", |
751 | fprintf (outfile, "%c%s", |
638 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
752 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
639 | eolstring); |
753 | eolstring); |
640 | fprintf (outfile, "end%s", eolstring); |
754 | fprintf (outfile, "end%s", eolstring); |
641 | } |
755 | } |
|
|
756 | else if (encoding == YENC_ENCODED) { |
|
|
757 | if (progress.fsize == -1) { |
|
|
758 | fprintf (outfile, "=yend crc32=%08lx%s", |
|
|
759 | crc, |
|
|
760 | eolstring); |
|
|
761 | } |
|
|
762 | else { |
|
|
763 | fprintf (outfile, "=yend size=%ld crc32=%08lx%s", |
|
|
764 | progress.fsize, |
|
|
765 | crc, |
|
|
766 | eolstring); |
|
|
767 | } |
|
|
768 | } |
|
|
769 | |
642 | /* |
770 | /* |
643 | * empty line at end does no harm |
771 | * empty line at end does no harm |
644 | */ |
772 | */ |
|
|
773 | |
645 | fprintf (outfile, "%s", eolstring); |
774 | fprintf (outfile, "%s", eolstring); |
646 | |
775 | |
647 | if (infile==NULL) |
776 | if (infile==NULL) |
648 | fclose (theifile); |
777 | fclose (theifile); |
649 | |
778 | |
… | |
… | |
657 | |
786 | |
658 | int UUEXPORT |
787 | int UUEXPORT |
659 | UUEncodePartial (FILE *outfile, FILE *infile, |
788 | UUEncodePartial (FILE *outfile, FILE *infile, |
660 | char *infname, int encoding, |
789 | char *infname, int encoding, |
661 | char *outfname, char *mimetype, |
790 | char *outfname, char *mimetype, |
662 | int filemode, int partno, long linperfile) |
791 | int filemode, int partno, long linperfile, |
|
|
792 | crc32_t *crcptr) |
663 | { |
793 | { |
664 | mimemap *miter=mimetable; |
794 | mimemap *miter=mimetable; |
665 | static FILE *theifile; |
795 | static FILE *theifile; |
666 | int themode, numparts; |
796 | int themode, numparts; |
667 | struct stat finfo; |
797 | struct stat finfo; |
668 | long thesize; |
798 | long thesize; |
669 | char *ptr; |
799 | char *ptr; |
670 | int res; |
800 | int res; |
|
|
801 | crc32_t pcrc; |
|
|
802 | crc32_t *pcrcptr=NULL; |
671 | |
803 | |
672 | if ((outfname==NULL&&infname==NULL) || partno<=0 || |
804 | if ((outfname==NULL&&infname==NULL) || partno<=0 || |
673 | (infile == NULL&&infname==NULL) || outfile==NULL || |
805 | (infile == NULL&&infname==NULL) || outfile==NULL || |
674 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
806 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
675 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
807 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
676 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
808 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
677 | uustring (S_PARM_CHECK), "UUEncodePartial()"); |
809 | uustring (S_PARM_CHECK), "UUEncodePartial()"); |
678 | return UURET_ILLVAL; |
810 | return UURET_ILLVAL; |
679 | } |
811 | } |
680 | |
812 | |
… | |
… | |
711 | if (fstat (fileno (infile), &finfo) != 0) { |
843 | if (fstat (fileno (infile), &finfo) != 0) { |
712 | UUMessage (uuencode_id, __LINE__, UUMSG_WARNING, |
844 | UUMessage (uuencode_id, __LINE__, UUMSG_WARNING, |
713 | uustring (S_STAT_ONE_PART)); |
845 | uustring (S_STAT_ONE_PART)); |
714 | numparts = 1; |
846 | numparts = 1; |
715 | themode = (filemode)?filemode:0644; |
847 | themode = (filemode)?filemode:0644; |
716 | thesize = 0; |
848 | thesize = -1; |
717 | } |
849 | } |
718 | else { |
850 | else { |
719 | if (linperfile <= 0) |
851 | if (linperfile <= 0) |
720 | numparts = 1; |
852 | numparts = 1; |
721 | else |
853 | else |
… | |
… | |
726 | thesize = (long) finfo.st_size; |
858 | thesize = (long) finfo.st_size; |
727 | } |
859 | } |
728 | theifile = infile; |
860 | theifile = infile; |
729 | } |
861 | } |
730 | |
862 | |
731 | FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
863 | _FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
732 | |
864 | |
733 | progress.totsize = (thesize>0) ? thesize : -1; |
865 | progress.totsize = (thesize>=0) ? thesize : -1; |
734 | progress.partno = 1; |
866 | progress.partno = 1; |
735 | progress.numparts = numparts; |
867 | progress.numparts = numparts; |
736 | progress.percent = 0; |
868 | progress.percent = 0; |
737 | progress.foffset = 0; |
869 | progress.foffset = 0; |
738 | |
870 | |
… | |
… | |
741 | * looking at the file's extension. If it is unknown, default to |
873 | * looking at the file's extension. If it is unknown, default to |
742 | * Application/Octet-Stream |
874 | * Application/Octet-Stream |
743 | */ |
875 | */ |
744 | |
876 | |
745 | if (mimetype == NULL) { |
877 | if (mimetype == NULL) { |
746 | if ((ptr = FP_strrchr ((outfname)?outfname:infname, '.'))) { |
878 | if ((ptr = _FP_strrchr ((outfname)?outfname:infname, '.'))) { |
747 | while (miter->extension && FP_stricmp (ptr+1, miter->extension) != 0) |
879 | while (miter->extension && _FP_stricmp (ptr+1, miter->extension) != 0) |
748 | miter++; |
880 | miter++; |
749 | mimetype = miter->mimetype; |
881 | mimetype = miter->mimetype; |
750 | } |
882 | } |
751 | } |
883 | } |
752 | |
884 | |
… | |
… | |
756 | |
888 | |
757 | /* |
889 | /* |
758 | * print sub-header |
890 | * print sub-header |
759 | */ |
891 | */ |
760 | |
892 | |
|
|
893 | if (encoding != YENC_ENCODED) { |
761 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
894 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
762 | fprintf (outfile, "Content-Type: %s%s", |
895 | fprintf (outfile, "Content-Type: %s%s", |
763 | (mimetype)?mimetype:"Application/Octet-Stream", |
896 | (mimetype)?mimetype:"Application/Octet-Stream", |
764 | eolstring); |
897 | eolstring); |
765 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
898 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
766 | CTE_TYPE(encoding), eolstring); |
899 | CTE_TYPE(encoding), eolstring); |
767 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
900 | fprintf (outfile, "Content-Disposition: attachment; filename=\"%s\"%s", |
768 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
901 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
|
|
902 | } |
|
|
903 | |
769 | fprintf (outfile, "%s", eolstring); |
904 | fprintf (outfile, "%s", eolstring); |
770 | |
905 | |
771 | /* |
906 | /* |
772 | * for the first part of UU or XX messages, print a begin line |
907 | * for the first part of UU or XX messages, print a begin line |
773 | */ |
908 | */ |
|
|
909 | |
774 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
910 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
775 | fprintf (outfile, "begin %o %s%s", |
911 | fprintf (outfile, "begin %o %s%s", |
776 | (themode) ? themode : ((filemode)?filemode:0644), |
912 | (themode) ? themode : ((filemode)?filemode:0644), |
777 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
913 | UUFNameFilter ((outfname)?outfname:infname), eolstring); |
|
|
914 | } |
|
|
915 | } |
|
|
916 | if (encoding == YENC_ENCODED) { |
|
|
917 | pcrc = crc32(0L, Z_NULL, 0); |
|
|
918 | pcrcptr = &pcrc; |
|
|
919 | if (numparts != 1) { |
|
|
920 | if (progress.totsize == -1) { |
|
|
921 | fprintf (outfile, "=ybegin part=%d line=128 name=%s%s", |
|
|
922 | partno, |
|
|
923 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
924 | eolstring); |
|
|
925 | } |
|
|
926 | else { |
|
|
927 | fprintf (outfile, "=ybegin part=%d line=128 size=%ld name=%s%s", |
|
|
928 | partno, |
|
|
929 | progress.totsize, |
|
|
930 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
931 | eolstring); |
|
|
932 | } |
|
|
933 | |
|
|
934 | fprintf (outfile, "=ypart begin=%d end=%d%s", |
|
|
935 | (partno-1)*linperfile*128+1, |
|
|
936 | (partno*linperfile*128) < progress.totsize ? |
|
|
937 | (partno*linperfile*128) : progress.totsize, |
|
|
938 | eolstring); |
|
|
939 | } |
|
|
940 | else { |
|
|
941 | if (progress.totsize == -1) { |
|
|
942 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
943 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
944 | eolstring); |
|
|
945 | } |
|
|
946 | else { |
|
|
947 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
948 | progress.totsize, |
|
|
949 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
950 | eolstring); |
|
|
951 | } |
778 | } |
952 | } |
779 | } |
953 | } |
780 | |
954 | |
781 | /* |
955 | /* |
782 | * update progress information |
956 | * update progress information |
… | |
… | |
795 | else |
969 | else |
796 | progress.fsize = linperfile*bpl[encoding]; |
970 | progress.fsize = linperfile*bpl[encoding]; |
797 | |
971 | |
798 | progress.action = UUACT_ENCODING; |
972 | progress.action = UUACT_ENCODING; |
799 | |
973 | |
800 | if ((res = UUEncodeStream (outfile, theifile, |
974 | if ((res = UUEncodeStream (outfile, theifile, encoding, linperfile, |
801 | encoding, linperfile)) != UURET_OK) { |
975 | crcptr, pcrcptr)) != UURET_OK) { |
802 | if (infile==NULL) fclose (theifile); |
976 | if (infile==NULL) fclose (theifile); |
803 | if (res != UURET_CANCEL) { |
977 | if (res != UURET_CANCEL) { |
804 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
978 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
805 | uustring (S_ERR_ENCODING), |
979 | uustring (S_ERR_ENCODING), |
806 | UUFNameFilter ((outfname)?outfname:infname), |
980 | UUFNameFilter ((outfname)?outfname:infname), |
807 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
981 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
808 | } |
982 | } |
809 | progress.action = 0; |
983 | progress.action = 0; |
810 | return res; |
984 | return res; |
811 | } |
985 | } |
|
|
986 | |
812 | /* |
987 | /* |
813 | * print end line |
988 | * print end line |
814 | */ |
989 | */ |
|
|
990 | |
815 | if (feof (theifile) && |
991 | if (feof (theifile) && |
816 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
992 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
817 | fprintf (outfile, "%c%s", |
993 | fprintf (outfile, "%c%s", |
818 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
994 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
819 | eolstring); |
995 | eolstring); |
820 | fprintf (outfile, "end%s", eolstring); |
996 | fprintf (outfile, "end%s", eolstring); |
|
|
997 | } |
|
|
998 | else if (encoding == YENC_ENCODED) { |
|
|
999 | if (numparts != 1) { |
|
|
1000 | fprintf (outfile, "=yend size=%d part=%d pcrc32=%08lx", |
|
|
1001 | (partno*linperfile*128) < progress.totsize ? |
|
|
1002 | linperfile*128 : (progress.totsize-(partno-1)*linperfile*128), |
|
|
1003 | partno, |
|
|
1004 | pcrc); |
|
|
1005 | } |
|
|
1006 | else { |
|
|
1007 | fprintf (outfile, "=yend size=%d", |
|
|
1008 | progress.totsize); |
|
|
1009 | } |
|
|
1010 | if (feof (theifile)) |
|
|
1011 | fprintf (outfile, " crc32=%08lx", *crcptr); |
|
|
1012 | fprintf (outfile, "%s", eolstring); |
821 | } |
1013 | } |
822 | |
1014 | |
823 | /* |
1015 | /* |
824 | * empty line at end does no harm |
1016 | * empty line at end does no harm |
825 | */ |
1017 | */ |
… | |
… | |
860 | { |
1052 | { |
861 | struct stat finfo; |
1053 | struct stat finfo; |
862 | FILE *theifile; |
1054 | FILE *theifile; |
863 | int themode; |
1055 | int themode; |
864 | int res; |
1056 | int res; |
|
|
1057 | crc32_t crc; |
|
|
1058 | crc32_t *crcptr=NULL; |
865 | |
1059 | |
866 | if (outfile==NULL || |
1060 | if (outfile==NULL || |
867 | (infile == NULL&&infname==NULL) || |
1061 | (infile == NULL&&infname==NULL) || |
868 | (outfname==NULL&&infname==NULL) || |
1062 | (outfname==NULL&&infname==NULL) || |
869 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1063 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
870 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1064 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
871 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1065 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
872 | uustring (S_PARM_CHECK), "UUEncodeToStream()"); |
1066 | uustring (S_PARM_CHECK), "UUEncodeToStream()"); |
873 | return UURET_ILLVAL; |
1067 | return UURET_ILLVAL; |
874 | } |
1068 | } |
875 | |
1069 | |
… | |
… | |
902 | progress.fsize = (long) finfo.st_size; |
1096 | progress.fsize = (long) finfo.st_size; |
903 | } |
1097 | } |
904 | theifile = infile; |
1098 | theifile = infile; |
905 | } |
1099 | } |
906 | |
1100 | |
907 | if (progress.fsize <= 0) |
1101 | if (progress.fsize < 0) |
908 | progress.fsize = -1; |
1102 | progress.fsize = -1; |
909 | |
1103 | |
910 | FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
1104 | _FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
911 | |
1105 | |
912 | progress.partno = 1; |
1106 | progress.partno = 1; |
913 | progress.numparts = 1; |
1107 | progress.numparts = 1; |
914 | progress.percent = 0; |
1108 | progress.percent = 0; |
915 | progress.foffset = 0; |
1109 | progress.foffset = 0; |
… | |
… | |
919 | fprintf (outfile, "begin %o %s%s", |
1113 | fprintf (outfile, "begin %o %s%s", |
920 | (themode) ? themode : 0644, |
1114 | (themode) ? themode : 0644, |
921 | UUFNameFilter ((outfname)?outfname:infname), |
1115 | UUFNameFilter ((outfname)?outfname:infname), |
922 | eolstring); |
1116 | eolstring); |
923 | } |
1117 | } |
|
|
1118 | else if (encoding == YENC_ENCODED) { |
|
|
1119 | crc = crc32(0L, Z_NULL, 0); |
|
|
1120 | crcptr = &crc; |
|
|
1121 | if (progress.fsize == -1) { |
|
|
1122 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
1123 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1124 | eolstring); |
|
|
1125 | } |
|
|
1126 | else { |
|
|
1127 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
1128 | progress.fsize, |
|
|
1129 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1130 | eolstring); |
|
|
1131 | } |
|
|
1132 | } |
|
|
1133 | |
924 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0)) != UURET_OK) { |
1134 | if ((res = UUEncodeStream (outfile, theifile, encoding, 0, crcptr, NULL)) != UURET_OK) { |
925 | if (res != UURET_CANCEL) { |
1135 | if (res != UURET_CANCEL) { |
926 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1136 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
927 | uustring (S_ERR_ENCODING), |
1137 | uustring (S_ERR_ENCODING), |
928 | UUFNameFilter ((infname)?infname:outfname), |
1138 | UUFNameFilter ((infname)?infname:outfname), |
929 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
1139 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
930 | } |
1140 | } |
931 | progress.action = 0; |
1141 | progress.action = 0; |
932 | return res; |
1142 | return res; |
933 | } |
1143 | } |
|
|
1144 | |
934 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
1145 | if (encoding == UU_ENCODED || encoding == XX_ENCODED) { |
935 | fprintf (outfile, "%c%s", |
1146 | fprintf (outfile, "%c%s", |
936 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1147 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
937 | eolstring); |
1148 | eolstring); |
938 | fprintf (outfile, "end%s", eolstring); |
1149 | fprintf (outfile, "end%s", eolstring); |
939 | } |
1150 | } |
|
|
1151 | else if (encoding == YENC_ENCODED) { |
|
|
1152 | if (progress.fsize == -1) { |
|
|
1153 | fprintf (outfile, "=yend crc32=%08lx%s", |
|
|
1154 | crc, |
|
|
1155 | eolstring); |
|
|
1156 | } |
|
|
1157 | else { |
|
|
1158 | fprintf (outfile, "=yend size=%ld crc32=%08lx%s", |
|
|
1159 | progress.fsize, |
|
|
1160 | crc, |
|
|
1161 | eolstring); |
|
|
1162 | } |
|
|
1163 | } |
|
|
1164 | |
940 | /* |
1165 | /* |
941 | * empty line at end does no harm |
1166 | * empty line at end does no harm |
942 | */ |
1167 | */ |
|
|
1168 | |
943 | fprintf (outfile, "%s", eolstring); |
1169 | fprintf (outfile, "%s", eolstring); |
944 | |
1170 | |
945 | if (infile==NULL) fclose (theifile); |
1171 | if (infile==NULL) fclose (theifile); |
946 | progress.action = 0; |
1172 | progress.action = 0; |
947 | |
1173 | |
… | |
… | |
958 | { |
1184 | { |
959 | int part, numparts, len, filemode, res; |
1185 | int part, numparts, len, filemode, res; |
960 | char *oname=NULL, *optr, *ptr; |
1186 | char *oname=NULL, *optr, *ptr; |
961 | FILE *theifile, *outfile; |
1187 | FILE *theifile, *outfile; |
962 | struct stat finfo; |
1188 | struct stat finfo; |
|
|
1189 | crc32_t pcrc, crc; |
|
|
1190 | crc32_t *pcrcptr=NULL, *crcptr=NULL; |
963 | |
1191 | |
964 | if ((diskname==NULL&&infname==NULL) || |
1192 | if ((diskname==NULL&&infname==NULL) || |
965 | (outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1193 | (outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
966 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1194 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
967 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1195 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
968 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1196 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
969 | uustring (S_PARM_CHECK), "UUEncodeToFile()"); |
1197 | uustring (S_PARM_CHECK), "UUEncodeToFile()"); |
970 | return UURET_ILLVAL; |
1198 | return UURET_ILLVAL; |
971 | } |
1199 | } |
972 | |
1200 | |
… | |
… | |
1014 | /* |
1242 | /* |
1015 | * optr points after the last dot, so that we can print the part number |
1243 | * optr points after the last dot, so that we can print the part number |
1016 | * there. |
1244 | * there. |
1017 | */ |
1245 | */ |
1018 | |
1246 | |
1019 | optr = FP_strrchr (oname, '.'); |
1247 | optr = _FP_strrchr (oname, '.'); |
1020 | if (optr==NULL || strchr (optr, '/')!=NULL || strchr (optr, '\\')!=NULL) { |
1248 | if (optr==NULL || strchr (optr, '/')!=NULL || strchr (optr, '\\')!=NULL) { |
1021 | optr = oname + strlen (oname); |
1249 | optr = oname + strlen (oname); |
1022 | *optr++ = '.'; |
1250 | *optr++ = '.'; |
1023 | } |
1251 | } |
1024 | else if (optr==oname || *(optr-1)=='/' || *(optr-1)=='\\') { |
1252 | else if (optr==oname || *(optr-1)=='/' || *(optr-1)=='\\') { |
… | |
… | |
1033 | if (infile==NULL) { |
1261 | if (infile==NULL) { |
1034 | if (stat (infname, &finfo) == -1) { |
1262 | if (stat (infname, &finfo) == -1) { |
1035 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1263 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1036 | uustring (S_NOT_STAT_FILE), |
1264 | uustring (S_NOT_STAT_FILE), |
1037 | infname, strerror (uu_errno=errno)); |
1265 | infname, strerror (uu_errno=errno)); |
1038 | FP_free (oname); |
1266 | _FP_free (oname); |
1039 | return UURET_IOERR; |
1267 | return UURET_IOERR; |
1040 | } |
1268 | } |
1041 | if ((theifile = fopen (infname, "rb")) == NULL) { |
1269 | if ((theifile = fopen (infname, "rb")) == NULL) { |
1042 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1270 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1043 | uustring (S_NOT_OPEN_FILE), |
1271 | uustring (S_NOT_OPEN_FILE), |
1044 | infname, strerror (uu_errno=errno)); |
1272 | infname, strerror (uu_errno=errno)); |
1045 | FP_free (oname); |
1273 | _FP_free (oname); |
1046 | return UURET_IOERR; |
1274 | return UURET_IOERR; |
1047 | } |
1275 | } |
1048 | if (linperfile <= 0) |
1276 | if (linperfile <= 0) |
1049 | numparts = 1; |
1277 | numparts = 1; |
1050 | else |
1278 | else |
… | |
… | |
1072 | progress.totsize = -1; |
1300 | progress.totsize = -1; |
1073 | } |
1301 | } |
1074 | theifile = infile; |
1302 | theifile = infile; |
1075 | } |
1303 | } |
1076 | |
1304 | |
1077 | FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
1305 | _FP_strncpy (progress.curfile, (outfname)?outfname:infname, 256); |
1078 | |
1306 | |
1079 | progress.totsize = (progress.totsize<=0) ? -1 : progress.totsize; |
1307 | progress.totsize = (progress.totsize<0) ? -1 : progress.totsize; |
1080 | progress.numparts = numparts; |
1308 | progress.numparts = numparts; |
1081 | |
1309 | |
1082 | for (part=1; !feof (theifile); part++) { |
1310 | for (part=1; !feof (theifile); part++) { |
1083 | /* |
1311 | /* |
1084 | * Attach extension |
1312 | * Attach extension |
… | |
… | |
1130 | if (infile==NULL) fclose (theifile); |
1358 | if (infile==NULL) fclose (theifile); |
1131 | progress.action = 0; |
1359 | progress.action = 0; |
1132 | free (oname); |
1360 | free (oname); |
1133 | return UURET_IOERR; |
1361 | return UURET_IOERR; |
1134 | } |
1362 | } |
|
|
1363 | |
|
|
1364 | if (encoding != YENC_ENCODED) { |
1135 | fprintf (outfile, "%s", eolstring); |
1365 | fprintf (outfile, "%s", eolstring); |
1136 | fprintf (outfile, "_=_ %s", eolstring); |
1366 | fprintf (outfile, "_=_ %s", eolstring); |
1137 | if (numparts == -1) |
1367 | if (numparts == -1) |
1138 | fprintf (outfile, "_=_ Part %03d of file %s%s", |
1368 | fprintf (outfile, "_=_ Part %03d of file %s%s", |
1139 | part, UUFNameFilter ((outfname)?outfname:infname), |
1369 | part, UUFNameFilter ((outfname)?outfname:infname), |
1140 | eolstring); |
1370 | eolstring); |
1141 | else |
1371 | else |
1142 | fprintf (outfile, "_=_ Part %03d of %03d of file %s%s", |
1372 | fprintf (outfile, "_=_ Part %03d of %03d of file %s%s", |
1143 | part, numparts, |
1373 | part, numparts, |
1144 | UUFNameFilter ((outfname)?outfname:infname), |
1374 | UUFNameFilter ((outfname)?outfname:infname), |
1145 | eolstring); |
1375 | eolstring); |
1146 | fprintf (outfile, "_=_ %s", eolstring); |
1376 | fprintf (outfile, "_=_ %s", eolstring); |
1147 | fprintf (outfile, "%s", eolstring); |
1377 | fprintf (outfile, "%s", eolstring); |
|
|
1378 | } |
1148 | |
1379 | |
1149 | if (part==1 && (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1380 | if (part==1 && (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1150 | fprintf (outfile, "begin %o %s%s", |
1381 | fprintf (outfile, "begin %o %s%s", |
1151 | (filemode)?filemode : 0644, |
1382 | (filemode)?filemode : 0644, |
1152 | UUFNameFilter ((outfname)?outfname:infname), |
1383 | UUFNameFilter ((outfname)?outfname:infname), |
1153 | eolstring); |
1384 | eolstring); |
1154 | } |
1385 | } |
|
|
1386 | else if (encoding == YENC_ENCODED) { |
|
|
1387 | if (!crcptr) { |
|
|
1388 | crc = crc32(0L, Z_NULL, 0); |
|
|
1389 | crcptr = &crc; |
|
|
1390 | } |
|
|
1391 | pcrc = crc32(0L, Z_NULL, 0); |
|
|
1392 | pcrcptr = &pcrc; |
|
|
1393 | if (numparts != 1) { |
|
|
1394 | if (progress.totsize == -1) { |
|
|
1395 | fprintf (outfile, "=ybegin part=%d line=128 name=%s%s", |
|
|
1396 | part, |
|
|
1397 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1398 | eolstring); |
|
|
1399 | } |
|
|
1400 | else { |
|
|
1401 | fprintf (outfile, "=ybegin part=%d line=128 size=%ld name=%s%s", |
|
|
1402 | part, |
|
|
1403 | progress.totsize, |
|
|
1404 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1405 | eolstring); |
|
|
1406 | } |
|
|
1407 | |
|
|
1408 | fprintf (outfile, "=ypart begin=%d end=%d%s", |
|
|
1409 | (part-1)*linperfile*128+1, |
|
|
1410 | (part*linperfile*128) < progress.totsize ? |
|
|
1411 | (part*linperfile*128) : progress.totsize, |
|
|
1412 | eolstring); |
|
|
1413 | } |
|
|
1414 | else { |
|
|
1415 | if (progress.totsize == -1) { |
|
|
1416 | fprintf (outfile, "=ybegin line=128 name=%s%s", |
|
|
1417 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1418 | eolstring); |
|
|
1419 | } |
|
|
1420 | else { |
|
|
1421 | fprintf (outfile, "=ybegin line=128 size=%ld name=%s%s", |
|
|
1422 | progress.totsize, |
|
|
1423 | UUFNameFilter ((outfname)?outfname:infname), |
|
|
1424 | eolstring); |
|
|
1425 | } |
|
|
1426 | } |
|
|
1427 | } |
|
|
1428 | |
1155 | if ((res = UUEncodeStream (outfile, theifile, |
1429 | if ((res = UUEncodeStream (outfile, theifile, |
1156 | encoding, linperfile)) != UURET_OK) { |
1430 | encoding, linperfile, crcptr, pcrcptr)) != UURET_OK) { |
1157 | if (res != UURET_CANCEL) { |
1431 | if (res != UURET_CANCEL) { |
1158 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1432 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1159 | uustring (S_ERR_ENCODING), |
1433 | uustring (S_ERR_ENCODING), |
1160 | UUFNameFilter ((infname)?infname:outfname), |
1434 | UUFNameFilter ((infname)?infname:outfname), |
1161 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
1435 | (res==UURET_IOERR)?strerror(uu_errno):UUstrerror (res)); |
1162 | } |
1436 | } |
1163 | if (infile==NULL) fclose (theifile); |
1437 | if (infile==NULL) fclose (theifile); |
1164 | progress.action = 0; |
1438 | progress.action = 0; |
1165 | fclose (outfile); |
1439 | fclose (outfile); |
1166 | unlink (oname); |
1440 | unlink (oname); |
1167 | FP_free (oname); |
1441 | _FP_free (oname); |
1168 | return res; |
1442 | return res; |
1169 | } |
1443 | } |
|
|
1444 | |
1170 | if (feof (theifile) && |
1445 | if (feof (theifile) && |
1171 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1446 | (encoding == UU_ENCODED || encoding == XX_ENCODED)) { |
1172 | fprintf (outfile, "%c%s", |
1447 | fprintf (outfile, "%c%s", |
1173 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1448 | (encoding==UU_ENCODED) ? UUEncodeTable[0] : XXEncodeTable[0], |
1174 | eolstring); |
1449 | eolstring); |
1175 | fprintf (outfile, "end%s", eolstring); |
1450 | fprintf (outfile, "end%s", eolstring); |
1176 | } |
1451 | } |
|
|
1452 | else if (encoding == YENC_ENCODED) { |
|
|
1453 | if (numparts != 1) { |
|
|
1454 | fprintf (outfile, "=yend size=%d part=%d pcrc32=%08lx", |
|
|
1455 | (part*linperfile*128) < progress.totsize ? |
|
|
1456 | linperfile*128 : (progress.totsize-(part-1)*linperfile*128), |
|
|
1457 | part, |
|
|
1458 | pcrc); |
|
|
1459 | } |
|
|
1460 | else { |
|
|
1461 | fprintf (outfile, "=yend size=%d", |
|
|
1462 | progress.totsize); |
|
|
1463 | } |
|
|
1464 | if (feof (theifile)) |
|
|
1465 | fprintf (outfile, " crc32=%08lx", crc); |
|
|
1466 | fprintf (outfile, "%s", eolstring); |
|
|
1467 | } |
|
|
1468 | |
1177 | /* |
1469 | /* |
1178 | * empty line at end does no harm |
1470 | * empty line at end does no harm |
1179 | */ |
1471 | */ |
|
|
1472 | |
1180 | fprintf (outfile, "%s", eolstring); |
1473 | fprintf (outfile, "%s", eolstring); |
1181 | fclose (outfile); |
1474 | fclose (outfile); |
1182 | } |
1475 | } |
|
|
1476 | |
1183 | if (infile==NULL) fclose (theifile); |
1477 | if (infile==NULL) fclose (theifile); |
1184 | progress.action = 0; |
1478 | progress.action = 0; |
1185 | FP_free (oname); |
1479 | _FP_free (oname); |
1186 | return UURET_OK; |
1480 | return UURET_OK; |
1187 | } |
1481 | } |
1188 | |
1482 | |
1189 | /* |
1483 | /* |
1190 | * Encode a MIME Mail message or Newsgroup posting and send to a |
1484 | * Encode a MIME Mail message or Newsgroup posting and send to a |
… | |
… | |
1220 | char *mimetype, *ptr; |
1514 | char *mimetype, *ptr; |
1221 | int res, len; |
1515 | int res, len; |
1222 | |
1516 | |
1223 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1517 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1224 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1518 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1225 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1519 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
1226 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1520 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1227 | uustring (S_PARM_CHECK), "UUE_PrepSingle()"); |
1521 | uustring (S_PARM_CHECK), "UUE_PrepSingle()"); |
1228 | return UURET_ILLVAL; |
1522 | return UURET_ILLVAL; |
1229 | } |
1523 | } |
1230 | |
1524 | |
1231 | oname = UUFNameFilter ((outfname)?outfname:infname); |
1525 | oname = UUFNameFilter ((outfname)?outfname:infname); |
1232 | len = ((subject)?strlen(subject):0) + strlen(oname) + 40; |
1526 | len = ((subject)?strlen(subject):0) + strlen(oname) + 40; |
1233 | |
1527 | |
1234 | if ((ptr = FP_strrchr (oname, '.'))) { |
1528 | if ((ptr = _FP_strrchr (oname, '.'))) { |
1235 | while (miter->extension && FP_stricmp (ptr+1, miter->extension) != 0) |
1529 | while (miter->extension && _FP_stricmp (ptr+1, miter->extension) != 0) |
1236 | miter++; |
1530 | miter++; |
1237 | mimetype = miter->mimetype; |
1531 | mimetype = miter->mimetype; |
1238 | } |
1532 | } |
1239 | else |
1533 | else |
1240 | mimetype = NULL; |
1534 | mimetype = NULL; |
… | |
… | |
1247 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1541 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1248 | uustring (S_OUT_OF_MEMORY), len); |
1542 | uustring (S_OUT_OF_MEMORY), len); |
1249 | return UURET_NOMEM; |
1543 | return UURET_NOMEM; |
1250 | } |
1544 | } |
1251 | |
1545 | |
|
|
1546 | if (encoding == YENC_ENCODED) { |
1252 | if (subject) |
1547 | if (subject) |
|
|
1548 | sprintf (subline, "- %s - %s (001/001)", oname, subject); |
|
|
1549 | else |
|
|
1550 | sprintf (subline, "- %s - (001/001)", oname); |
|
|
1551 | } |
|
|
1552 | else { |
|
|
1553 | if (subject) |
1253 | sprintf (subline, "%s (001/001) - [ %s ]", subject, oname); |
1554 | sprintf (subline, "%s (001/001) - [ %s ]", subject, oname); |
1254 | else |
1555 | else |
1255 | sprintf (subline, "[ %s ] (001/001)", oname); |
1556 | sprintf (subline, "[ %s ] (001/001)", oname); |
|
|
1557 | } |
1256 | |
1558 | |
1257 | if (from) { |
1559 | if (from) { |
1258 | fprintf (outfile, "From: %s%s", from, eolstring); |
1560 | fprintf (outfile, "From: %s%s", from, eolstring); |
1259 | } |
1561 | } |
1260 | if (destination) { |
1562 | if (destination) { |
… | |
… | |
1267 | |
1569 | |
1268 | if (replyto) { |
1570 | if (replyto) { |
1269 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1571 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1270 | } |
1572 | } |
1271 | |
1573 | |
|
|
1574 | if (encoding != YENC_ENCODED) { |
1272 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1575 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1273 | fprintf (outfile, "Content-Type: %s; name=\"%s\"%s", |
1576 | fprintf (outfile, "Content-Type: %s; name=\"%s\"%s", |
1274 | (mimetype)?mimetype:"Application/Octet-Stream", |
1577 | (mimetype)?mimetype:"Application/Octet-Stream", |
1275 | UUFNameFilter ((outfname)?outfname:infname), |
1578 | UUFNameFilter ((outfname)?outfname:infname), |
1276 | eolstring); |
1579 | eolstring); |
1277 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
1580 | fprintf (outfile, "Content-Transfer-Encoding: %s%s", |
1278 | CTE_TYPE(encoding), eolstring); |
1581 | CTE_TYPE(encoding), eolstring); |
|
|
1582 | } |
|
|
1583 | |
1279 | fprintf (outfile, "%s", eolstring); |
1584 | fprintf (outfile, "%s", eolstring); |
1280 | |
1585 | |
1281 | res = UUEncodeToStream (outfile, infile, infname, encoding, |
1586 | res = UUEncodeToStream (outfile, infile, infname, encoding, |
1282 | outfname, filemode); |
1587 | outfname, filemode); |
1283 | |
1588 | |
1284 | FP_free (subline); |
1589 | _FP_free (subline); |
1285 | return res; |
1590 | return res; |
1286 | } |
1591 | } |
1287 | |
1592 | |
1288 | int UUEXPORT |
1593 | int UUEXPORT |
1289 | UUE_PrepPartial (FILE *outfile, FILE *infile, |
1594 | UUE_PrepPartial (FILE *outfile, FILE *infile, |
… | |
… | |
1316 | static FILE *theifile; |
1621 | static FILE *theifile; |
1317 | struct stat finfo; |
1622 | struct stat finfo; |
1318 | char *subline, *oname; |
1623 | char *subline, *oname; |
1319 | long thesize; |
1624 | long thesize; |
1320 | int res, len; |
1625 | int res, len; |
|
|
1626 | static crc32_t crc; |
|
|
1627 | crc32_t *crcptr=NULL; |
1321 | |
1628 | |
1322 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1629 | if ((outfname==NULL&&infname==NULL) || (infile==NULL&&infname==NULL) || |
1323 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1630 | (encoding!=UU_ENCODED&&encoding!=XX_ENCODED&&encoding!=B64ENCODED&& |
1324 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED)) { |
1631 | encoding!=PT_ENCODED&&encoding!=QP_ENCODED&&encoding!=YENC_ENCODED)) { |
1325 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1632 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1326 | uustring (S_PARM_CHECK), "UUE_PrepPartial()"); |
1633 | uustring (S_PARM_CHECK), "UUE_PrepPartial()"); |
1327 | return UURET_ILLVAL; |
1634 | return UURET_ILLVAL; |
1328 | } |
1635 | } |
1329 | |
1636 | |
… | |
… | |
1331 | len = ((subject)?strlen(subject):0) + strlen (oname) + 40; |
1638 | len = ((subject)?strlen(subject):0) + strlen (oname) + 40; |
1332 | |
1639 | |
1333 | /* |
1640 | /* |
1334 | * if first part, get information about the file |
1641 | * if first part, get information about the file |
1335 | */ |
1642 | */ |
|
|
1643 | |
1336 | if (partno == 1) { |
1644 | if (partno == 1) { |
1337 | if (infile==NULL) { |
1645 | if (infile==NULL) { |
1338 | if (stat (infname, &finfo) == -1) { |
1646 | if (stat (infname, &finfo) == -1) { |
1339 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1647 | UUMessage (uuencode_id, __LINE__, UUMSG_ERROR, |
1340 | uustring (S_NOT_STAT_FILE), |
1648 | uustring (S_NOT_STAT_FILE), |
… | |
… | |
1361 | if (filesize <= 0) { |
1669 | if (filesize <= 0) { |
1362 | UUMessage (uuencode_id, __LINE__, UUMSG_WARNING, |
1670 | UUMessage (uuencode_id, __LINE__, UUMSG_WARNING, |
1363 | uustring (S_STAT_ONE_PART)); |
1671 | uustring (S_STAT_ONE_PART)); |
1364 | numparts = 1; |
1672 | numparts = 1; |
1365 | themode = (filemode)?filemode:0644; |
1673 | themode = (filemode)?filemode:0644; |
1366 | thesize = 0; |
1674 | thesize = -1; |
1367 | } |
1675 | } |
1368 | else { |
1676 | else { |
1369 | if (linperfile <= 0) |
1677 | if (linperfile <= 0) |
1370 | numparts = 1; |
1678 | numparts = 1; |
1371 | else |
1679 | else |
… | |
… | |
1386 | filemode = (int) finfo.st_mode & 0777; |
1694 | filemode = (int) finfo.st_mode & 0777; |
1387 | thesize = (long) finfo.st_size; |
1695 | thesize = (long) finfo.st_size; |
1388 | } |
1696 | } |
1389 | theifile = infile; |
1697 | theifile = infile; |
1390 | } |
1698 | } |
|
|
1699 | |
1391 | /* |
1700 | /* |
1392 | * if there's one part only, don't use Message/Partial |
1701 | * if there's one part only, don't use Message/Partial |
1393 | */ |
1702 | */ |
1394 | |
1703 | |
1395 | if (numparts == 1) { |
1704 | if (numparts == 1) { |
… | |
… | |
1400 | } |
1709 | } |
1401 | |
1710 | |
1402 | /* |
1711 | /* |
1403 | * we also need a unique ID |
1712 | * we also need a unique ID |
1404 | */ |
1713 | */ |
|
|
1714 | |
1405 | sprintf (mimeid, "UUDV-%ld.%ld.%s", |
1715 | sprintf (mimeid, "UUDV-%ld.%ld.%s", |
1406 | (long) time(NULL), thesize, |
1716 | (long) time(NULL), thesize, |
1407 | (strlen(oname)>16)?"oops":oname); |
1717 | (strlen(oname)>16)?"oops":oname); |
1408 | } |
1718 | } |
1409 | |
1719 | |
… | |
… | |
1412 | uustring (S_OUT_OF_MEMORY), len); |
1722 | uustring (S_OUT_OF_MEMORY), len); |
1413 | if (infile==NULL) fclose (theifile); |
1723 | if (infile==NULL) fclose (theifile); |
1414 | return UURET_NOMEM; |
1724 | return UURET_NOMEM; |
1415 | } |
1725 | } |
1416 | |
1726 | |
|
|
1727 | |
|
|
1728 | if (encoding == YENC_ENCODED) { |
|
|
1729 | if (partno == 1) |
|
|
1730 | crc = crc32(0L, Z_NULL, 0); |
|
|
1731 | crcptr = &crc; |
1417 | if (subject) |
1732 | if (subject) |
|
|
1733 | sprintf (subline, "- %s - %s (%03d/%03d)", oname, subject, |
|
|
1734 | partno, numparts); |
|
|
1735 | else |
|
|
1736 | sprintf (subline, "- %s - (%03d/%03d)", oname, |
|
|
1737 | partno, numparts); |
|
|
1738 | } |
|
|
1739 | else { |
|
|
1740 | if (subject) |
1418 | sprintf (subline, "%s (%03d/%03d) - [ %s ]", |
1741 | sprintf (subline, "%s (%03d/%03d) - [ %s ]", |
1419 | subject, partno, numparts, oname); |
1742 | subject, partno, numparts, oname); |
1420 | else |
1743 | else |
1421 | sprintf (subline, "[ %s ] (%03d/%03d)", |
1744 | sprintf (subline, "[ %s ] (%03d/%03d)", |
1422 | oname, partno, numparts); |
1745 | oname, partno, numparts); |
|
|
1746 | } |
1423 | |
1747 | |
1424 | if (from) { |
1748 | if (from) { |
1425 | fprintf (outfile, "From: %s%s", from, eolstring); |
1749 | fprintf (outfile, "From: %s%s", from, eolstring); |
1426 | } |
1750 | } |
1427 | |
1751 | |
… | |
… | |
1435 | |
1759 | |
1436 | if (replyto) { |
1760 | if (replyto) { |
1437 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1761 | fprintf (outfile, "Reply-To: %s%s", replyto, eolstring); |
1438 | } |
1762 | } |
1439 | |
1763 | |
|
|
1764 | if (encoding != YENC_ENCODED) { |
1440 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1765 | fprintf (outfile, "MIME-Version: 1.0%s", eolstring); |
1441 | fprintf (outfile, "Content-Type: Message/Partial; number=%d; total=%d;%s", |
1766 | fprintf (outfile, "Content-Type: Message/Partial; number=%d; total=%d;%s", |
1442 | partno, numparts, eolstring); |
1767 | partno, numparts, eolstring); |
1443 | fprintf (outfile, "\tid=\"%s\"%s", |
1768 | fprintf (outfile, "\tid=\"%s\"%s", |
1444 | mimeid, eolstring); |
1769 | mimeid, eolstring); |
|
|
1770 | } |
|
|
1771 | |
1445 | fprintf (outfile, "%s", eolstring); |
1772 | fprintf (outfile, "%s", eolstring); |
1446 | |
1773 | |
1447 | res = UUEncodePartial (outfile, theifile, |
1774 | res = UUEncodePartial (outfile, theifile, |
1448 | infname, encoding, |
1775 | infname, encoding, |
1449 | (outfname)?outfname:infname, NULL, |
1776 | (outfname)?outfname:infname, NULL, |
1450 | themode, partno, linperfile); |
1777 | themode, partno, linperfile, crcptr); |
1451 | |
1778 | |
1452 | FP_free (subline); |
1779 | _FP_free (subline); |
1453 | |
1780 | |
1454 | if (infile==NULL) { |
1781 | if (infile==NULL) { |
1455 | if (res != UURET_OK) { |
1782 | if (res != UURET_OK) { |
1456 | fclose (theifile); |
1783 | fclose (theifile); |
1457 | return res; |
1784 | return res; |