Translated.

diff --git a/sasl-ja.texi b/sasl-ja.texi
index 15fd321..4242f94 100644 (file)
--- a/sasl-ja.texi
+++ b/sasl-ja.texi
@@ -12,7 +12,7 @@
 @settitle Emacs SASL Library @value{VERSION}
 
 @ifinfo
-This file describes the Emacs SASL library.
+\e$B$3$N%U%!%$%k$O\e(B Emacs SASL \e$B%i%$%V%i%j!<$r@bL@$7$^$9!#\e(B
 
 Copyright (C) 2000 Daiki Ueno.
 
@@ -47,6 +47,12 @@ any later version published by the Free Software Foundation; with no
 Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
 Texts.  A copy of the license is included in the section entitled "GNU
 Free Documentation License".
+
+\e$B$3$NJ8=q$r!"%U%j!<%=%U%H%&%'%":bCDH/9T$N\e(B GNU \e$B%U%j!<J8=qMxMQ5vBz7@Ls=q\e(B
+\e$BBh\e(B 1.1 \e$BHG$^$?$O$=$l0J9_$NHG$,Dj$a$k>r7o$N2<$GJ#@=!"G[I[!"$"$k$$$OJQ99$9\e(B
+\e$B$k$3$H$r5v2D$7$^$9!#JQ99IT2DItJ,!"I=I=;f%F%-%9%H$*$h$SN"I=;f%F%-%9%H$O;X\e(B
+\e$BDj$7$^$;$s!#$3$NMxMQ5vBz7@Ls=q$NJ#<L$O!V\e(BGNU \e$B%U%j!<J8=qMxMQ5vBz7@Ls=q!W$H\e(B
+\e$B$$$&>O$K4^$^$l$F$$$^$9!#\e(B
 @end titlepage
 @page
 
@@ -54,203 +60,201 @@ Free Documentation License".
 
 @node Top
 @top Emacs SASL
-This manual describes the Emacs SASL library.
 
-A common interface to share several authentication mechanisms between
-applications using different protocols.
+\e$B$3$N%^%K%e%"%k$O\e(B Emacs SASL \e$B%i%$%V%i%j!<$r@bL@$7$^$9!#\e(B
+
+\e$B0[$J$k%W%m%H%3%k$r;H$&%"%W%j%1!<%7%g%s4V$G!"J#?t$NG'>Z%a%+%K%:%`$r6&M-$9\e(B
+\e$B$k$?$a$N6&DL%$%s%?!<%U%'!<%9$G$9!#\e(B
 
 @menu
-* Overview::                    What Emacs SASL library is.
-* How to use::                  Adding authentication support to your applications.
-* Data types::                  
-* Back end drivers::             Writing your own drivers.
-* Index::                       
-* Function Index::              
-* Variable Index::              
+* Overview::                    Emacs SASL \e$B%i%$%V%i%j!<$H$O\e(B
+* How to use::                  \e$B%"%W%j%1!<%7%g%s$KG'>Z%5%]!<%H$rDI2C$9$k\e(B
+* Data types::
+* Back end drivers::            \e$BFH<+$N%I%i%$%P!<$r=q$/\e(B
+* Index::
+* Function Index::
+* Variable Index::
 @end menu
 
 @node Overview
-@chapter Overview
+@chapter \e$BBgMW\e(B
 
-@sc{sasl} is short for @dfn{Simple Authentication and Security Layer}.
-This standard is documented in RFC2222.  It provides a simple method for
-adding authentication support to various application protocols.
+@sc{sasl} \e$B$O\e(B @dfn{Simple Authentication and Security Layer} \e$B$NN,$G$9!#I8\e(B
+\e$B=`$O\e(B RFC2222 \e$B$KJ8=q2=$5$l$F$$$^$9!#$3$l$O!"$5$^$6$^$J%"%W%j%1!<%7%g%s!&\e(B
+\e$B%W%m%H%3%k$K!"G'>Z%5%]!<%H$rDI2C$9$k$?$a$N4JC1$J<jCJ$rDs6!$7$^$9!#\e(B
 
-The toplevel interface of this library is inspired by Java @sc{sasl}
-Application Program Interface.  It defines an abstraction over a series
-of authentication mechanism drivers (@ref{Back end drivers}).
+\e$B$3$N%i%$%V%i%j!<$N:G>e0L$N%$%s%?!<%U%'!<%9$O!"\e(BJava @sc{sasl} Application
+Program Interface \e$B$K$h$C$F?(H/$5$l$^$7$?!#$=$l$O!"Cj>]2=$7$?0lO"$NG'>Z%a\e(B
+\e$B%+%K%:%`$N%I%i%$%P!<$rDj5A$7$^$9!#\e(B
 
-Back end drivers are designed to be close as possible to the
-authentication mechanism.  You can access the additional configuration
-information anywhere from the implementation.
+\e$B%P%C%/%(%s%I$N%I%i%$%P!<$O!"$J$k$Y$/G'>Z%a%+%K%:%`$KL)@\$7$F$$$k$3$H$rL\\e(B
+\e$B;X$7$F$$$^$9!#$I$3$K$"$kDI2C$N@_Dj>pJs$K$b!"$3$N<BAu$+$i%"%/%;%9$9$k$3$H\e(B
+\e$B$,$G$-$^$9!#\e(B
 
 @node How to use
-@chapter How to use
+@chapter \e$B;H$$J}\e(B
 
-(Not yet written).
+(\e$B$^$@=q$+$l$F$$$^$;$s\e(B)\e$B!#\e(B
 
-To use Emacs SASL library, please evaluate following expression at the
-beginning of your application program.
+Emacs SASL \e$B%i%$%V%i%j!<$r;H$&$K$O!"%"%W%j%1!<%7%g%s!&%W%m%0%i%`$N:G=i$G!"\e(B
+\e$B0J2<$N<0$rI>2A$7$F2<$5$$!#\e(B
 
 @lisp
 (require 'sasl)
 @end lisp
 
-If you want to check existence of sasl.el at runtime, instead you
-can list autoload settings for functions you want.
+\e$B<B9T;~$K$N$_\e(B sasl.el \e$B$,B8:_$7$F$$$k$3$H$r8!::$7$?$$$J$i$P!"Be$o$j$KI,MW\e(B
+\e$B$J4X?t$N\e(B autoload \e$B$N@_Dj$rJB$Y$F$*$$$F$b9=$$$^$;$s!#\e(B
 
 @node Data types
-@chapter Data types
+@chapter \e$B%G!<%?$N7?\e(B
 
-There are three data types to be used for carrying a negotiated
-security layer---a mechanism, a client parameter and an authentication
-step.
+\e$B%M%4%7%(!<%H$5$l$?%;%-%e%j%F%#!<AX$NEAAw$K;H$o$l$k;0$D$N%G!<%?$N7?$H$7$F!"\e(B
+\e$B%a%+%K%:%`!"%/%i%$%"%s%H!&%Q%i%a!<%?!"$*$h$SG'>Z%9%F%C%W$,$"$j$^$9!#\e(B
 
 @menu
-* Mechanisms::                  
-* Clients::                     
-* Steps::                       
+* Mechanisms::
+* Clients::
+* Steps::
 @end menu
 
 @node Mechanisms
-@section Mechanisms
+@section \e$B%a%+%K%:%`\e(B
 
-A mechanism (@code{sasl-mechanism} object) is a schema of the @sc{sasl}
-authentication mechanism driver.
+\e$B%a%+%K%:%`\e(B (@code{sasl-mechanism} \e$B%*%V%8%'%/%H\e(B) \e$B$,!"\e(B@sc{sasl} \e$BG'>Z%a%+%K\e(B
+\e$B%:%`$N%I%i%$%P!<$N\e(B schema \e$B$G$9!#\e(B
 
 @defvar sasl-mechanisms
-A list of mechanism names.
+\e$B%a%+%K%:%`L>$N%j%9%H!#\e(B
 @end defvar
 
 @defun sasl-find-mechanism mechanisms
+\e$BE,@Z$J%a%+%K%:%`$r<hF@$7$^$9!#\e(B@*
+\e$B$3$N4X?t$O\e(B @var{mechanisms} \e$B$H\e(B @code{sasl-mechanisms} \e$B$rHf3S$7$F!"E,@Z\e(B
+\e$B$J\e(B @code{sasl-mechanism} \e$B%*%V%8%'%/%H$rJV$7$^$9!#\e(B
 
-Retrieve an apropriate mechanism.
-This function compares @var{mechanisms} and @code{sasl-mechanisms} then
-returns apropriate @code{sasl-mechanism} object.
-
-@example
+@lisp
 (let ((sasl-mechanisms '("CRAM-MD5" "DIGEST-MD5")))
   (setq mechanism (sasl-find-mechanism server-supported-mechanisms)))
-@end example
-
+@end lisp
 @end defun
 
 @defun sasl-mechanism-name mechanism
-Return name of mechanism, a string.
+\e$B%a%+%K%:%`$NL>A0$rJ8;zNs$GJV$7$^$9!#\e(B
 @end defun
 
-If you want to write an authentication mechanism driver (@ref{Back end
-drivers}), use @code{sasl-make-mechanism} and modify
-@code{sasl-mechanisms} and @code{sasl-mechanism-alist} correctly.
+\e$BG'>Z%a%+%K%:%`$N%I%i%$%P!<\e(B (@ref{Back end drivers}) \e$B$r=q$-$?$1$l$P!"\e(B
+@code{sasl-make-mechanism} \e$B$r;H$$!"\e(B@code{sasl-mechanisms} \e$B$*$h\e(B
+\e$B$S\e(B @code{sasl-mechanism-alist} \e$B$r@5$7$/JQ99$7$F2<$5$$!#\e(B
 
 @defun sasl-make-mechanism name steps
-Allocate a @code{sasl-mechanism} object.
-This function takes two parameters---name of the mechanism, and a list
-of authentication functions.
+@code{sasl-mechanism} \e$B%*%V%8%'%/%H$r3d$jEv$F$^$9!#\e(B@*
+\e$B$3$N4X?t$OFs$D$N%Q%i%a!<%?!"$9$J$o$A%a%+%K%:%`$NL>A0!"$*$h$SG'>Z$9$k$?$a\e(B
+\e$B$N4X?t$N%j%9%H$r<u$1<h$j$^$9!#\e(B
 
-@example
+@lisp
 (defconst sasl-anonymous-steps
-  '(identity                           ;no initial response
+  '(identity                            ; \e$B:G=i$O1~EzL5$7\e(B
     sasl-anonymous-response))
 
 (put 'sasl-anonymous 'sasl-mechanism
      (sasl-make-mechanism "ANONYMOUS" sasl-anonymous-steps))
-@end example
-
+@end lisp
 @end defun
 
 @node Clients
-@section Clients
+@section \e$B%/%i%$%"%s%H\e(B
 
-A client (@code{sasl-client} object) initialized with four
-parameters---a mechanism, a user name, name of the service and name of
-the server.
+\e$B%/%i%$%"%s%H\e(B (@code{sasl-client} \e$B%*%V%8%'%/%H\e(B) \e$B$O;M$D$N%Q%i%a!<%?!"$9$J\e(B
+\e$B$o$A%a%+%K%:%`!"%f!<%6!<L>!"%5!<%S%9L>!"$*$h$S%5!<%P!<L>$K$h$C$F=i4|2=$5\e(B
+\e$B$l$^$9!#\e(B
 
 @defun sasl-make-client mechanism name service server
-Prepare a @code{sasl-client} object.
+@code{sasl-client} \e$B%*%V%8%'%/%H$rMQ0U$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-mechanism client
-Return the mechanism (@code{sasl-mechanism} object) of client.
+\e$B%/%i%$%"%s%H$N%a%+%K%:%`\e(B (@code{sasl-mechanism} \e$B%*%V%8%'%/%H\e(B) \e$B$rJV$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-name client
-Return the authorization name of client, a string.
+\e$B%/%i%$%"%s%H$NG'>ZL>$rJ8;zNs$GJV$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-service client
-Return the service name of client, a string.
+\e$B%/%i%$%"%s%H$N%5!<%S%9L>$rJ8;zNs$GJV$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-server client
-Return the server name of client, a string.
+\e$B%/%i%$%"%s%H$N%5!<%P!<L>$rJ8;zNs$GJV$7$^$9!#\e(B
 @end defun
 
-If you want to specify additional configuration properties, please use
-@code{sasl-client-set-property}.
+\e$BB0@-$N@_Dj$rDI2C$7$?$$>l9g$O!"\e(B@code{sasl-client-set-property} \e$B$r;H$C$F2<\e(B
+\e$B$5$$!#\e(B
 
 @defun sasl-client-set-property client property value
-Add the given property/value to client.
+\e$BM?$($i$l$?B0@-$*$h$S$=$NCM$r%/%i%$%"%s%H$KDI2C$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-property client property
-Return the value of the property of client.
+\e$B%/%i%$%s%H$NB0@-$NCM$rJV$7$^$9!#\e(B
 @end defun
 
 @defun sasl-client-set-properties client plist
-Destructively set the properties of client.
-The second argument is the new property list.
+\e$B%/%i%$%"%s%H$NB0@-$rGK2uE*$K@_Dj$7$^$9!#\e(B@*
+\e$BBhFs0z?t$O?7$7$$%W%m%Q%F%#!<!&%j%9%H\e(B (plist) \e$B$G$9!#\e(B
 @end defun
 
 @defun sasl-client-properties client
-Return the whole property list of client configuration.
+\e$B%/%i%$%"%s%H$N@_Dj$N%W%m%Q%F%#!<!&%j%9%H$r!"$^$k$4$HJV$7$^$9!#\e(B
 @end defun
 
 @node Steps
-@section Steps
+@section \e$B%9%F%C%W\e(B
 
-A step (@code{sasl-step} object) is an abstraction of authentication
-``step'' which holds the response value and the next entry point for the
-authentication process (the latter is not accessible).
+\e$B%9%F%C%W\e(B (@code{sasl-step} \e$B%*%V%8%'%/%H\e(B) \e$B$OG'>Z%9%F%C%W$NCj>]2=$G$9!#$=\e(B
+\e$B$l$O!"1~Ez$NCM$H<!2s$NG'>Z=hM}$NF~$j8}$rJ];}$7$^$9\e(B (\e$B8e<T$O%"%/%;%9$G$-$^\e(B
+\e$B$;$s\e(B)\e$B!#\e(B
 
 @defun sasl-step-data step
-Return the data which @var{step} holds, a string.
+@var{step} \e$B$,J];}$9$k%G!<%?$rJ8;zNs$GJV$7$^$9!#\e(B
 @end defun
 
 @defun sasl-step-set-data step data
-Store @var{data} string to @var{step}.
+@var{step} \e$B$K\e(B @var{data} \e$B$NJ8;zNs$r3JG<$7$^$9!#\e(B
 @end defun
 
-To get the initial response, you should call the function
-@code{sasl-next-step} with the second argument @code{nil}.
+\e$B:G=i$N1~Ez$rF@$k$K$O!"BhFs0z?t$r\e(B @code{nil} \e$B$K$7$F4X\e(B
+\e$B?t\e(B @code{sasl-next-step} \e$B$r8F$P$J$1$l$P$J$j$^$;$s!#\e(B
 
-@example
+@lisp
 (setq name (sasl-mechanism-name mechanism))
-@end example
+@end lisp
 
-At this point we could send the command which starts a SASL
-authentication protocol exchange.  For example,
+\e$B$3$NCJ3,$G!"\e(BSASL \e$B$NG'>Z%W%m%H%3%k$N8r49$r3+;O$9$k%3%^%s%I$rAw$k$3$H$,$G\e(B
+\e$B$-$^$9!#Nc$G$9!#\e(B
 
-@example
+@lisp
 (process-send-string
  process
- (if (sasl-step-data step)             ;initial response
-     (format "AUTH %s %s\r\n" name (base64-encode-string (sasl-step-data step) t))
+ (if (sasl-step-data step)              ; \e$B:G=i$N1~Ez\e(B
+     (format "AUTH %s %s\r\n"
+             name (base64-encode-string (sasl-step-data step) t))
    (format "AUTH %s\r\n" name)))
-@end example
+@end lisp
 
-To go on with the authentication process, all you have to do is call
-@code{sasl-next-step} consecutively.
+\e$BG'>Z=hM}$rB3$1$k$?$a$K9T$J$o$J$1$l$P$J$i$J$$$3$H$O!"O"B3$7\e(B
+\e$B$F\e(B @code{sasl-next-step} \e$B$r8F$V$3$H$G$9!#\e(B
 
 @defun sasl-next-step client step
-Perform the authentication step.
-At the first time @var{step} should be set to @code{nil}.
+\e$BG'>Z%9%F%C%W$r<B9T$7$^$9!#\e(B@*
+\e$B:G=i$O\e(B @var{step} \e$B$r\e(B @code{nil} \e$B$K@_Dj$7$J$1$l$P$J$j$^$;$s!#\e(B
 @end defun
 
 @node Back end drivers
-@chapter Back end drivers
+@chapter \e$B%P%C%/%(%s%I!&%I%i%$%P!<\e(B
 
-(Not yet written).
+(\e$B$^$@=q$+$l$F$$$^$;$s\e(B)\e$B!#\e(B
 
 @node Index
 @chapter Index