private ChannelFuture sendFile(ChannelHandlerContext ctx, Channel ch, FileChunk file) throws IOException { RandomAccessFile raf; try { raf = new RandomAccessFile(file.getFile(), "r"); } catch (FileNotFoundException fnfe) { return null; } ChannelFuture writeFuture; if (ch.getPipeline().get(SslHandler.class) != null) { // Cannot use zero-copy with HTTPS. writeFuture = ch.write(new ChunkedFile(raf, file.startOffset(), file.length(), 8192)); } else { // No encryption - use zero-copy. final FileRegion region = new DefaultFileRegion(raf.getChannel(), file.startOffset(), file.length()); writeFuture = ch.write(region); writeFuture.addListener( new ChannelFutureListener() { public void operationComplete(ChannelFuture future) { region.releaseExternalResources(); } }); } return writeFuture; }
/** * Sets the values of the properties of a specific <tt>ColibriConferenceIQ</tt> to the values of * the respective properties of this instance. Thus, the specified <tt>iq</tt> may be thought of * as a description of this instance. * * <p><b>Note</b>: The copying of the values is deep i.e. the <tt>Contents</tt>s of this instance * are described in the specified <tt>iq</tt>. * * @param iq the <tt>ColibriConferenceIQ</tt> to set the values of the properties of this instance * on */ public void describeDeep(ColibriConferenceIQ iq) { describeShallow(iq); if (isRecording()) { ColibriConferenceIQ.Recording recordingIQ = new ColibriConferenceIQ.Recording(State.ON.toString()); recordingIQ.setDirectory(getRecordingDirectory()); iq.setRecording(recordingIQ); } for (Content content : getContents()) { ColibriConferenceIQ.Content contentIQ = iq.getOrCreateContent(content.getName()); for (Channel channel : content.getChannels()) { if (channel instanceof SctpConnection) { ColibriConferenceIQ.SctpConnection sctpConnectionIQ = new ColibriConferenceIQ.SctpConnection(); channel.describe(sctpConnectionIQ); contentIQ.addSctpConnection(sctpConnectionIQ); } else { ColibriConferenceIQ.Channel channelIQ = new ColibriConferenceIQ.Channel(); channel.describe(channelIQ); contentIQ.addChannel(channelIQ); } } } }
/** * Copy a file to specific destination with WinSCP command * * @param lfile file you want to transfer * @param rfile destination file */ public synchronized void scpTo(String lfile, String rfile) { if (!connected) { throw new ActionFailedException("There is no session!"); } try { // exec 'scp -t rfile' remotely String command = "scp -p -t " + rfile; channel = session.openChannel("exec"); ((ChannelExec) channel).setCommand(command); // get I/O streams for remote scp OutputStream out = channel.getOutputStream(); InputStream in = channel.getInputStream(); channel.connect(); // byte[] tmp = new byte[1]; checkAck(in); // send "C0644 filesize filename", where filename should not include '/' int filesize = (int) (new File(lfile)).length(); command = "C0644 " + filesize + " "; if (lfile.lastIndexOf('/') > 0) { command += lfile.substring(lfile.lastIndexOf('/') + 1); } else { command += lfile; } command += "\n"; out.write(command.getBytes()); out.flush(); checkAck(in); // send a content of lfile FileInputStream fis = new FileInputStream(lfile); byte[] buf = new byte[1024]; while (true) { int len = fis.read(buf, 0, buf.length); if (len <= 0) break; out.write(buf, 0, len); out.flush(); } fis.close(); // send '\0' buf[0] = 0; out.write(buf, 0, 1); out.flush(); checkAck(in); } catch (Exception e) { throw new ItemNotFoundException("Failed to copy file: " + e.getMessage()); } finally { if (channel != null) { channel.disconnect(); } } }
public MessageDispatcher(Channel channel, MessageListener l, MembershipListener l2) { this.channel = channel; prot_adapter = new ProtocolAdapter(); if (channel != null) { local_addr = channel.getAddress(); channel.addChannelListener(this); } setMessageListener(l); setMembershipListener(l2); if (channel != null) installUpHandler(prot_adapter, true); start(); }
@Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { Channel ch = e.getChannel(); Throwable cause = e.getCause(); if (cause instanceof TooLongFrameException) { sendError(ctx, BAD_REQUEST); return; } cause.printStackTrace(); if (ch.isConnected()) { sendError(ctx, INTERNAL_SERVER_ERROR); } }
public void textInserted(Message.TextPasteMsg m) { try { int SenderId = m.getClientId(); int offset = m.getOffset(); String textPasted = m.getText(); if (EditorServer_Debug) System.err.println("EditorServer->textinserted : PASTED by : " + SenderId); Vector pars = null; try { pars = lockManager.textInserted(m.getPar(), offset, textPasted, SenderId); if (EditorServer_Debug) System.err.println("\n+=*%EditorServer--> textInserted recovered VECTOR..."); } catch (Exception e) { System.err.println("\n+=*%EditorServer--> textInserted VECTOR error "); } textChannel.sendToOthers(client, new Data(m)); EditorClient SenderClient = getEditorClient(SenderId); SenderClient.addTextPasteAction(System.currentTimeMillis(), pars, offset, textPasted); clientsPanel.updateActionTableFor(SenderClient); updateParagraphList(); } catch (Exception e) { System.err.println("\nEditorServer--> textPasted: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void textInserted(Message.TextInsertMsg m) { if (EditorServer_Debug) System.err.println("EditorServer-> textInserted."); try { int ClientId = m.getClientId(); int offset = m.getOffset(); String characterInserted = m.getText(); if (EditorServer_Debug) System.out.println("EditorServer-> textInserted : *" + characterInserted + "*"); Vector pars = lockManager.textInserted(m.getPar(), offset, characterInserted, ClientId); textChannel.sendToOthers(client, new Data(m)); EditorClient c = getEditorClient(ClientId); // new condition inserted to avoid timestamp generation if the character // is a newline if (characterInserted.equals("\n")) { if (EditorServer_Debug) System.out.println("EditorServer-> textInserted : attempting to insert a newLine"); } c.addTextInsertAction(System.currentTimeMillis(), pars, offset, characterInserted); clientsPanel.updateActionTableFor(c); updateParagraphList(); } catch (Exception e) { System.err.println("EditorServer-> textInserted: error receiving-sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void sendHighlights() { // send highlights to everybody try { Iterator i = highlights.getHighlights().iterator(); while (i.hasNext()) { Highlights.Highlight h = (Highlights.Highlight) i.next(); Paragraph sPar = lockManager.getParFromOffset(h.getStart()); Paragraph ePar = lockManager.getParFromOffset(h.getEnd()); if (EditorServer_Debug) { System.out.println("StartPar: " + sPar.toString()); System.out.println("EndPar: " + ePar.toString()); } Message.HighlightAddMsg msg = new Message.HighlightAddMsg( -1, h.getId(), h.getType().getId(), sPar.getID(), ePar.getID(), h.getStart() - sPar.getOffset(), h.getEnd() - ePar.getOffset()); textChannel.sendToOthers(client, new Data(msg)); } } catch (Exception e) { System.err.println("EditorServer: sendHighlights: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
/** {@inheritDoc} */ @Override public void expire() { try { eventDispatcher.shutdown(); } finally { super.expire(); } }
public void stop() { if (corr != null) corr.stop(); if (channel instanceof JChannel) { TP transport = channel.getProtocolStack().getTransport(); transport.unregisterProbeHandler(probe_handler); corr.unregisterProbeHandler(transport); } }
public void sendClientReject(int keyValue, int reason) { Message.ClientRejectMsg msg = new Message.ClientRejectMsg(-1, keyValue, reason); try { clientChannel.sendToOthers(client, new Data(msg)); } catch (Exception e) { System.err.println("EditorServer: clientRejected: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void setChannel(Channel ch) { if (ch == null) return; this.channel = ch; local_addr = channel.getAddress(); if (prot_adapter == null) prot_adapter = new ProtocolAdapter(); // Don't force installing the UpHandler so subclasses can use this // method and still integrate with a MuxUpHandler installUpHandler(prot_adapter, false); }
public void scrollMoved(Message.ScrollMoveMsg m) { // if(EditorServer_Debug) System.err.println("EditorServer: scrollMoved.") ; try { clientChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: scrollMoved: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void sendDocumentState(int clientId) { Message.DocumentStateMsg msg = new Message.DocumentStateMsg(clientId, lockManager.getDocumentAsXML()); try { clientChannel.sendToOthers(client, new Data(msg)); } catch (Exception e) { System.err.println("EditorServer: sendDocumentState: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
/* * (non-Javadoc) * * @see * org.eclipse.ecf.provider.filetransfer.outgoing.AbstractOutgoingFileTransfer * #openStreams() */ protected void openStreams() throws IncomingFileTransferException { try { // Set input stream from local file final URL url = getRemoteFileURL(); this.username = url.getUserInfo(); scpUtil = new ScpUtil(this); final Session s = scpUtil.getSession(); s.connect(); final String command = SCP_COMMAND + scpUtil.trimTargetFile(url.getPath()); channel = s.openChannel(SCP_EXEC); ((ChannelExec) channel).setCommand(command); channel.connect(); final InputStream ins = channel.getInputStream(); responseStream = channel.getOutputStream(); scpUtil.sendZeroToStream(responseStream); final int c = checkAck(ins); if (c != 'C') throw new IOException(Messages.ScpRetrieveFileTransfer_EXCEPTION_SCP_PROTOCOL); // read '0644 ' final byte[] buf = new byte[1024]; ins.read(buf, 0, 5); setFileLength(readFileSize(ins, buf)); readFileName(ins, buf); // set input stream for reading rest of file remoteFileContents = ins; scpUtil.sendZeroToStream(responseStream); fireReceiveStartEvent(); } catch (final Exception e) { channel = null; username = null; throw new IncomingFileTransferException( NLS.bind( Messages.ScpRetrieveFileTransfer_EXCEPTION_CONNECTING, getRemoteFileURL().toString()), e); } }
public void start() { if (corr == null) corr = createRequestCorrelator(prot_adapter, this, local_addr) .asyncDispatching(async_dispatching); correlatorStarted(); corr.start(); if (channel != null) { List<Address> tmp_mbrs = channel.getView() != null ? channel.getView().getMembers() : null; setMembers(tmp_mbrs); if (channel instanceof JChannel) { TP transport = channel.getProtocolStack().getTransport(); corr.registerProbeHandler(transport); } TP transport = channel.getProtocolStack().getTransport(); hardware_multicast_supported = transport.supportsMulticasting(); transport.registerProbeHandler(probe_handler); } }
/** * This procedure is invoked to process the "flush" Tcl command. See the user documentation for * details on what it does. * * @param interp the current interpreter. * @param argv command arguments. */ public void cmdProc(Interp interp, TclObject argv[]) throws TclException { Channel chan; /* The channel being operated on this method */ if (argv.length != 2) { throw new TclNumArgsException(interp, 1, argv, "channelId"); } chan = TclIO.getChannel(interp, argv[1].toString()); if (chan == null) { throw new TclException(interp, "can not find channel named \"" + argv[1].toString() + "\""); } try { chan.flush(interp); } catch (IOException e) { throw new TclRuntimeError( "FlushCmd.cmdProc() Error: IOException when flushing " + chan.getChanName()); } }
public void lockReleased(Message.LockReleaseMsg m) { if (EditorServer_Debug) System.err.println("EditorServer: lockReleased."); lockManager.lockReleased(m.getStartPar(), m.getEndPar(), m.getClientId()); try { textChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: lockReleased: error sending lock released"); if (EditorServer_Debug) e.printStackTrace(); } }
public void highlightDeleted(Message.HighlightDeleteMsg m) { if (EditorServer_Debug) System.err.println("EditorServer: highlightDeleted."); highlights.deleteHighlight(m.getId()); EditorClient c = getEditorClient(m.getClientId()); try { textChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: highlightDeleted: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
private void cleanup(int code, String message) { try { channel.close(code, message); } catch (Exception e) { logger.debug("failed to close channel on [{}]", e, message); } try { connection.close(code, message); } catch (Exception e) { logger.debug("failed to close connection on [{}]", e, message); } }
/** * Creates a channel for shell type in the current session channel types = shell, sftp, exec(X * forwarding), direct-tcpip(stream forwarding) etc * * @param sshContact ID of SSH Contact */ public void createShellChannel(ContactSSH sshContact) throws IOException { try { Channel shellChannel = sshContact.getSSHSession().openChannel("shell"); // initalizing the reader and writers of ssh contact sshContact.initializeShellIO(shellChannel.getInputStream(), shellChannel.getOutputStream()); ((ChannelShell) shellChannel) .setPtyType(sshContact.getSSHConfigurationForm().getTerminalType()); // initializing the shell shellChannel.connect(1000); sshContact.setShellChannel(shellChannel); sshContact.sendLine("export PS1="); } catch (JSchException ex) { sshContact.setSSHSession(null); throw new IOException("Unable to create shell channel to remote" + " server"); } }
public void highlightTypeAdded(Message.HighlightTypeMsg m) { if (EditorServer_Debug) System.err.println("EditorServer: highlightTypeAdded."); highlights.addHighlightType(m.getId(), m.getName(), m.getColor()); try { textChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: highlightTypeAdded: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void highlightEdited(Message.HighlightEditMsg m) { if (EditorServer_Debug) System.err.println("EditorServer: highlightEdited."); highlights.editHighlight( m.getId(), m.getStartPar(), m.getStartOffset(), m.getEndPar(), m.getEndOffset()); try { textChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: highlightEdited: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void lockRequested(Message.LockRequestMsg m) { if (EditorServer_Debug) System.err.println("EditorServer -> lockRequested."); /* java.util.Timer t = new java.util.Timer() ; t.schedule(new TimerTask() { public void run() { client.lockDenied(id) ; } }, 3000) ; */ if (lockManager.lockRequested(m.getStartPar(), m.getEndPar(), m.getClientId())) { if (EditorServer_Debug) System.out.println("Lock Granted"); Message.LockGrantMsg reply = new Message.LockGrantMsg( m.getClientId(), m.getStartPar(), m.getEndPar(), m.getIdNumber()); try { textChannel.sendToOthers(client, new Data(reply)); } catch (Exception e) { System.err.println("EditorServer: lockRequested: error sending lock granted"); if (EditorServer_Debug) e.printStackTrace(); } } else { if (EditorServer_Debug) System.out.println("Lock Denied"); // send lock denied to sender Message.LockDenyMsg reply = new Message.LockDenyMsg(m.getClientId(), m.getIdNumber()); try { textChannel.sendToOthers(client, new Data(reply)); } catch (Exception e) { System.err.println("EditorServer: lockRequested: error sending lock denied"); if (EditorServer_Debug) e.printStackTrace(); } } }
public void clientLeft(Message.ClientLeaveMsg m) { System.out.println("EditorServer: clientLeft"); EditorClient ec = getEditorClient(m.getClientId()); ec.setPresent(false); clientsPanel.updateClientList(); try { clientChannel.sendToOthers(client, new Data(m)); } catch (Exception e) { System.err.println("EditorServer: clientLeft: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void disconnect() { if (connected) { if (channel != null) { channel.disconnect(); channel = null; } if (session != null) { session.disconnect(); session = null; } connected = false; } }
/** * Sets the given UpHandler as the UpHandler for the channel, or, if the channel already has a * Muxer installed as it's UpHandler, sets the given handler as the Muxer's {@link * Muxer#setDefaultHandler(Object) default handler}. If the relevant handler is already installed, * the <code>canReplace</code> controls whether this method replaces it (after logging a WARN) or * simply leaves <code>handler</code> uninstalled. * * <p>Passing <code>false</code> as the <code>canReplace</code> value allows callers to use this * method to install defaults without concern about inadvertently overriding * * @param handler the UpHandler to install * @param canReplace <code>true</code> if an existing Channel upHandler or Muxer default upHandler * can be replaced; <code>false</code> if this method shouldn't install */ protected void installUpHandler(UpHandler handler, boolean canReplace) { UpHandler existing = channel.getUpHandler(); if (existing == null) { channel.setUpHandler(handler); } else if (existing instanceof Muxer<?>) { @SuppressWarnings("unchecked") Muxer<UpHandler> mux = (Muxer<UpHandler>) existing; if (mux.getDefaultHandler() == null) { mux.setDefaultHandler(handler); } else if (canReplace) { log.warn( "Channel Muxer already has a default up handler installed (" + mux.getDefaultHandler() + ") but now it is being overridden"); mux.setDefaultHandler(handler); } } else if (canReplace) { log.warn( "Channel already has an up handler installed (" + existing + ") but now it is being overridden"); channel.setUpHandler(handler); } }
public void gestureLine(Message.GestureLineMsg m) { if (EditorServer_Debug) System.err.println("EditorServer: gestureLine." + String.valueOf(m.getId())); try { clientChannel.sendToOthers(client, new Data(m)); EditorClient c = getEditorClient(m.getClientId()); long par = getParIdForGesture(m.getPar(), m.getAY()); c.addGestureAction(System.currentTimeMillis(), m.getId(), par, m.getAX(), m.getAY(), this); c.addGestureAction(System.currentTimeMillis(), m.getId(), par, m.getBX(), m.getBY(), this); clientsPanel.updateActionTableFor(c); } catch (Exception e) { System.err.println("EditorServer: gestureLine: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void clientAppeared() { if (EditorServer_Debug) System.out.println("EditorServer: clientAppeared."); // send client list to everybody try { Iterator i = clients.iterator(); while (i.hasNext()) { EditorClient ec = (EditorClient) i.next(); if (ec.isPresent()) clientChannel.sendToOthers(client, new Data(ec.getMessage())); } } catch (Exception e) { System.err.println("EditorServer: clientAppeared: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }
public void sendHighlightTypes() { // send highlightTypes to everybody try { Iterator i = highlights.getHighlightTypes().iterator(); while (i.hasNext()) { HighlightType type = (HighlightType) i.next(); if (EditorServer_Debug) System.out.println("EditorServer: sendHighlightTypes. " + String.valueOf(type.getId())); Message.HighlightTypeMsg msg = new Message.HighlightTypeMsg(-1, type.getId(), type.getName(), type.getColor()); textChannel.sendToOthers(client, new Data(msg)); } } catch (Exception e) { System.err.println("EditorServer: sendHighlightTypes: error sending msg"); if (EditorServer_Debug) e.printStackTrace(); } }