Can't decode encoding x-uuencode

Can't decode encoding x-uuencode

[Niels Olof Bouvin]

Hi

I often get MIME mails with uuencoded attachments. When I try to 'o' the
attachments, I am informed that 'Can't decode encoding x-uuencode'.
What should I change to make this work? 

Another thing: Does pGnus work with mailcap? I'm using pGnus under WinNT,
and before I changed to pGnus (aye, in the days of yore, in days of qGnus!),
I used MetaMail, and it (using mailcap and shelex) launched the proper
viewers.

Cheers
	Niels Olof


-- 
Niels Olof Bouvin http://www.daimi.aau.dk/~bouvin/ Voice: (+45)89425642 \ /
In omnibus requiem quaesivi, et nusquam inveni nisi in angulo cum libro (")
M.Sc.  Ph.D. Student @ C.S. Dept., Århus University, Denmark. ICQ: 17005775
.

Re: Can't decode encoding x-uuencode

[Lars Magne Ingebrigtsen]

Niels Olof Bouvin <n.o.bouvin@daimi.aau.dk> writes:

> I often get MIME mails with uuencoded attachments. When I try to 'o' the
> attachments, I am informed that 'Can't decode encoding x-uuencode'.
> What should I change to make this work? 

I've added this to the todo list.

> Another thing: Does pGnus work with mailcap?

It's supposed to work; yes.

-- 
(domestic pets only, the antidote for overdose, milk.)
  larsi@gnus.org * Lars Magne Ingebrigtsen

Re: Can't decode encoding x-uuencode

[Shenghuo ZHU]

>>>>> "LMI" == Lars Magne Ingebrigtsen <larsi@gnus.org> writes:

LMI> Niels Olof Bouvin <n.o.bouvin@daimi.aau.dk> writes:
>> I often get MIME mails with uuencoded attachments. When I try to 'o' the
>> attachments, I am informed that 'Can't decode encoding x-uuencode'.
>> What should I change to make this work? 

LMI> I've added this to the todo list.

Untested solution:

1. Extract the attachment to loadpath;
2. Modefy mm-bodies.el(mm-decode-content-transfer-encoding) as
    follows;
3. Test it or send me a sample. :-)

(require 'uudecode) 

(defun mm-decode-content-transfer-encoding (encoding)
  (cond
   ((eq encoding 'quoted-printable)
    (quoted-printable-decode-region (point-min) (point-max)))
   ((eq encoding 'base64)
    (condition-case ()
	(base64-decode-region (point-min) (point-max))
      (error nil)))
   ((memq encoding '(7bit 8bit binary))
    )
   ((null encoding)
    )
   ((eq encoding 'x-uuencode)
    (condition-case ()
	(uu-decode-region (point-min) (point-max))
      (error nil)))
   ((fboundp encoding)
    (funcall encoding (point-min) (point-max))
    )
   (t
    (error "Can't decode encoding %s" encoding))))


-- 
Shenghuo

----------------------------------------------------------------------
;;; uudecode.el -- elisp native uudecode
;;; Copyright (c) 1998 by Shenghuo Zhu <zsh@cs.rochester.edu>

;; Author: Shenghuo Zhu <zsh@cs.rochester.edu>
;; $Revision: 1.1 $
;; Keywords: uudecode

;;; This file is not part of GNU Emacs, but the same permissions
;;; apply.
;;;
;;; GNU Emacs is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2, or (at your option)
;;; any later version.
;;;
;;; GNU Emacs is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Emacs; see the file COPYING.  If not, write to the
;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;;; Boston, MA 02111-1307, USA.

;;; Commentary:
;;;     Lots of codes are stolen from mm-decode.el, gnus-uu.el and
;;;     base64.el

;;; Code:

(if (not (fboundp 'char-int))
    (fset 'char-int 'identity))

(defvar uu-decoder-program "uudecode"
  "*Non-nil value should be a string that names a uu decoder.
The program should expect to read uu data on its standard
input and write the converted data to its standard output.")

(defvar uu-decoder-switches nil
  "*List of command line flags passed to the command named by
uu-decoder-program.")

(defvar uu-alphabet "\040-\140")

(defvar uu-begin-string "^begin[ \t]+[0-7][0-7][0-7][ \t]+\\(.*\\)$")
(defvar uu-end-string "^end[ \t]*$")

(defvar uu-body-line
  (let ((i 61) (str "^M"))
    (while (> (setq i (1- i)) 0)
      (setq str (concat str "[^a-z]")))
    (concat str ".?$")))

(defvar uu-temporary-file-directory "/tmp/")

(defun uu-decode-region-external (start end &optional file-name)
  ""
  (interactive "r\nP")
  (let ((cbuf (current-buffer)) tempfile firstline work-buffer status) 
    (save-excursion
      (goto-char start)
      (when (re-search-forward uu-begin-string nil t)
	(forward-line 1)
	(setq firstline (point))
	(cond ((null file-name))
	      ((stringp file-name))
	      (t 
	       (setq file-name (read-file-name "File to Name:" 
					       nil nil nil 
					       (match-string 1)))))
	(setq tempfile (expand-file-name
			(or file-name (concat uu-temporary-file-directory
					      (make-temp-name "uu")))))
	(let ((cdir default-directory) default-process-coding-system)
	  (unwind-protect
	      (progn
		(set-buffer (setq work-buffer 
				  (generate-new-buffer " *uudecode-work*")))
		(buffer-disable-undo work-buffer)
		(insert "begin 600 " (file-name-nondirectory tempfile) "\n")
		(insert-buffer-substring cbuf firstline end)
		(cd (file-name-directory tempfile))
		(apply 'call-process-region
		       (point-min)
		       (point-max)
		       uu-decoder-program 
		       nil
		       nil
		       nil
		       uu-decoder-switches))
	    (cd cdir) (set-buffer cbuf)))
	(if (file-exists-p tempfile)
	    (unless file-name
	      (goto-char start)
	      (delete-region start end)
	      (let (format-alist)
		(if (fboundp 'insert-file-contents-internal)
		    (insert-file-contents-internal tempfile)
		(insert-file-contents tempfile))))
	  (message "Can not uudecode")))
      (and work-buffer (kill-buffer work-buffer))
      (condition-case ()
	  (or file-name (delete-file tempfile))
	(error))
      )))

(defun uu-insert-char (char &optional count ignored buffer)
  (condition-case nil
      (progn
	(insert-char char count ignored buffer)
	(fset 'uu-insert-char 'insert-char))
    (wrong-number-of-arguments
     (fset 'uu-insert-char 'uu-xemacs-insert-char)
     (uu-insert-char char count ignored buffer))))

(defun uu-xemacs-insert-char (char &optional count ignored buffer)
  (if (or (null buffer) (eq buffer (current-buffer)))
      (insert-char char count)
    (save-excursion
      (set-buffer buffer)
      (insert-char char count))))

(defun uu-decode-region (start end &optional file-name)
  (interactive "r\nP")
  (let ((work-buffer nil)
	(done nil)
	(counter 0)
	(remain 0)
	(bits 0)
	(lim 0) inputpos
	(non-data-chars (concat "^" uu-alphabet)))
    (unwind-protect
	(save-excursion
	  (goto-char start)
	  (when (re-search-forward uu-begin-string nil t)
	    (cond ((null file-name))
		  ((stringp file-name))
		  (t 
		   (setq file-name (expand-file-name 
				    (read-file-name "File to Name:" 
						    nil nil nil 
						    (match-string 1))))))
	    (setq work-buffer (generate-new-buffer " *uudecode-work*"))
	    (buffer-disable-undo work-buffer)
	    (forward-line 1)
	    (skip-chars-forward non-data-chars end)
	    (while (not done)
	      (setq inputpos (point))
	      (setq remain 0 bits 0 counter 0)
	      (cond
	       ((> (skip-chars-forward uu-alphabet end) 0)
		(setq lim (point))
		(setq remain 
		      (logand (- (char-int (char-after inputpos)) 32) 63))
		(setq inputpos (1+ inputpos))
		(if (= remain 0) (setq done t))
		(while (and (< inputpos lim) (> remain 0))
		  (setq bits (+ bits 
				(logand 
				 (- 
				  (char-int (char-after inputpos)) 32) 63)))
		  (if (/= counter 0) (setq remain (1- remain)))
		  (setq counter (1+ counter)
			inputpos (1+ inputpos))
		  (cond ((= counter 4)
			 (uu-insert-char (lsh bits -16) 1 nil work-buffer)
			 (uu-insert-char (logand (lsh bits -8) 255) 1 nil
					 work-buffer)
			 (uu-insert-char (logand bits 255) 1 nil
					 work-buffer)
			 (setq bits 0 counter 0))
			(t (setq bits (lsh bits 6)))))))
	      (cond
		 (done)
		 ((> 0 remain)
		  (error "uucode line ends unexpectly")
		  (setq done t))
		 ((and (= (point) end) (not done))
		  (error "uucode ends unexpectly")
		  (setq done t))
		 ((= counter 3)
		  (uu-insert-char (logand (lsh bits -16) 255) 1 nil 
				  work-buffer)
		  (uu-insert-char (logand (lsh bits -8) 255) 1 nil
				  work-buffer))
		 ((= counter 2)
		  (uu-insert-char (logand (lsh bits -10) 255) 1 nil 
				  work-buffer)))
	      (skip-chars-forward non-data-chars end))
	    (if file-name
		(save-excursion
		  (set-buffer work-buffer)
		  (write-file file-name))
	      (or (markerp end) (setq end (set-marker (make-marker) end)))
	      (goto-char start)
	      (insert-buffer-substring work-buffer)
	      (delete-region (point) end))))
      (and work-buffer (kill-buffer work-buffer)))))

(provide 'uudecode)
;; end of uudecode.el

Re: Can't decode encoding x-uuencode

[Steinar Bang]

>>>>> Niels Olof Bouvin <n.o.bouvin@daimi.aau.dk>:

> I often get MIME mails with uuencoded attachments. When I try to 'o'
> the attachments, I am informed that 'Can't decode encoding
> x-uuencode'.  What should I change to make this work?

What does it look like? Do you have an example of the MIME headers of
one of the uuencoded attachments you've been receiving (only the
headers are of interest.  Don't forward the entire attachment to the
list (that probably goes without saying (but I don't want the blame in 
case it should happen))).