/*****************************************************************
    * Licensed to the Apache Software Foundation (ASF) under one   *
    * or more contributor license agreements.  See the NOTICE file *
    * distributed with this work for additional information        *
    * regarding copyright ownership.  The ASF licenses this file   *
    * to you under the Apache License, Version 2.0 (the            *
    * "License"); you may not use this file except in compliance   *
    * with the License.  You may obtain a copy of the License at   *
    *                                                              *
   *   http://www.apache.org/licenses/LICENSE-2.0                 *
   *                                                              *
   * Unless required by applicable law or agreed to in writing,   *
   * software distributed under the License is distributed on an  *
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
   * KIND, either express or implied.  See the License for the    *
   * specific language governing permissions and limitations      *
   * under the License.                                           *
   ****************************************************************/
  
  package org.apache.james.nntpserver;
  
  import org.apache.avalon.cornerstone.services.connection.ConnectionHandler;
  import org.apache.avalon.excalibur.pool.Poolable;
  import org.apache.avalon.framework.container.ContainerUtil;
  import org.apache.avalon.framework.logger.AbstractLogEnabled;
  import org.apache.james.core.MailHeaders;
  import org.apache.james.nntpserver.repository.NNTPArticle;
  import org.apache.james.nntpserver.repository.NNTPGroup;
  import org.apache.james.util.CharTerminatedInputStream;
  import org.apache.james.util.DotStuffingInputStream;
  import org.apache.james.util.ExtraDotOutputStream;
  import org.apache.james.util.InternetPrintWriter;
  import org.apache.mailet.dates.RFC977DateFormat;
  import org.apache.mailet.dates.RFC2980DateFormat;
  import org.apache.mailet.dates.SimplifiedDateFormat;
  import org.apache.james.util.watchdog.Watchdog;
  import org.apache.james.util.watchdog.WatchdogTarget;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.BufferedReader;
  import java.io.ByteArrayInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.io.SequenceInputStream;
  import java.net.Socket;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Locale;
  import java.util.StringTokenizer;
  import javax.mail.MessagingException;
  
  /***
   * The NNTP protocol is defined by RFC 977.
   * This implementation is based on IETF draft 15, posted on 15th July '2002.
   * URL: http://www.ietf.org/internet-drafts/draft-ietf-nntpext-base-15.txt
   *
   * Common NNTP extensions are in RFC 2980.
   */
  public class NNTPHandler
      extends AbstractLogEnabled
      implements ConnectionHandler, Poolable {
  
      /***
       * used to calculate DATE from - see 11.3
       */
      private static final SimplifiedDateFormat DF_RFC977 = new RFC977DateFormat();
  
      /***
       * Date format for the DATE keyword - see 11.1.1
       */
      private static final SimplifiedDateFormat DF_RFC2980 = new RFC2980DateFormat();
  
      /***
       * The UTC offset for this time zone.
       */
      public static final long UTC_OFFSET = Calendar.getInstance().get(Calendar.ZONE_OFFSET);
  
      /***
       * The text string for the NNTP MODE command.
       */
      private final static String COMMAND_MODE = "MODE";
  
      /***
       * The text string for the NNTP LIST command.
       */
      private final static String COMMAND_LIST = "LIST";
  
      /***
       * The text string for the NNTP GROUP command.
       */
      private final static String COMMAND_GROUP = "GROUP";
 
     /***
      * The text string for the NNTP NEXT command.
      */
     private final static String COMMAND_NEXT = "NEXT";
 
     /***
      * The text string for the NNTP LAST command.
      */
     private final static String COMMAND_LAST = "LAST";
 
     /***
      * The text string for the NNTP ARTICLE command.
      */
     private final static String COMMAND_ARTICLE = "ARTICLE";
 
     /***
      * The text string for the NNTP HEAD command.
      */
     private final static String COMMAND_HEAD = "HEAD";
 
     /***
      * The text string for the NNTP BODY command.
      */
     private final static String COMMAND_BODY = "BODY";
 
     /***
      * The text string for the NNTP STAT command.
      */
     private final static String COMMAND_STAT = "STAT";
 
     /***
      * The text string for the NNTP POST command.
      */
     private final static String COMMAND_POST = "POST";
 
     /***
      * The text string for the NNTP IHAVE command.
      */
     private final static String COMMAND_IHAVE = "IHAVE";
 
     /***
      * The text string for the NNTP QUIT command.
      */
     private final static String COMMAND_QUIT = "QUIT";
 
     /***
      * The text string for the NNTP SLAVE command.
      */
     private final static String COMMAND_SLAVE = "SLAVE";
 
     /***
      * The text string for the NNTP DATE command.
      */
     private final static String COMMAND_DATE = "DATE";
 
     /***
      * The text string for the NNTP HELP command.
      */
     private final static String COMMAND_HELP = "HELP";
 
     /***
      * The text string for the NNTP NEWGROUPS command.
      */
     private final static String COMMAND_NEWGROUPS = "NEWGROUPS";
 
     /***
      * The text string for the NNTP NEWNEWS command.
      */
     private final static String COMMAND_NEWNEWS = "NEWNEWS";
 
     /***
      * The text string for the NNTP LISTGROUP command.
      */
     private final static String COMMAND_LISTGROUP = "LISTGROUP";
 
     /***
      * The text string for the NNTP OVER command.
      */
     private final static String COMMAND_OVER = "OVER";
 
     /***
      * The text string for the NNTP XOVER command.
      */
     private final static String COMMAND_XOVER = "XOVER";
 
     /***
      * The text string for the NNTP HDR command.
      */
     private final static String COMMAND_HDR = "HDR";
 
     /***
      * The text string for the NNTP XHDR command.
      */
     private final static String COMMAND_XHDR = "XHDR";
 
     /***
      * The text string for the NNTP AUTHINFO command.
      */
     private final static String COMMAND_AUTHINFO = "AUTHINFO";
 
     /***
      * The text string for the NNTP PAT command.
      */
     private final static String COMMAND_PAT = "PAT";
 
     /***
      * The text string for the NNTP MODE READER parameter.
      */
     private final static String MODE_TYPE_READER = "READER";
 
     /***
      * The text string for the NNTP MODE STREAM parameter.
      */
     private final static String MODE_TYPE_STREAM = "STREAM";
 
     /***
      * The text string for the NNTP AUTHINFO USER parameter.
      */
     private final static String AUTHINFO_PARAM_USER = "USER";
 
     /***
      * The text string for the NNTP AUTHINFO PASS parameter.
      */
     private final static String AUTHINFO_PARAM_PASS = "PASS";
 
     /***
      * The character array that indicates termination of an NNTP message
      */
     private final static char[] NNTPTerminator = { '\r', '\n', '.', '\r', '\n' };
 
     /***
      * The thread executing this handler 
      */
     private Thread handlerThread;
 
     /***
      * The remote host name obtained by lookup on the socket.
      */
     private String remoteHost;
 
     /***
      * The remote IP address of the socket.
      */
     private String remoteIP;
 
     /***
      * The TCP/IP socket over which the POP3 interaction
      * is occurring
      */
     private Socket socket;
 
     /***
      * The incoming stream of bytes coming from the socket.
      */
     private InputStream in;
 
     /***
      * The reader associated with incoming characters.
      */
     private BufferedReader reader;
 
     /***
      * The socket's output stream
      */
     private OutputStream outs;
 
     /***
      * The writer to which outgoing messages are written.
      */
     private PrintWriter writer;
 
     /***
      * The current newsgroup.
      */
     private NNTPGroup group;
 
     /***
      * The current newsgroup.
      */
     private int currentArticleNumber = -1;
 
     /***
      * Per-service configuration data that applies to all handlers
      * associated with the service.
      */
     private NNTPHandlerConfigurationData theConfigData;
 
     /***
      * The user id associated with the NNTP dialogue
      */
     private String user = null;
 
     /***
      * The password associated with the NNTP dialogue
      */
     private String password = null;
 
     /***
      * Whether the user for this session has already authenticated.
      * Used to optimize authentication checks
      */
     boolean isAlreadyAuthenticated = false;
 
     /***
      * The watchdog being used by this handler to deal with idle timeouts.
      */
     private Watchdog theWatchdog;
 
     /***
      * The watchdog target that idles out this handler.
      */
     private WatchdogTarget theWatchdogTarget = new NNTPWatchdogTarget();
 
     /***
      * Set the configuration data for the handler
      *
      * @param theData configuration data for the handler
      */
     void setConfigurationData(NNTPHandlerConfigurationData theData) {
         theConfigData = theData;
     }
 
     /***
      * Set the Watchdog for use by this handler.
      *
      * @param theWatchdog the watchdog
      */
     void setWatchdog(Watchdog theWatchdog) {
         this.theWatchdog = theWatchdog;
     }
 
     /***
      * Gets the Watchdog Target that should be used by Watchdogs managing
      * this connection.
      *
      * @return the WatchdogTarget
      */
     WatchdogTarget getWatchdogTarget() {
         return theWatchdogTarget;
     }
 
     /***
      * Idle out this connection
      */
     void idleClose() {
         if (getLogger() != null) {
             getLogger().error("NNTP Connection has idled out.");
         }
         try {
             if (socket != null) {
                 socket.close();
             }
         } catch (Exception e) {
             // ignored
         } finally {
             socket = null;
         }
 
         synchronized (this) {
             // Interrupt the thread to recover from internal hangs
             if (handlerThread != null) {
                 handlerThread.interrupt();
                 handlerThread = null;
             }
         }
     }
 
     /***
      * @see org.apache.avalon.cornerstone.services.connection.ConnectionHandler#handleConnection(Socket)
      */
     public void handleConnection( Socket connection ) throws IOException {
         try {
             this.socket = connection;
             synchronized (this) {
                 handlerThread = Thread.currentThread();
             }
             remoteIP = socket.getInetAddress().getHostAddress();
             remoteHost = socket.getInetAddress().getHostName();
             in = new BufferedInputStream(socket.getInputStream(), 1024);
             // An ASCII encoding can be used because all transmissions other
             // that those in the message body command are guaranteed
             // to be ASCII
             reader = new BufferedReader(new InputStreamReader(in, "ASCII"), 512);
             outs = new BufferedOutputStream(socket.getOutputStream(), 1024);
             writer = new InternetPrintWriter(outs, true);
         } catch (Exception e) {
             StringBuffer exceptionBuffer = 
                 new StringBuffer(256)
                     .append("Cannot open connection from ")
                     .append(remoteHost)
                     .append(" (")
                     .append(remoteIP)
                     .append("): ")
                     .append(e.getMessage());
             String exceptionString = exceptionBuffer.toString();
             getLogger().error(exceptionString, e );
         }
 
         try {
             // section 7.1
             if ( theConfigData.getNNTPRepository().isReadOnly() ) {
                 StringBuffer respBuffer =
                     new StringBuffer(128)
                         .append("201 ")
                         .append(theConfigData.getHelloName())
                         .append(" NNTP Service Ready, posting prohibited");
                 writeLoggedFlushedResponse(respBuffer.toString());
             } else {
                 StringBuffer respBuffer =
                     new StringBuffer(128)
                             .append("200 ")
                             .append(theConfigData.getHelloName())
                             .append(" NNTP Service Ready, posting permitted");
                 writeLoggedFlushedResponse(respBuffer.toString());
             }
 
             theWatchdog.start();
             while (parseCommand(reader.readLine())) {
                 theWatchdog.reset();
             }
             theWatchdog.stop();
 
             getLogger().info("Connection closed");
         } catch (Exception e) {
             // If the connection has been idled out, the
             // socket will be closed and null.  Do NOT
             // log the exception or attempt to send the
             // closing connection message
             if (socket != null) {
                 try {
                     doQUIT(null);
                 } catch (Throwable t) {}
                 getLogger().error( "Exception during connection:" + e.getMessage(), e );
             }
         } finally {
             resetHandler();
         }
     }
 
     /***
      * Resets the handler data to a basic state.
      */
     private void resetHandler() {
 
         // Clear the Watchdog
         if (theWatchdog != null) {
             ContainerUtil.dispose(theWatchdog);
             theWatchdog = null;
         }
 
         // Clear the streams
         try {
             if (reader != null) {
                 reader.close();
             }
         } catch (IOException ioe) {
             getLogger().warn("NNTPHandler: Unexpected exception occurred while closing reader: " + ioe);
         } finally {
             reader = null;
         }
 
         in = null;
 
         if (writer != null) {
             writer.close();
             writer = null;
         }
         outs = null;
 
         remoteHost = null;
         remoteIP = null;
         try {
             if (socket != null) {
                 socket.close();
             }
         } catch (IOException ioe) {
             getLogger().warn("NNTPHandler: Unexpected exception occurred while closing socket: " + ioe);
         } finally {
             socket = null;
         }
 
         synchronized (this) {
             handlerThread = null;
         }
 
         // Clear the selected group, article info
         group = null;
         currentArticleNumber = -1;
 
         // Clear the authentication info
         user = null;
         password = null;
         isAlreadyAuthenticated = false;
 
         // Clear the config data
         theConfigData = null;
     }
 
     /***
      * This method parses NNTP commands read off the wire in handleConnection.
      * Actual processing of the command (possibly including additional back and
      * forth communication with the client) is delegated to one of a number of
      * command specific handler methods.  The primary purpose of this method is
      * to parse the raw command string to determine exactly which handler should
      * be called.  It returns true if expecting additional commands, false otherwise.
      *
      * @param commandRaw the raw command string passed in over the socket
      *
      * @return whether additional commands are expected.
      */
     private boolean parseCommand(String commandRaw) {
         if (commandRaw == null) {
             return false;
         }
         if (getLogger().isDebugEnabled()) {
             getLogger().debug("Command received: " + commandRaw);
         }
 
         String command = commandRaw.trim();
         String argument = null;
         int spaceIndex = command.indexOf(" ");
         if (spaceIndex >= 0) {
             argument = command.substring(spaceIndex + 1);
             command = command.substring(0, spaceIndex);
         }
         command = command.toUpperCase(Locale.US);
 
         boolean returnValue = true;
         if (!isAuthorized(command) ) {
             writeLoggedFlushedResponse("480 User is not authenticated");
             getLogger().debug("Command not allowed.");
             return returnValue;
         }
         if ((command.equals(COMMAND_MODE)) && (argument != null)) {
             if (argument.toUpperCase(Locale.US).equals(MODE_TYPE_READER)) {
                 doMODEREADER(argument);
             } else if (argument.toUpperCase(Locale.US).equals(MODE_TYPE_STREAM)) {
                 doMODESTREAM(argument);
             } else {
                 writeLoggedFlushedResponse("500 Command not understood");
             }
         } else if ( command.equals(COMMAND_LIST)) {
             doLIST(argument);
         } else if ( command.equals(COMMAND_GROUP) ) {
             doGROUP(argument);
         } else if ( command.equals(COMMAND_NEXT) ) {
             doNEXT(argument);
         } else if ( command.equals(COMMAND_LAST) ) {
             doLAST(argument);
         } else if ( command.equals(COMMAND_ARTICLE) ) {
             doARTICLE(argument);
         } else if ( command.equals(COMMAND_HEAD) ) {
             doHEAD(argument);
         } else if ( command.equals(COMMAND_BODY) ) {
             doBODY(argument);
         } else if ( command.equals(COMMAND_STAT) ) {
             doSTAT(argument);
         } else if ( command.equals(COMMAND_POST) ) {
             doPOST(argument);
         } else if ( command.equals(COMMAND_IHAVE) ) {
             doIHAVE(argument);
         } else if ( command.equals(COMMAND_QUIT) ) {
             doQUIT(argument);
             returnValue = false;
         } else if ( command.equals(COMMAND_DATE) ) {
             doDATE(argument);
         } else if ( command.equals(COMMAND_HELP) ) {
             doHELP(argument);
         } else if ( command.equals(COMMAND_NEWGROUPS) ) {
             doNEWGROUPS(argument);
         } else if ( command.equals(COMMAND_NEWNEWS) ) {
             doNEWNEWS(argument);
         } else if ( command.equals(COMMAND_LISTGROUP) ) {
             doLISTGROUP(argument);
         } else if ( command.equals(COMMAND_OVER) ) {
             doOVER(argument);
         } else if ( command.equals(COMMAND_XOVER) ) {
             doXOVER(argument);
         } else if ( command.equals(COMMAND_HDR) ) {
             doHDR(argument);
         } else if ( command.equals(COMMAND_XHDR) ) {
             doXHDR(argument);
         } else if ( command.equals(COMMAND_AUTHINFO) ) {
             doAUTHINFO(argument);
         } else if ( command.equals(COMMAND_SLAVE) ) {
             doSLAVE(argument);
         } else if ( command.equals(COMMAND_PAT) ) {
             doPAT(argument);
         } else {
             doUnknownCommand(command, argument);
         }
         return returnValue;
     }
 
     /***
      * Handles an unrecognized command, logging that.
      *
      * @param command the command received from the client
      * @param argument the argument passed in with the command
      */
     private void doUnknownCommand(String command, String argument) {
         if (getLogger().isDebugEnabled()) {
             StringBuffer logBuffer =
                 new StringBuffer(128)
                     .append("Received unknown command ")
                     .append(command)
                     .append(" with argument ")
                     .append(argument);
             getLogger().debug(logBuffer.toString());
         }
         writeLoggedFlushedResponse("500 Unknown command");
     }
 
     /***
      * Implements only the originnal AUTHINFO.
      * for simple and generic AUTHINFO, 501 is sent back. This is as
      * per article 3.1.3 of RFC 2980
      *
      * @param argument the argument passed in with the AUTHINFO command
      */
     private void doAUTHINFO(String argument) {
         String command = null;
         String value = null;
         if (argument != null) {
             int spaceIndex = argument.indexOf(" ");
             if (spaceIndex >= 0) {
                 command = argument.substring(0, spaceIndex);
                 value = argument.substring(spaceIndex + 1);
             }
         }
         if (command == null) {
             writeLoggedFlushedResponse("501 Syntax error");
             return;
         }
         command = command.toUpperCase(Locale.US);
         if ( command.equals(AUTHINFO_PARAM_USER) ) {
             // Reject re-authentication
             if ( isAlreadyAuthenticated ) {
                 writeLoggedFlushedResponse("482 Already authenticated - rejecting new credentials");
             }
             // Reject doubly sent user
             if (user != null) {
                 user = null;
                 password = null;
                 isAlreadyAuthenticated = false;
                 writeLoggedFlushedResponse("482 User already specified - rejecting new user");
                 return;
             }
             user = value;
             writeLoggedFlushedResponse("381 More authentication information required");
         } else if ( command.equals(AUTHINFO_PARAM_PASS) ) {
             // Reject password sent before user
             if (user == null) {
                 writeLoggedFlushedResponse("482 User not yet specified.  Rejecting user.");
                 return;
             }
             // Reject doubly sent password
             if (password != null) {
                 user = null;
                 password = null;
                 isAlreadyAuthenticated = false;
                 writeLoggedFlushedResponse("482 Password already specified - rejecting new password");
                 return;
             }
             password = value;
             isAlreadyAuthenticated = isAuthenticated();
             if ( isAlreadyAuthenticated ) {
                 writeLoggedFlushedResponse("281 Authentication accepted");
             } else {
                 writeLoggedFlushedResponse("482 Authentication rejected");
                 // Clear bad authentication
                 user = null;
                 password = null;
             }
         } else {
             writeLoggedFlushedResponse("501 Syntax error");
             return;
         }
     }
 
     /***
      * Lists the articles posted since the date passed in as
      * an argument.
      *
      * @param argument the argument passed in with the NEWNEWS command.
      *                 Should be a wildmat followed by a date.
      */
     private void doNEWNEWS(String argument) {
         // see section 11.4
 
         String wildmat = "*";
 
         if (argument != null) {
             int spaceIndex = argument.indexOf(" ");
             if (spaceIndex >= 0) {
                 wildmat = argument.substring(0, spaceIndex);
                 argument = argument.substring(spaceIndex + 1);
             } else {
                 getLogger().error("NEWNEWS had an invalid argument");
                 writeLoggedFlushedResponse("501 Syntax error");
                 return;
             }
         } else {
             getLogger().error("NEWNEWS had a null argument");
             writeLoggedFlushedResponse("501 Syntax error");
             return;
         }
 
         Date theDate = null;
         try {
             theDate = getDateFrom(argument);
         } catch (NNTPException nntpe) {
             getLogger().error("NEWNEWS had an invalid argument", nntpe);
             writeLoggedFlushedResponse("501 Syntax error");
             return;
         }
 
         writeLoggedFlushedResponse("230 list of new articles by message-id follows");
         Iterator groupIter = theConfigData.getNNTPRepository().getMatchedGroups(wildmat);
         while ( groupIter.hasNext() ) {
             Iterator articleIter = ((NNTPGroup)(groupIter.next())).getArticlesSince(theDate);
             while (articleIter.hasNext()) {
                 StringBuffer iterBuffer =
                     new StringBuffer(64)
                         .append(((NNTPArticle)articleIter.next()).getUniqueID());
                 writeLoggedResponse(iterBuffer.toString());
             }
         }
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Lists the groups added since the date passed in as
      * an argument.
      *
      * @param argument the argument passed in with the NEWGROUPS command.
      *                 Should be a date.
      */
     private void doNEWGROUPS(String argument) {
         // see section 11.3
         // both draft-ietf-nntpext-base-15.txt and rfc977 have only group names 
         // in response lines, but INN sends 
         // '<group name> <last article> <first article> <posting allowed>'
         // NOTE: following INN over either document.
         //
         // TODO: Check this.  Audit at http://www.academ.com/pipermail/ietf-nntp/2001-July/002185.html
         // doesn't mention the supposed discrepancy.  Consider changing code to 
         // be in line with spec.
         Date theDate = null;
         try {
             theDate = getDateFrom(argument);
         } catch (NNTPException nntpe) {
             getLogger().error("NEWGROUPS had an invalid argument", nntpe);
             writeLoggedFlushedResponse("501 Syntax error");
             return;
         }
         Iterator iter = theConfigData.getNNTPRepository().getGroupsSince(theDate);
         writeLoggedFlushedResponse("231 list of new newsgroups follows");
         while ( iter.hasNext() ) {
             NNTPGroup currentGroup = (NNTPGroup)iter.next();
             StringBuffer iterBuffer =
                 new StringBuffer(128)
                     .append(currentGroup.getName())
                     .append(" ")
                     .append(currentGroup.getLastArticleNumber())
                     .append(" ")
                     .append(currentGroup.getFirstArticleNumber())
                     .append(" ")
                     .append((currentGroup.isPostAllowed()?"y":"n"));
             writeLoggedResponse(iterBuffer.toString());
         }
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Lists the help text for the service.
      *
      * @param argument the argument passed in with the HELP command.
      */
     private void doHELP(String argument) {
         writeLoggedResponse("100 Help text follows");
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Acknowledges a SLAVE command.  No special preference is given
      * to slave connections.
      *
      * @param argument the argument passed in with the SLAVE command.
      */
     private void doSLAVE(String argument) {
         writeLoggedFlushedResponse("202 slave status noted");
     }
 
     /***
      * Returns the current date according to the news server.
      *
      * @param argument the argument passed in with the DATE command
      */
     private void doDATE(String argument) {
         Date dt = new Date(System.currentTimeMillis()-UTC_OFFSET);
         String dtStr = DF_RFC2980.format(new Date(dt.getTime() - UTC_OFFSET));
         writeLoggedFlushedResponse("111 " + dtStr);
     }
 
     /***
      * Quits the transaction.
      *
      * @param argument the argument passed in with the QUIT command
      */
     private void doQUIT(String argument) {
         writeLoggedFlushedResponse("205 closing connection");
     }
 
     /***
      * Handles the LIST command and its assorted extensions.
      *
      * @param argument the argument passed in with the LIST command.
      */
     private void doLIST(String argument) {
         // see section 9.4.1
         String wildmat = "*";
         boolean isListNewsgroups = false;
 
         String extension = argument;
         if (argument != null) {
             int spaceIndex = argument.indexOf(" ");
             if (spaceIndex >= 0) {
                 wildmat = argument.substring(spaceIndex + 1);
                 extension = argument.substring(0, spaceIndex);
             }
             extension = extension.toUpperCase(Locale.US);
         }
 
         if (extension != null) {
             if (extension.equals("ACTIVE")) {
                 isListNewsgroups = false;
             } else if (extension.equals("NEWSGROUPS") ) {
                 isListNewsgroups = true;
             } else if (extension.equals("EXTENSIONS") ) {
                 doLISTEXTENSIONS();
                 return;
             } else if (extension.equals("OVERVIEW.FMT") ) {
                 doLISTOVERVIEWFMT();
                 return;
             } else if (extension.equals("ACTIVE.TIMES") ) {
                 // not supported - 9.4.2.1, 9.4.3.1, 9.4.4.1
                 writeLoggedFlushedResponse("503 program error, function not performed");
                 return;
             } else if (extension.equals("DISTRIBUTIONS") ) {
                 // not supported - 9.4.2.1, 9.4.3.1, 9.4.4.1
                 writeLoggedFlushedResponse("503 program error, function not performed");
                 return;
             } else if (extension.equals("DISTRIB.PATS") ) {
                 // not supported - 9.4.2.1, 9.4.3.1, 9.4.4.1
                 writeLoggedFlushedResponse("503 program error, function not performed");
                 return;
             } else {
                 writeLoggedFlushedResponse("501 Syntax error");
                 return;
             }
         }
 
         Iterator iter = theConfigData.getNNTPRepository().getMatchedGroups(wildmat);
         writeLoggedFlushedResponse("215 list of newsgroups follows");
         while ( iter.hasNext() ) {
             NNTPGroup theGroup = (NNTPGroup)iter.next();
             if (isListNewsgroups) {
                 writeLoggedResponse(theGroup.getListNewsgroupsFormat());
             } else {
                 writeLoggedResponse(theGroup.getListFormat());
             }
         }
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Informs the server that the client has an article with the specified
      * message-ID.
      *
      * @param id the message id
      */
     private void doIHAVE(String id) {
         // see section 9.3.2.1
         if (!isMessageId(id)) {
             writeLoggedFlushedResponse("501 command syntax error");
             return;
         }
         NNTPArticle article = theConfigData.getNNTPRepository().getArticleFromID(id);
         if ( article != null ) {
             writeLoggedFlushedResponse("435 article not wanted - do not send it");
         } else {
             writeLoggedFlushedResponse("335 send article to be transferred. End with <CR-LF>.<CR-LF>");
             try {
                 createArticle();
             } catch (RuntimeException e) {
                 writeLoggedFlushedResponse("436 transfer failed - try again later");
                 throw e;
             }
             writeLoggedFlushedResponse("235 article received ok");
         }
     }
 
     /***
      * Posts an article to the news server.
      *
      * @param argument the argument passed in with the POST command
      */
     private void doPOST(String argument) {
         // see section 9.3.1.1
         if ( argument != null ) {
             writeLoggedFlushedResponse("501 Syntax error - unexpected parameter");
         }
         writeLoggedFlushedResponse("340 send article to be posted. End with <CR-LF>.<CR-LF>");
         createArticle();
         writeLoggedFlushedResponse("240 article received ok");
     }
 
     /***
      * Executes the STAT command.  Sets the current article pointer,
      * returns article information.
      *
      * @param the argument passed in to the STAT command,
      *        which should be an article number or message id.
      *        If no parameter is provided, the current selected
      *        article is used.
      */
     private void doSTAT(String param) {
         // section 9.2.4
         NNTPArticle article = null;
         if (isMessageId(param)) {
             article = theConfigData.getNNTPRepository().getArticleFromID(param);
             if ( article == null ) {
                 writeLoggedFlushedResponse("430 no such article");
                 return;
             } else {
                 StringBuffer respBuffer =
                     new StringBuffer(64)
                             .append("223 0 ")
                             .append(param);
                 writeLoggedFlushedResponse(respBuffer.toString());
             }
         } else {
             int newArticleNumber = currentArticleNumber;
             if ( group == null ) {
                 writeLoggedFlushedResponse("412 no newsgroup selected");
                 return;
             } else {
                 if ( param == null ) {
                     if ( currentArticleNumber < 0 ) {
                         writeLoggedFlushedResponse("420 no current article selected");
                         return;
                     } else {
                         article = group.getArticle(currentArticleNumber);
                     }
                 }
                 else {
                     newArticleNumber = Integer.parseInt(param);
                     article = group.getArticle(newArticleNumber);
                 }
                 if ( article == null ) {
                     writeLoggedFlushedResponse("423 no such article number in this group");
                     return;
                 } else {
                     currentArticleNumber = newArticleNumber;
                     String articleID = article.getUniqueID();
                     if (articleID == null) {
                         articleID = "<0>";
                     }
                     StringBuffer respBuffer =
                         new StringBuffer(128)
                                 .append("223 ")
                                 .append(article.getArticleNumber())
                                 .append(" ")
                                 .append(articleID);
                     writeLoggedFlushedResponse(respBuffer.toString());
                 }
             }
         }
     }
 
     /***
      * Executes the BODY command.  Sets the current article pointer,
      * returns article information and body.
      *
      * @param the argument passed in to the BODY command,
      *        which should be an article number or message id.
      *        If no parameter is provided, the current selected
      *        article is used.
      */
     private void doBODY(String param) {
         // section 9.2.3
         NNTPArticle article = null;
         if (isMessageId(param)) {
             article = theConfigData.getNNTPRepository().getArticleFromID(param);
             if ( article == null ) {
                 writeLoggedFlushedResponse("430 no such article");
                 return;
             } else {
                 StringBuffer respBuffer =
                     new StringBuffer(64)
                             .append("222 0 ")
                             .append(param);
                 writeLoggedFlushedResponse(respBuffer.toString());
             }
         } else {
             int newArticleNumber = currentArticleNumber;
             if ( group == null ) {
                 writeLoggedFlushedResponse("412 no newsgroup selected");
                 return;
             } else {
                 if ( param == null ) {
                     if ( currentArticleNumber < 0 ) {
                         writeLoggedFlushedResponse("420 no current article selected");
                         return;
                     } else {
                         article = group.getArticle(currentArticleNumber);
                     }
                 }
                 else {
                     newArticleNumber = Integer.parseInt(param);
                     article = group.getArticle(newArticleNumber);
                 }
                 if ( article == null ) {
                     writeLoggedFlushedResponse("423 no such article number in this group");
                     return;
                 } else {
                     currentArticleNumber = newArticleNumber;
                     String articleID = article.getUniqueID();
                     if (articleID == null) {
                         articleID = "<0>";
                     }
                     StringBuffer respBuffer =
                         new StringBuffer(128)
                                 .append("222 ")
                                 .append(article.getArticleNumber())
                                 .append(" ")
                                 .append(articleID);
                     writeLoggedFlushedResponse(respBuffer.toString());
                 }
             }
         }
         if (article != null) {
             writer.flush();
             article.writeBody(new ExtraDotOutputStream(outs));
             writeLoggedFlushedResponse("\r\n.");
         }
     }
 
     /***
      * Executes the HEAD command.  Sets the current article pointer,
      * returns article information and headers.
      *
      * @param the argument passed in to the HEAD command,
      *        which should be an article number or message id.
      *        If no parameter is provided, the current selected
      *        article is used.
      */
     private void doHEAD(String param) {
         // section 9.2.2
         NNTPArticle article = null;
         if (isMessageId(param)) {
             article = theConfigData.getNNTPRepository().getArticleFromID(param);
             if ( article == null ) {
                 writeLoggedFlushedResponse("430 no such article");
                 return;
             } else {
                 StringBuffer respBuffer =
                     new StringBuffer(64)
                             .append("221 0 ")
                             .append(param);
                 writeLoggedFlushedResponse(respBuffer.toString());
             }
         } else {
             int newArticleNumber = currentArticleNumber;
             if ( group == null ) {
                 writeLoggedFlushedResponse("412 no newsgroup selected");
                 return;
             } else {
                 if ( param == null ) {
                     if ( currentArticleNumber < 0 ) {
                         writeLoggedFlushedResponse("420 no current article selected");
                         return;
                     } else {
                         article = group.getArticle(currentArticleNumber);
                     }
                 }
                 else {
                     newArticleNumber = Integer.parseInt(param);
                     article = group.getArticle(newArticleNumber);
                 }
                 if ( article == null ) {
                     writeLoggedFlushedResponse("423 no such article number in this group");
                     return;
                 } else {
                     currentArticleNumber = newArticleNumber;
                     String articleID = article.getUniqueID();
                     if (articleID == null) {
                         articleID = "<0>";
                     }
                     StringBuffer respBuffer =
                         new StringBuffer(128)
                                 .append("221 ")
                                 .append(article.getArticleNumber())
                                 .append(" ")
                                 .append(articleID);
                     writeLoggedFlushedResponse(respBuffer.toString());
                 }
             }
         }
         if (article != null) {
             writer.flush();
             article.writeHead(new ExtraDotOutputStream(outs));
             writeLoggedFlushedResponse(".");
         }
     }
 
     /***
      * Executes the ARTICLE command.  Sets the current article pointer,
      * returns article information and contents.
      *
      * @param the argument passed in to the ARTICLE command,
      *        which should be an article number or message id.
      *        If no parameter is provided, the current selected
      *        article is used.
      */
     private void doARTICLE(String param) {
         // section 9.2.1
         NNTPArticle article = null;
         if (isMessageId(param)) {
             article = theConfigData.getNNTPRepository().getArticleFromID(param);
             if ( article == null ) {
                 writeLoggedFlushedResponse("430 no such article");
                 return;
             } else {
                 StringBuffer respBuffer =
                     new StringBuffer(64)
                             .append("220 0 ")
                             .append(param);
                 writeLoggedResponse(respBuffer.toString());
             }
         } else {
             int newArticleNumber = currentArticleNumber;
             if ( group == null ) {
                 writeLoggedFlushedResponse("412 no newsgroup selected");
                 return;
             } else {
                 if ( param == null ) {
                     if ( currentArticleNumber < 0 ) {
                         writeLoggedFlushedResponse("420 no current article selected");
                         return;
                     } else {
                         article = group.getArticle(currentArticleNumber);
                     }
                 }
                 else {
                     newArticleNumber = Integer.parseInt(param);
                     article = group.getArticle(newArticleNumber);
                 }
                 if ( article == null ) {
                     writeLoggedFlushedResponse("423 no such article number in this group");
                     return;
                 } else {
                     currentArticleNumber = newArticleNumber;
                     String articleID = article.getUniqueID();
                     if (articleID == null) {
                         articleID = "<0>";
                     }
                     StringBuffer respBuffer =
                         new StringBuffer(128)
                                 .append("220 ")
                                 .append(article.getArticleNumber())
                                 .append(" ")
                                 .append(articleID);
                     writeLoggedFlushedResponse(respBuffer.toString());
                 }
             }
         }
         if (article != null) {
             writer.flush();
             article.writeArticle(new ExtraDotOutputStream(outs));
             // see jira JAMES-311 for an explanation of the "\r\n"
             writeLoggedFlushedResponse("\r\n.");
         }
     }
 
     /***
      * Advances the current article pointer to the next article in the group.
      *
      * @param argument the argument passed in with the NEXT command
      */
     private void doNEXT(String argument) {
         // section 9.1.1.3.1
         if ( argument != null ) {
             writeLoggedFlushedResponse("501 Syntax error - unexpected parameter");
         } else if ( group == null ) {
             writeLoggedFlushedResponse("412 no newsgroup selected");
         } else if ( currentArticleNumber < 0 ) {
             writeLoggedFlushedResponse("420 no current article has been selected");
         } else if ( currentArticleNumber >= group.getLastArticleNumber() ) {
             writeLoggedFlushedResponse("421 no next article in this group");
         } else {
             currentArticleNumber++;
             NNTPArticle article = group.getArticle(currentArticleNumber);
             StringBuffer respBuffer =
                 new StringBuffer(64)
                         .append("223 ")
                         .append(article.getArticleNumber())
                         .append(" ")
                         .append(article.getUniqueID());
             writeLoggedFlushedResponse(respBuffer.toString());
         }
     }
 
     /***
      * Moves the currently selected article pointer to the article
      * previous to the currently selected article in the selected group.
      *
      * @param argument the argument passed in with the LAST command
      */
     private void doLAST(String argument) {
         // section 9.1.1.2.1
         if ( argument != null ) {
             writeLoggedFlushedResponse("501 Syntax error - unexpected parameter");
         } else if ( group == null ) {
             writeLoggedFlushedResponse("412 no newsgroup selected");
         } else if ( currentArticleNumber < 0 ) {
             writeLoggedFlushedResponse("420 no current article has been selected");
         } else if ( currentArticleNumber <= group.getFirstArticleNumber() ) {
             writeLoggedFlushedResponse("422 no previous article in this group");
         } else {
             currentArticleNumber--;
             NNTPArticle article = group.getArticle(currentArticleNumber);
             StringBuffer respBuffer =
                 new StringBuffer(64)
                         .append("223 ")
                         .append(article.getArticleNumber())
                         .append(" ")
                         .append(article.getUniqueID());
             writeLoggedFlushedResponse(respBuffer.toString());
         }
     }
 
     /***
      * Selects a group to be the current newsgroup.
      *
      * @param group the name of the group being selected.
      */
     private void doGROUP(String groupName) {
         if (groupName == null) {
             writeLoggedFlushedResponse("501 Syntax error - missing required parameter");
             return;
         }
         NNTPGroup newGroup = theConfigData.getNNTPRepository().getGroup(groupName);
         // section 9.1.1.1
         if ( newGroup == null ) {
             writeLoggedFlushedResponse("411 no such newsgroup");
         } else {
             group = newGroup;
             // if the number of articles in group == 0
             // then the server may return this information in 3 ways, 
             // The clients must honor all those 3 ways.
             // our response is: 
             // highWaterMark == lowWaterMark and number of articles == 0
             int articleCount = group.getNumberOfArticles();
             int lowWaterMark = group.getFirstArticleNumber();
             int highWaterMark = group.getLastArticleNumber();
 
             // Set the current article pointer.  If no
             // articles are in the group, the current article
             // pointer should be explicitly unset.
             if (articleCount != 0) {
                 currentArticleNumber = lowWaterMark;
             } else {
                 currentArticleNumber = -1;
             }
             StringBuffer respBuffer =
                 new StringBuffer(128)
                         .append("211 ")
                         .append(articleCount)
                         .append(" ")
                         .append(lowWaterMark)
                         .append(" ")
                         .append(highWaterMark)
                         .append(" ")
                         .append(group.getName())
                         .append(" group selected");
             writeLoggedFlushedResponse(respBuffer.toString());
         }
     }
 
     /***
      * Lists the extensions supported by this news server.
      */
     private void doLISTEXTENSIONS() {
         // 8.1.1
         writeLoggedResponse("202 Extensions supported:");
         writeLoggedResponse("LISTGROUP");
         writeLoggedResponse("AUTHINFO");
         writeLoggedResponse("OVER");
         writeLoggedResponse("XOVER");
         writeLoggedResponse("HDR");
         writeLoggedResponse("XHDR");
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Informs the server that the client is a newsreader.
      *
      * @param argument the argument passed in with the MODE READER command
      */
     private void doMODEREADER(String argument) {
         // 7.2
         writeLoggedFlushedResponse(theConfigData.getNNTPRepository().isReadOnly()
                        ? "201 Posting Not Permitted" : "200 Posting Permitted");
     }
 
     /***
      * Informs the server that the client is a news server.
      *
      * @param argument the argument passed in with the MODE STREAM command
      */
     private void doMODESTREAM(String argument) {
         // 7.2
         writeLoggedFlushedResponse("500 Command not understood");
     }
 
     /***
      * Gets a listing of article numbers in specified group name
      * or in the already selected group if the groupName is null.
      *
      * @param groupName the name of the group to list
      */
     private void doLISTGROUP(String groupName) {
         // 9.5.1.1.1
         if (groupName==null) {
             if ( group == null) {
                 writeLoggedFlushedResponse("412 no news group currently selected");
                 return;
             }
         }
         else {
             group = theConfigData.getNNTPRepository().getGroup(groupName);
             if ( group == null ) {
                 writeLoggedFlushedResponse("411 no such newsgroup");
                 return;
             }
         }
         if ( group != null ) {
             // this.group = group;
 
             // Set the current article pointer.  If no
             // articles are in the group, the current article
             // pointer should be explicitly unset.
             if (group.getNumberOfArticles() > 0) {
                 currentArticleNumber = group.getFirstArticleNumber();
             } else {
                 currentArticleNumber = -1;
             }
 
             writeLoggedFlushedResponse("211 list of article numbers follow");
 
             Iterator iter = group.getArticles();
             while (iter.hasNext()) {
                 NNTPArticle article = (NNTPArticle)iter.next();
                 writeLoggedResponse(article.getArticleNumber() + "");
             }
             writeLoggedFlushedResponse(".");
         }
     }
 
     /***
      * Handles the LIST OVERVIEW.FMT command.  Not supported.
      */
     private void doLISTOVERVIEWFMT() {
         // 9.5.3.1.1
         writeLoggedFlushedResponse("215 Information follows");
         String[] overviewHeaders = theConfigData.getNNTPRepository().getOverviewFormat();
         for (int i = 0;  i < overviewHeaders.length; i++) {
             writeLoggedResponse(overviewHeaders[i]);
         }
         writeLoggedFlushedResponse(".");
     }
 
     /***
      * Handles the PAT command.  Not supported.
      *
      * @param argument the argument passed in with the PAT command
      */
     private void doPAT(String argument) {
         // 9.5.3.1.1 in draft-12
         writeLoggedFlushedResponse("500 Command not recognized");
     }
 
     /***
      * Get the values of the headers for the selected newsgroup, 
      * with an optional range modifier.
      *
      * @param argument the argument passed in with the XHDR command.
      */
     private void doXHDR(String argument) {
         doHDR(argument);
     }
 
     /***
      * Get the values of the headers for the selected newsgroup, 
      * with an optional range modifier.
      *
      * @param argument the argument passed in with the HDR command.
      */
     private void doHDR(String argument) {
         // 9.5.3
         if (argument == null) {
             writeLoggedFlushedResponse("501 Syntax error - missing required parameter");
             return;
         }
         String hdr = argument;
         String range = null;
         int spaceIndex = hdr.indexOf(" ");
         if (spaceIndex >= 0 ) {
             range = hdr.substring(spaceIndex + 1);
             hdr = hdr.substring(0, spaceIndex);
         }
         if (group == null ) {
             writeLoggedFlushedResponse("412 No news group currently selected.");
             return;
         }
         if ((range == null) && (currentArticleNumber < 0)) {
             writeLoggedFlushedResponse("420 No current article selected");
             return;
         }
         NNTPArticle[] article = getRange(range);
         if ( article == null ) {
             writeLoggedFlushedResponse("412 no newsgroup selected");
         } else if ( article.length == 0 ) {
             writeLoggedFlushedResponse("430 no such article");
         } else {
             writeLoggedFlushedResponse("221 Header follows");
             for ( int i = 0 ; i < article.length ; i++ ) {
                 String val = article[i].getHeader(hdr);
                 if ( val == null ) {
                     val = "";
                 }
                 StringBuffer hdrBuffer =
                     new StringBuffer(128)
                             .append(article[i].getArticleNumber())
                             .append(" ")
                             .append(val);
                 writeLoggedResponse(hdrBuffer.toString());
             }
             writeLoggedFlushedResponse(".");
         }
     }
 
     /***
      * Returns information from the overview database regarding the
      * current article, or a range of articles.
      *
      * @param range the optional article range.
      */
     private void doXOVER(String range) {
         doOVER(range);
     }
 
     /***
      * Returns information from the overview database regarding the
      * current article, or a range of articles.
      *
      * @param range the optional article range.
      */
     private void doOVER(String range) {
         // 9.5.2.2.1
         if ( group == null ) {
             writeLoggedFlushedResponse("412 No newsgroup selected");
             return;
         }
         if ((range == null) && (currentArticleNumber < 0)) {
             writeLoggedFlushedResponse("420 No current article selected");
             return;
         }
         NNTPArticle[] article = getRange(range);
         if ( article.length == 0 ) {
             writeLoggedFlushedResponse("420 No article(s) selected");
         } else {
             writeLoggedResponse("224 Overview information follows");
             for ( int i = 0 ; i < article.length ; i++ ) {
                 article[i].writeOverview(outs);
                 if (i % 100 == 0) {
                     // Reset the watchdog every hundred headers or so
                     // to ensure the connection doesn't timeout for slow
                     // clients
                     theWatchdog.reset();
                 }
             }
             writeLoggedFlushedResponse(".");
         }
     }
 
     /***
      * Handles the transaction for getting the article data.
      */
     private void createArticle() {
         try {
             InputStream msgIn = new CharTerminatedInputStream(in, NNTPTerminator);
             // Removes the dot stuffing
             msgIn = new DotStuffingInputStream(msgIn);
             MailHeaders headers = new MailHeaders(msgIn);
             processMessageHeaders(headers);
             processMessage(headers, msgIn);
         } catch (MessagingException me) {
             throw new NNTPException("MessagingException encountered when loading article.");
         }
     }
 
     /***
      * Processes the NNTP message headers coming in off the wire.
      *
      * @param headers the headers of the message being read
      */
     private MailHeaders processMessageHeaders(MailHeaders headers)
         throws MessagingException {
         return headers;
     }
 
     /***
      * Processes the NNTP message coming in off the wire.  Reads the
      * content and delivers to the spool.
      *
      * @param headers the headers of the message being read
      * @param msgIn the stream containing the message content
      */
     private void processMessage(MailHeaders headers, InputStream bodyIn)
         throws MessagingException {
         InputStream messageIn = null;
         try {
             messageIn = new SequenceInputStream(new ByteArrayInputStream(headers.toByteArray()), bodyIn);
             theConfigData.getNNTPRepository().createArticle(messageIn);
         } finally {
             if (messageIn != null) {
                 try {
                     messageIn.close();
                 } catch (IOException ioe) {
                     // Ignore exception on close.
                 }
                 messageIn = null;
             }
         }
     }
 
     /***
      * Returns the date from @param input.
      * The input tokens are assumed to be in format date time [GMT|UTC] .
      * 'date' is in format [XX]YYMMDD. 'time' is in format 'HHMMSS'
      * NOTE: This routine could do with some format checks.
      *
      * @param argument the date string
      */
     private Date getDateFrom(String argument) {
         if (argument == null) {
             throw new NNTPException("Date argument was absent.");
         }
         StringTokenizer tok = new StringTokenizer(argument, " ");
         if (tok.countTokens() < 2) {
             throw new NNTPException("Date argument was ill-formed.");
         }
         String date = tok.nextToken();
         String time = tok.nextToken();
         boolean utc = ( tok.hasMoreTokens() );
         Date d = new Date();
         try {
             StringBuffer dateStringBuffer =
                 new StringBuffer(64)
                     .append(date)
                     .append(" ")
                     .append(time);
             Date dt = DF_RFC977.parse(dateStringBuffer.toString());
             if ( utc ) {
                 dt = new Date(dt.getTime()+UTC_OFFSET);
             }
             return dt;
         } catch ( ParseException pe ) {
             StringBuffer exceptionBuffer =
                 new StringBuffer(128)
                     .append("Date extraction failed: ")
                     .append(date)
                     .append(",")
                     .append(time)
                     .append(",")
                     .append(utc);
             throw new NNTPException(exceptionBuffer.toString());
         }
     }
 
     /***
      * Returns the list of articles that match the range.
      *
      * A precondition of this method is that the selected
      * group be non-null.  The current article pointer must
      * be valid if no range is explicitly provided.
      *
      * @return null indicates insufficient information to
      * fetch the list of articles
      */
     private NNTPArticle[] getRange(String range) {
         // check for msg id
         if ( isMessageId(range)) {
             NNTPArticle article = theConfigData.getNNTPRepository().getArticleFromID(range);
             return ( article == null )
                 ? new NNTPArticle[0] : new NNTPArticle[] { article };
         }
 
         if ( range == null ) {
             range = "" + currentArticleNumber;
         }
 
         int start = -1;
         int end = -1;
         int idx = range.indexOf('-');
         if ( idx == -1 ) {
             start = Integer.parseInt(range);
             end = start;
         } else {
             start = Integer.parseInt(range.substring(0,idx));
             if ( (idx + 1) == range.length() ) {
                 end = group.getLastArticleNumber();
             } else {
                 end = Integer.parseInt(range.substring(idx + 1));
             }
         }
         List list = new ArrayList();
         for ( int i = start ; i <= end ; i++ ) {
             NNTPArticle article = group.getArticle(i);
             if ( article != null ) {
                 list.add(article);
             }
         }
         return (NNTPArticle[])list.toArray(new NNTPArticle[0]);
     }
 
     /***
      * Return whether the user associated with the connection (possibly no
      * user) is authorized to execute the command.
      *
      * @param the command being tested
      * @return whether the command is authorized
      */
     private boolean isAuthorized(String command) {
         isAlreadyAuthenticated = isAlreadyAuthenticated || isAuthenticated();
         if (isAlreadyAuthenticated) {
             return true;
         }
         // some commands are authorized, even if the user is not authenticated
         boolean allowed = command.equals("AUTHINFO");
         allowed = allowed || command.equals("MODE");
         allowed = allowed || command.equals("QUIT");
         return allowed;
     }
 
     /***
      * Return whether the connection has been authenticated.
      *
      * @return whether the connection has been authenticated.
      */
     private boolean isAuthenticated() {
         if ( theConfigData.isAuthRequired() ) {
             if  ((user != null) && (password != null) && (theConfigData.getUsersRepository() != null)) {
                 return theConfigData.getUsersRepository().test(user,password);
             } else {
                 return false;
             }
         } else {
             return true;
         }
     }
 
     /***
      * Tests a string to see whether it is formatted as a message
      * ID.
      *
      * @param testString the string to test
      *
      * @return whether the string is a candidate message ID
      */
     private static boolean isMessageId(String testString) {
         if ((testString != null) &&
             (testString.startsWith("<")) &&
             (testString.endsWith(">"))) {
             return true;
         } else {
             return false;
         }
    }
 
     /***
      * This method logs at a "DEBUG" level the response string that 
      * was sent to the SMTP client.  The method is provided largely
      * as syntactic sugar to neaten up the code base.  It is declared
      * private and final to encourage compiler inlining.
      *
      * @param responseString the response string sent to the client
      */
     private final void logResponseString(String responseString) {
         if (getLogger().isDebugEnabled()) {
             getLogger().debug("Sent: " + responseString);
         }
     }
 
     /***
      * Write and flush a response string.  The response is also logged.
      * Should be used for the last line of a multi-line response or
      * for a single line response.
      *
      * @param responseString the response string sent to the client
      */
     final void writeLoggedFlushedResponse(String responseString) {
         writer.println(responseString);
         writer.flush();
         logResponseString(responseString);
     }
 
     /***
      * Write a response string.  The response is also logged. 
      * Used for multi-line responses.
      *
      * @param responseString the response string sent to the client
      */
     final void writeLoggedResponse(String responseString) {
         writer.println(responseString);
         logResponseString(responseString);
     }
 
     /***
      * A private inner class which serves as an adaptor
      * between the WatchdogTarget interface and this
      * handler class.
      */
     private class NNTPWatchdogTarget
         implements WatchdogTarget {
 
         /***
          * @see org.apache.james.util.watchdog.WatchdogTarget#execute()
          */
         public void execute() {
             NNTPHandler.this.idleClose();
         }
 
     }
 }