Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2014 Red Hat, Inc., and individual contributors
   * as indicated by the @author tags.
   *
   * Licensed 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 io.undertow.websockets.core.protocol.version07;
 
 
io.undertow.websockets.core.StreamSinkFrameChannel implementation for writing WebSocket Frames on io.undertow.websockets.core.WebSocketVersion.V08 connections

Author(s):
Norman Maurer
 
 public abstract class WebSocket07FrameSinkChannel extends StreamSinkFrameChannel {
 
     private final int maskingKey;
     private final Masker masker;
     private final long payloadSize;
     private boolean dataWritten = false;
     long toWrite;
 
                                        long payloadSize) {
         super(wsChanneltype);
         this. = payloadSize;
         this. = payloadSize;
         if(wsChannel.isClient()) {
              = new Random().nextInt();
              = new Masker();
         } else {
              = null;
              = 0;
         }
     }
 
     @Override
     protected void handleFlushComplete(boolean finalFrame) {
          = true;
         if( != null) {
             .setMaskingKey();
         }
     }


    
If a stream sink channel is closed while in the middle of sending fragmented data we need to close the connection.

 
     protected void channelForciblyClosed() throws IOException {
         getChannel().sendClose();
     }
 
     private byte opCode() {
         if() {
             return .;
         }
         switch (getType()) {
         case :
             return .;
         case :
             return .;
         case :
             return .;
         case :
             return .;
         case :
             return .;
         case :
             return .;
         default:
             throw ..unsupportedFrameType(getType());
         }
     }
 
     @Override
     protected SendFrameHeader createFrameHeader() {
         if( >= 0 && ) {
            //for fixed length we don't need more than one header
            return null;
        }
        Pooled<ByteBufferstart = getChannel().getBufferPool().allocate();
        byte b0 = 0;
        //if writes are shutdown this is the final fragment
        if (isFinalFrameQueued() ||  >= 0) {
            b0 |= 1 << 7;
        }
        b0 |= (getRsv() & 7) << 4;
        b0 |= opCode() & 0xf;
        final ByteBuffer header = start.getResource();
        //int maskLength = 0; // handle masking for clients but we are currently only
        // support servers this is not a priority by now
        byte maskKey = 0;
        if( != null) {
            maskKey |= 1 << 7;
        }
        long payloadSize;
        if(this. >= 0) {
            payloadSize = this.;
        } else {
            payloadSize = getBuffer().remaining();
        }
        if (payloadSize <= 125) {
            header.put(b0);
            header.put((byte)((payloadSize | maskKey) & 0xFF));
        } else if (payloadSize <= 0xFFFF) {
            header.put(b0);
            header.put((byte) ((126 | maskKey) & 0xFF));
            header.put((byte) (payloadSize >>> 8 & 0xFF));
            header.put((byte) (payloadSize & 0xFF));
        } else {
            header.put(b0);
            header.put((byte) ((127 | maskKey) & 0xFF));
            header.putLong(payloadSize);
        }
        if( != null) {
            header.put((byte)(( >> 24) & 0xFF));
            header.put((byte)(( >> 16) & 0xFF));
            header.put((byte)(( >> 8) & 0xFF));
            header.put((byte)(( & 0xFF)));
        }
        header.flip();
        return new SendFrameHeader(0, start);
    }
    @Override
    public long write(final ByteBuffer[] srcsthrows IOException {
        return write(srcs, 0, srcs.length);
    }
    @Override
    public long write(final ByteBuffer[] srcsfinal int offsetfinal int lengththrows IOException {
        if( >= 0 && Buffers.remaining(srcs) > ) {
            throw ..messageOverflow();
        }
        if( == null) {
            return super.write(srcsoffsetlength);
        } else {
            final Pooled<ByteBufferbuffer = getChannel().getBufferPool().allocate();
            try {
                ByteBuffer[] copy = new ByteBuffer[length];
                for(int i = 0; i < length; ++i) {
                    copy[i] = srcs[offset + i].duplicate();
                }
                Buffers.copy(buffer.getResource(), copy, 0, length);
                buffer.getResource().flip();
                .beforeWrite(buffer.getResource(), 0, buffer.getResource().remaining());
                long written = super.write(buffer.getResource());
                long toAllocate = written;
                for(int i = offseti < length; ++i) {
                    ByteBuffer thisBuf = srcs[i];
                    if(toAllocate < thisBuf.remaining()) {
                        thisBuf.position((int) (thisBuf.position() + toAllocate));
                        break;
                    } else {
                        toAllocate -= thisBuf.remaining();
                        thisBuf.position(thisBuf.limit());
                    }
                }
                 -= written;
                return written;
            } finally {
                buffer.free();
            }
        }
    }
    @Override
    public int write(final ByteBuffer srcthrows IOException {
        if( >= 0 && src.remaining() > ) {
            throw ..messageOverflow();
        }
        if( == null) {
            return super.write(src);
        } else {
            final Pooled<ByteBufferbuffer = getChannel().getBufferPool().allocate();
            try {
                ByteBuffer copy = src.duplicate();
                Buffers.copy(buffer.getResource(), copy);
                buffer.getResource().flip();
                .beforeWrite(buffer.getResource(), 0, buffer.getResource().remaining());
                int written = super.write(buffer.getResource());
                src.position(src.position() + written);
                 -= written;
                return written;
            } finally {
                buffer.free();
            }
        }
    }
New to GrepCode? Check out our FAQ X