mcs.java

cygwin 是一个在windows平台上运行的unix模拟环境

	sendBerInteger(buffer, max_users);
	sendBerInteger(buffer, max_tokens);
	
	sendBerInteger(buffer, 1); // num_priorities
	sendBerInteger(buffer, 0); // min_throughput
	sendBerInteger(buffer, 1); // max_height

	sendBerInteger(buffer, max_pdusize);
	sendBerInteger(buffer, 2); // ver_protocol
    }

    /**
     * 
     * Send an MCS_CONNECT_INITIAL message (encoded as ASN.1 Ber)
     * 
     * @param data Packet in which to send the message
     * @throws IOException
     * @throws RdesktopException
     */
    public void sendConnectInitial(RdpPacket_Localised data) throws IOException, RdesktopException {
        logger.debug("MCS.sendConnectInitial");
    if(false){
        int length = 7 + (3 *34) + 4 + data.getEnd();
        RdpPacket_Localised buffer = IsoLayer.init(length+5);
        
        sendBerHeader(buffer, CONNECT_INITIAL, length);
        sendBerHeader(buffer, BER_TAG_OCTET_STRING, 0); //calling domain
        sendBerHeader(buffer, BER_TAG_OCTET_STRING, 0); // called domain

        sendBerHeader(buffer, BER_TAG_BOOLEAN, 1);
        buffer.set8(255); //upward flag

        sendDomainParams(buffer, 2, 2, 0, 0xffff); //target parameters
        sendDomainParams(buffer, 1, 1, 1, 0x420); // minimun parameters
        sendDomainParams(buffer, 0xffff, 0xfc17, 0xffff, 0xffff); //maximum parameters

        sendBerHeader(buffer, BER_TAG_OCTET_STRING, data.getEnd());

        data.copyToPacket(buffer, 0, buffer.getPosition(), data.getEnd());
        buffer.incrementPosition(data.getEnd());
        buffer.markEnd();
        IsoLayer.send(buffer);
        return;
    }
        
        
    logger.debug("MCS.sendConnectInitial");
	int datalen = data.getEnd();
	int length = 	9 +
					domainParamSize(34, 2, 0, 0xffff) + 
					domainParamSize(1, 1, 1, 0x420) + 
					domainParamSize(0xffff, 0xfc17, 0xffff, 0xffff) + 
					4 + datalen; // RDP5 Code
    
	RdpPacket_Localised buffer = IsoLayer.init(length+5);
	
	sendBerHeader(buffer, CONNECT_INITIAL, length);
	sendBerHeader(buffer, BER_TAG_OCTET_STRING, 1); //calling domain
	buffer.set8(1); // RDP5 Code
	sendBerHeader(buffer, BER_TAG_OCTET_STRING, 1); // called domain
	buffer.set8(1);  // RDP5 Code
	
	sendBerHeader(buffer, BER_TAG_BOOLEAN, 1);
	buffer.set8(0xff); //upward flag

	sendDomainParams(buffer, 34, 2, 0, 0xffff); //target parameters // RDP5 Code
	sendDomainParams(buffer, 1, 1, 1, 0x420); // minimum parameters
	sendDomainParams(buffer, 0xffff, 0xfc17, 0xffff, 0xffff); //maximum parameters

	sendBerHeader(buffer, BER_TAG_OCTET_STRING, datalen);

	data.copyToPacket(buffer, 0, buffer.getPosition(), data.getEnd());
	buffer.incrementPosition(data.getEnd());
	buffer.markEnd();
	IsoLayer.send(buffer);
    }

    /**
     * Receive and handle a connect response from the server
     * @param data Packet containing response data
     * @throws IOException
     * @throws RdesktopException
     * @throws OrderException
     * @throws CryptoException
     */
    public void receiveConnectResponse(RdpPacket_Localised data) throws IOException, RdesktopException, OrderException, CryptoException {
        
        
        logger.debug("MCS.receiveConnectResponse");   
               
    String[] connect_results = {
    	"Successful", 
		"Domain Merging",
		"Domain not Hierarchical",
		"No Such Channel",
		"No Such Domain",
		"No Such User",
		"Not Admitted",
		"Other User ID",
		"Parameters Unacceptable",
		"Token Not Available",
		"Token Not Possessed",
		"Too Many Channels",
		"Too Many Tokens",
		"Too Many Users",
		"Unspecified Failure",
		"User Rejected"
    };
    	
    int result=0;
	int length=0;
	
	RdpPacket_Localised buffer = IsoLayer.receive();
    logger.debug("Received buffer"); 
	length=berParseHeader(buffer, CONNECT_RESPONSE);
	length=berParseHeader(buffer, BER_TAG_RESULT);

	result=buffer.get8();
	if (result != 0) {
	    throw new RdesktopException("MCS Connect failed: " + connect_results[result]);
	}
	length=berParseHeader(buffer, BER_TAG_INTEGER);
	length=buffer.get8(); //connect id
	parseDomainParams(buffer);
	length=berParseHeader(buffer, BER_TAG_OCTET_STRING);
	
	Common.secure.processMcsData(buffer);
	
	/*
	if (length > data.size()) {
	    logger.warn("MCS Datalength exceeds size!"+length);
	    length=data.size();
	}
	data.copyFromPacket(buffer, buffer.getPosition(), 0, length);
	data.setPosition(0);
	data.markEnd(length);
	buffer.incrementPosition(length);
	
	if (buffer.getPosition() != buffer.getEnd()) {
	    throw new RdesktopException();
	}
	*/
    }

    /**
     * Transmit an EDrq message
     * @throws IOException
     * @throws RdesktopException
     */
    public void send_edrq() throws IOException, RdesktopException {
	logger.debug("send_edrq");
        RdpPacket_Localised buffer = IsoLayer.init(5);
	buffer.set8(EDRQ << 2);
	buffer.setBigEndian16(1); //height
	buffer.setBigEndian16(1); //interval
	buffer.markEnd();
	IsoLayer.send(buffer);
    }
    
    /**
     * Transmit a CJrq message
     * @param channelid Id of channel to be identified in request
     * @throws IOException
     * @throws RdesktopException
     */
    public void send_cjrq(int channelid) throws IOException, RdesktopException {
	RdpPacket_Localised buffer = IsoLayer.init(5);
	buffer.set8(CJRQ << 2);
	buffer.setBigEndian16(this.McsUserID); //height
	buffer.setBigEndian16(channelid); //interval
	buffer.markEnd();
	IsoLayer.send(buffer);
    }

    /**
     * Transmit an AUcf message
     * @throws IOException
     * @throws RdesktopException
     */
    public void send_aucf() throws IOException, RdesktopException {
	RdpPacket_Localised buffer = IsoLayer.init(2);
	
	buffer.set8(AUCF << 2);
	buffer.set8(0);
	buffer.markEnd();
	IsoLayer.send(buffer);
    }

    /**
     * Transmit an AUrq mesage
     * @throws IOException
     * @throws RdesktopException
     */
    public void send_aurq() throws IOException, RdesktopException {
	RdpPacket_Localised buffer = IsoLayer.init(1);

	buffer.set8(AURQ <<2);
	buffer.markEnd();
	IsoLayer.send(buffer);
    }

    /**
     * Receive and handle a CJcf message
     * @throws IOException
     * @throws RdesktopException
     */
    public void receive_cjcf() throws IOException, RdesktopException, OrderException, CryptoException {
    	logger.debug("receive_cjcf");
    int opcode=0, result=0;
	RdpPacket_Localised buffer = IsoLayer.receive();
	
	opcode=buffer.get8();
	if ((opcode >>2) != CJCF) {
	    throw new RdesktopException("Expected CJCF got" + opcode);
	}

	result=buffer.get8();
	if (result!=0) {
	    throw new RdesktopException("Expected CJRQ got " + result);
	}
	
	buffer.incrementPosition(4); //skip userid, req_channelid

	if ((opcode&2)!=0) {
	    buffer.incrementPosition(2); // skip join_channelid
	}

	if (buffer.getPosition() != buffer.getEnd()){
	    throw new RdesktopException();
	}
    }

    /**
     * Receive an AUcf message
     * @return UserID specified in message
     * @throws IOException
     * @throws RdesktopException
     * @throws OrderException
     * @throws CryptoException
     */
    public int receive_aucf() throws IOException, RdesktopException, OrderException, CryptoException {
	logger.debug("receive_aucf");
    int opcode=0, result=0, UserID=0;
	RdpPacket_Localised buffer = IsoLayer.receive();
	
	opcode=buffer.get8();
	if ((opcode >>2) != AUCF) {
	    throw new RdesktopException("Expected AUCF got " + opcode);
	}

	result=buffer.get8();
	if (result!=0) {
	    throw new RdesktopException("Expected AURQ got " + result);
	}

	if ((opcode&2)!=0) {
	    UserID=buffer.getBigEndian16();
	}

	if (buffer.getPosition() != buffer.getEnd()){
	    throw new RdesktopException();
	}
	return UserID;
    }

    /**
     * Parse a BER header and determine data length
     * @param data Packet containing header at current read position
     * @param tagval Tag ID for data type
     * @return Length of following data
     * @throws RdesktopException
     */
    public int berParseHeader(RdpPacket_Localised data, int tagval) throws RdesktopException {
	int tag=0;
	int length=0;
	int len;

	if (tagval > 0x000000ff) {
	    tag = data.getBigEndian16();
	} else {
	    tag = data.get8();
	}

	if (tag !=tagval) {
	    throw new RdesktopException("Unexpected tag got " + tag + " expected " +tagval);
	}
    
	len=data.get8();
	
	if ((len&0x00000080)!=0) { 
	    len &= ~0x00000080; // subtract 128
	    length = 0;
	    while(len--!=0){
		length=(length << 8)+data.get8();
	    }
	} else {
	    length=len;
	}

	return length;
    }

    /**
     * Parse domain parameters sent by server
     * @param data Packet containing domain parameters at current read position
     * @throws RdesktopException
     */
    public void parseDomainParams(RdpPacket_Localised data) throws RdesktopException {
	int length;

	length = this.berParseHeader(data, TAG_DOMAIN_PARAMS);
	data.incrementPosition(length);

	if (data.getPosition() > data.getEnd()) {
	    throw new RdesktopException();
	}
    }
 
    /**
     * Retrieve the user ID stored by this MCS object
     * @return User ID
     */
    public int getUserID() {
	return this.McsUserID;
    }
}