kerberos-client/src/main/java/org/apache/directory/kerberos/client/KerberosChannel.java

/*
 *  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.directory.kerberos.client;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;

/**
 * A class for sending and receiving kerberos request and response data
 * 
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
public class KerberosChannel
{
    /** the TCP socket */
    private Socket tcpSocket;
    
    /** the UDP socket */
    private DatagramSocket udpSocket;
    
    /** data input stream to read from */
    private DataInputStream in;
    
    /** data output stream to write to */
    private OutputStream out;
    
    /** flag to detect if this is a UDP channel */
    private boolean useUdp;
    
    private int timeOut = 60000;

    /** the UDP socket address of the server */
    private SocketAddress udpServerAddr = null;
    
    protected void openConnection( String hostName, int  portNo, int timeOut, boolean isUdp ) throws IOException
    {
        this.useUdp = isUdp;
        this.timeOut = timeOut;
        
        if ( isUdp )
        {
            udpServerAddr = new InetSocketAddress( hostName, portNo );
            udpSocket = new DatagramSocket();
        }
        else
        {
            tcpSocket = new Socket( hostName, portNo );
            tcpSocket.setSoTimeout( ( int ) timeOut );
            in = new DataInputStream( tcpSocket.getInputStream() );
            out = tcpSocket.getOutputStream();
        }
    }


    protected ByteBuffer sendAndReceive( ByteBuffer encodedBuf ) throws IOException
    {
        byte[] reqData  = encodedBuf.array();
        
        ByteBuffer repData;
        
        if ( useUdp )
        {
            DatagramPacket reqPacket = new DatagramPacket( reqData, reqData.length, udpServerAddr );
            udpSocket.send( reqPacket );
            
            byte[] buffer = new byte[2048];
            DatagramPacket repPacket = new DatagramPacket( buffer, buffer.length );
            udpSocket.receive( repPacket );
            
            byte[] receivedData = repPacket.getData();
            repData = ByteBuffer.allocate( receivedData.length );
            repData.put( receivedData );
        }
        else
        {
            out.write( reqData );
            out.flush();
            
            int len = in.readInt();
            
            repData = ByteBuffer.allocate( len + 4 );
            repData.putInt( len );
            
            byte[] tmp = new byte[ 1024 * 8 ];
            while ( in.available() > 0 )
            {
                int read = in.read( tmp );
                repData.put( tmp, 0, read );
            }
        }
        
        repData.flip();
        
        return repData;
    }
    
    
    protected boolean isUseTcp()
    {
        return !useUdp;
    }


    protected void close() throws IOException
    {
        if( useUdp )
        {
            if( udpSocket != null )
            {
                udpSocket.close();
            }
        }
        else
        {
            if( tcpSocket != null )
            {
                tcpSocket.close();
            }
        }
    }
}