@Override public void removeTunnel(final Requests request, final PccSession session) { final PlspId plspId = request.getLsp().getPlspId(); final Tunnel tunnel = this.tunnels.get(plspId); final long srpId = request.getSrp().getOperationId().getValue(); if (tunnel != null) { if (tunnel.getType() == LspType.PCE_LSP) { if (hasDelegation(tunnel, session)) { this.tunnels.remove(plspId); sendToAll( tunnel, plspId, tunnel.getLspState().getEro().getSubobject(), new SrpBuilder(request.getSrp()) .addAugmentation(Srp1.class, new Srp1Builder().setRemove(true).build()) .build(), reqToRptPath(request), request.getLsp()); } else { session.sendError( MsgBuilderUtil.createErrorMsg(PCEPErrors.UPDATE_REQ_FOR_NON_LSP, srpId)); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.LSP_NOT_PCE_INITIATED, srpId)); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UNKNOWN_PLSP_ID, srpId)); } }
protected GameState updateThis(float et) { music.update(et); factory.update(et, player.getSpeed()); field.update(et); tunnel.update(et); float offset = -getNearClippingPlane() - player.getL() / 2; totalDistance += -player.getZ() + offset; distortion.translateZ(player, offset, player.getSpeed()); tunnel.translateZ(player, offset); field.translateZ(player, offset); if (player.isAlive()) { return this; } else if (fadeOut > 0) { fadeOut -= FADE_OUT_RATE * et; return this; } else { // TODO: Better end-of-game System.out.println("Game over!"); System.out.println("Your score: " + score); System.out.println("Your speed: " + player.getSpeed()); System.out.println("Your distance: " + totalDistance); return null; } }
private void setDelegation(final PlspId plspId, final PccSession session) { final Tunnel tunnel = this.tunnels.get(plspId); final int sessionId; if (session != null) { sessionId = session.getId(); } else { sessionId = PCC_DELEGATION; } tunnel.setDelegationHolder(sessionId); }
private void doConnect(InetSocketAddress addr) throws IOException { dest = new Socket(); try { dest.connect(addr, 10000); } catch (SocketTimeoutException ex) { sendError(HOST_UNREACHABLE); return; } catch (ConnectException cex) { sendError(CONN_REFUSED); return; } // Success InetAddress iadd = addr.getAddress(); if (iadd instanceof Inet4Address) { out.write(PROTO_VERS); out.write(REQUEST_OK); out.write(0); out.write(IPV4); out.write(iadd.getAddress()); } else if (iadd instanceof Inet6Address) { out.write(PROTO_VERS); out.write(REQUEST_OK); out.write(0); out.write(IPV6); out.write(iadd.getAddress()); } else { sendError(GENERAL_FAILURE); return; } out.write((addr.getPort() >> 8) & 0xff); out.write((addr.getPort() >> 0) & 0xff); out.flush(); InputStream in2 = dest.getInputStream(); OutputStream out2 = dest.getOutputStream(); Tunnel tunnel = new Tunnel(in2, out); tunnel.start(); int b = 0; do { // Note that the socket might be closed from another thread (the tunnel) try { b = in.read(); if (b == -1) { in.close(); out2.close(); return; } out2.write(b); } catch (IOException ioe) { } } while (!client.isClosed()); }
/** * Stop all forwards giving the resource ID of the <i>SSL-Tunnel</i> that started them. * * @param launchSession launch session * @throws NoPermissionException if not allowed * @throws CoreException on any other error */ public void stopTunnels(LaunchSession launchSession) throws NoPermissionException, CoreException { if (!DefaultAgentManager.getInstance().hasActiveAgent(launchSession.getSession())) { throw new TunnelException(TunnelException.INTERNAL_ERROR, (Throwable) null, "No agent."); } Tunnel tunnel = (Tunnel) launchSession.getResource(); launchSession.checkAccessRights(null, agent.getSession()); MultiplexedConnection agent = DefaultAgentManager.getInstance().getAgentBySession(launchSession.getSession()); try { if (tunnel.getType() == TransportType.LOCAL_TUNNEL_ID) { Collection<Tunnel> l = new ArrayList<Tunnel>(); l.add(tunnel); stopLocalTunnels(agent, l); } else if (tunnel.getType() == TransportType.REMOTE_TUNNEL_ID) { Collection<Tunnel> l = new ArrayList<Tunnel>(); l.add(tunnel); stopRemoteTunnels(agent, l); } else { throw new TunnelException( TunnelException.INTERNAL_ERROR, (Throwable) null, "Unknown tunnel type " + tunnel.getType()); } CoreServlet.getServlet() .fireCoreEvent( new ResourceAccessEvent( this, TunnelsEventConstants.TUNNEL_CLOSED, launchSession.getResource(), launchSession.getPolicy(), launchSession.getSession(), CoreEvent.STATE_SUCCESSFUL)); } catch (TunnelException te) { CoreServlet.getServlet() .fireCoreEvent( new ResourceAccessEvent( this, TunnelsEventConstants.TUNNEL_CLOSED, launchSession.getResource(), launchSession.getPolicy(), launchSession.getSession(), te)); throw te; } finally { LaunchSessionFactory.getInstance().removeLaunchSession(launchSession); } }
/** * Start port forwards for the <i>SSL Tunnel</i> specified by the provided resource ID. * * @param launchSession launch session * @throws NoPermissionException if not allowed * @throws TunnelException on any other other * @throws PolicyException on any other determininig policy */ public void startTunnel(LaunchSession launchSession) throws NoPermissionException, TunnelException, PolicyException { if (!DefaultAgentManager.getInstance().hasActiveAgent(launchSession.getSession())) { throw new TunnelException(TunnelException.INTERNAL_ERROR, (Throwable) null, "No agent."); } else { Tunnel tunnel = (Tunnel) launchSession.getResource(); launchSession.checkAccessRights(null, agent.getSession()); AgentTunnel agent = DefaultAgentManager.getInstance().getAgentBySession(launchSession.getSession()); try { if (tunnel.getType() == TransportType.LOCAL_TUNNEL_ID) { startLocalTunnel(agent, tunnel, launchSession); } else if (tunnel.getType() == TransportType.REMOTE_TUNNEL_ID) { startRemoteTunnel(agent, tunnel, launchSession); } else { throw new TunnelException( TunnelException.INTERNAL_ERROR, (Throwable) null, "Unknown tunnel type " + tunnel.getType()); } // Fire event CoreServlet.getServlet() .fireCoreEvent( new ResourceAccessEvent( this, TunnelsEventConstants.TUNNEL_OPENED, launchSession.getResource(), launchSession.getPolicy(), launchSession.getSession(), CoreEvent.STATE_SUCCESSFUL)); } catch (TunnelException te) { // Fire event CoreServlet.getServlet() .fireCoreEvent( new ResourceAccessEvent( this, TunnelsEventConstants.TUNNEL_OPENED, launchSession.getResource(), launchSession.getPolicy(), launchSession.getSession(), te)); throw te; } } }
private void startStateTimeout(final Tunnel tunnel, final PlspId plspId) { if (this.stateTimeout > -1) { final Timeout newStateTimeout = this.timer.newTimeout( new TimerTask() { @Override public void run(final Timeout timeout) throws Exception { if (tunnel.getType() == LspType.PCE_LSP) { PccTunnelManagerImpl.this.tunnels.remove(plspId); // report tunnel removal to all sendToAll( tunnel, plspId, Collections.<Subobject>emptyList(), createSrp(0), new PathBuilder().build(), createLsp(plspId.getValue(), false, Optional.<Tlvs>absent(), false, true)); } } }, this.stateTimeout, TimeUnit.SECONDS); tunnel.setStateTimeout(newStateTimeout); } }
public boolean processRequest(Request request, MultiplexedConnection connection) { AgentTunnel agent = (AgentTunnel) connection; if (request.getRequestName().equals(SETUP_AND_LAUNCH_TUNNEL) && request.getRequestData() != null) { try { ByteArrayReader reader = new ByteArrayReader(request.getRequestData()); int id = (int) reader.readInt(); Tunnel resource = (Tunnel) TunnelPlugin.SSL_TUNNEL_RESOURCE_TYPE.getResourceById(id); if (resource == null) { throw new Exception("No resource with ID " + id); } Policy policy = LaunchSessionManager.getLaunchRequestPolicy(null, agent.getSession(), resource); if (resource.sessionPasswordRequired(agent.getSession())) { // TODO: prompt user for credentials through agent! return true; } else { LaunchSession launchSession = LaunchSessionFactory.getInstance() .createLaunchSession(agent.getSession(), resource, policy); launchSession.checkAccessRights(null, agent.getSession()); if (resource.getType() == TransportType.LOCAL_TUNNEL_ID) { try { Request req = buildLocalTunnel(resource, launchSession); request.setRequestData(req.getRequestData()); return true; } catch (IOException ioe) { throw new TunnelException(TunnelException.INTERNAL_ERROR, ioe); } } else if (resource.getType() == TransportType.REMOTE_TUNNEL_ID) { startRemoteTunnel(agent, resource, launchSession); request.setRequestData(null); return true; } else { throw new TunnelException( TunnelException.INTERNAL_ERROR, (Throwable) null, "Unknown tunnel type " + resource.getType()); } } } catch (Exception e) { log.error("Failed to start tunnel.", e); return false; } } return false; }
@Override public void returnDelegation(final Updates update, final PccSession session) { final PlspId plspId = update.getLsp().getPlspId(); final Tunnel tunnel = this.tunnels.get(plspId); final long srpId = update.getSrp().getOperationId().getValue(); if (tunnel != null) { // check if session really has a delegation if (hasDelegation(tunnel, session)) { // send report D=0 final Tlvs tlvs = createLspTlvs( plspId.getValue(), true, getDestinationAddress(tunnel.getLspState().getEro().getSubobject(), this.address), this.address, this.address, Optional.of(tunnel.getPathName())); session.sendReport( createPcRtpMessage( new LspBuilder(update.getLsp()) .setSync(true) .setOperational(OperationalStatus.Up) .setDelegate(false) .setTlvs(tlvs) .build(), Optional.of(createSrp(srpId)), tunnel.getLspState())); // start state timer startStateTimeout(tunnel, plspId); // if PCC's LSP, start re-delegation timer if (tunnel.getType() == LspType.PCC_LSP) { startRedelegationTimer(tunnel, plspId, session); } else { // if PCE-initiated LSP, revoke delegation instantly setDelegation(plspId, null); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UPDATE_REQ_FOR_NON_LSP, srpId)); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UNKNOWN_PLSP_ID, srpId)); } }
private void doBind(InetSocketAddress addr) throws IOException { ServerSocket svr = new ServerSocket(); svr.bind(null); InetSocketAddress bad = (InetSocketAddress) svr.getLocalSocketAddress(); out.write(PROTO_VERS); out.write(REQUEST_OK); out.write(0); out.write(IPV4); out.write(bad.getAddress().getAddress()); out.write((bad.getPort() >> 8) & 0xff); out.write((bad.getPort() & 0xff)); out.flush(); dest = svr.accept(); bad = (InetSocketAddress) dest.getRemoteSocketAddress(); out.write(PROTO_VERS); out.write(REQUEST_OK); out.write(0); out.write(IPV4); out.write(bad.getAddress().getAddress()); out.write((bad.getPort() >> 8) & 0xff); out.write((bad.getPort() & 0xff)); out.flush(); InputStream in2 = dest.getInputStream(); OutputStream out2 = dest.getOutputStream(); Tunnel tunnel = new Tunnel(in2, out); tunnel.start(); int b = 0; do { // Note that the socket might be close from another thread (the tunnel) try { b = in.read(); if (b == -1) { in.close(); out2.close(); return; } out2.write(b); } catch (IOException ioe) { } } while (!client.isClosed()); }
@Override public void addTunnel(final Requests request, final PccSession session) { final PlspId plspId = new PlspId(this.plspIDsCounter.incrementAndGet()); final Tunnel tunnel = new Tunnel( request.getLsp().getTlvs().getSymbolicPathName().getPathName().getValue(), session.getId(), LspType.PCE_LSP, reqToRptPath(request)); sendToAll( tunnel, plspId, request.getEro().getSubobject(), createSrp(request.getSrp().getOperationId().getValue()), tunnel.getLspState(), new LspBuilder(request.getLsp()) .addAugmentation(Lsp1.class, new Lsp1Builder().setCreate(true).build()) .build()); this.tunnels.put(plspId, tunnel); }
@Override public synchronized void onSessionUp(final PccSession session) { // first session - delegate all PCC's LSPs // only when reporting at startup if (!this.sessions.containsKey(session.getId()) && session.getId() == 0) { for (final PlspId plspId : this.tunnels.keySet()) { setDelegation(plspId, session); } } this.sessions.put(session.getId(), session); if (!this.tunnels.isEmpty()) { // report all known LSPs for (final Entry<PlspId, Tunnel> entry : this.tunnels.entrySet()) { final Tunnel tunnel = entry.getValue(); final boolean delegation = hasDelegation(tunnel, session); if (delegation) { tunnel.cancelTimeouts(); } final long plspId = entry.getKey().getValue(); final Tlvs tlvs = MsgBuilderUtil.createLspTlvs( plspId, true, getDestinationAddress(tunnel.getLspState().getEro().getSubobject(), this.address), this.address, this.address, Optional.of(tunnel.getPathName())); session.sendReport( createPcRtpMessage( createLsp(plspId, true, Optional.<Tlvs>fromNullable(tlvs), delegation, false), NO_SRP, tunnel.getLspState())); } // end-of-sync marker session.sendReport( createPcRtpMessage( createLsp(0, false, Optional.<Tlvs>absent(), true, false), NO_SRP, createPath(Collections.<Subobject>emptyList()))); } }
@Override public void reportToAll(final Updates update, final PccSession session) { final PlspId plspId = update.getLsp().getPlspId(); final Tunnel tunnel = this.tunnels.get(plspId); final long srpId = update.getSrp().getOperationId().getValue(); if (tunnel != null) { if (hasDelegation(tunnel, session)) { final Srp srp = createSrp(update.getSrp().getOperationId().getValue()); final Path path = updToRptPath(update.getPath()); final List<Subobject> subobjects = update.getPath().getEro().getSubobject(); final Lsp lsp = update.getLsp(); sendToAll(tunnel, plspId, subobjects, srp, path, lsp); // update tunnel state tunnel.setLspState(path); } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UPDATE_REQ_FOR_NON_LSP, srpId)); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UNKNOWN_PLSP_ID, srpId)); } }
void stopRemoteTunnels(MultiplexedConnection agent, Collection<Tunnel> tunnels) throws CoreException { CoreException e = null; for (Tunnel tunnel : tunnels) { try { RemoteTunnel rt = RemoteTunnelManagerFactory.getInstance().getRemoteTunnel(tunnel.getResourceId()); if (rt != null) { rt.stopListener(); } else { throw new Exception("No active with ID for " + tunnel.getResourceId()); } } catch (Exception ex) { throw new TunnelException(TunnelException.INTERNAL_ERROR, ex); } } if (e != null) { throw e; } }
void stopLocalTunnels(MultiplexedConnection agent, Collection<Tunnel> tunnels) throws CoreException { CoreException e = null; for (Tunnel tunnel : tunnels) { try { ByteArrayWriter msg = new ByteArrayWriter(); msg.writeInt(tunnel.getResourceId()); if (!agent.sendRequest(new Request(STOP_LOCAL_TUNNEL, msg.toByteArray()), false) && e == null) { e = new TunnelException( TunnelException.AGENT_REFUSED_LOCAL_TUNNEL_STOP, (Throwable) null); } } catch (IOException ex) { throw new TunnelException(TunnelException.INTERNAL_ERROR, ex); } } if (e != null) { throw e; } }
@SuppressWarnings("unchecked") void notifyAutoStartTunnels() { try { SessionInfo session = agent.getSession(); List<Tunnel> tunnels = ResourceUtil.getGrantedResource(session, TunnelPlugin.SSL_TUNNEL_RESOURCE_TYPE); List<BundleActionMessage> tunnelFailures = new ArrayList<BundleActionMessage>(); for (Tunnel tunnel : tunnels) { if (tunnel.isAutoStart()) { try { Policy policy = PolicyDatabaseFactory.getInstance() .getGrantingPolicyForUser(session.getUser(), tunnel); LaunchSession launchSession = LaunchSessionFactory.getInstance().createLaunchSession(session, tunnel, policy); startTunnel(launchSession); } catch (TunnelException tne) { log.error("failed to start tunnel: '" + tunnel + "'", tne); tunnelFailures.add(tne.getBundleActionMessage()); } } } if (!tunnelFailures.isEmpty()) { tunnelFailures.add( 0, new BundleActionMessage("tunnels", "error.tunnels.autostart", tunnelFailures.size())); for (BundleActionMessage actionMessage : tunnelFailures) { GlobalWarning globalWarning = new GlobalWarning(session.getHttpSession(), actionMessage); GlobalWarningManager.getInstance().addToSession(globalWarning); } } } catch (Exception e) { log.error("Failed to start auto-start tunnels", e); } }
private void startRedelegationTimer( final Tunnel tunnel, final PlspId plspId, final PccSession session) { final Timeout newRedelegationTimeout = this.timer.newTimeout( new TimerTask() { @Override public void run(final Timeout timeout) throws Exception { // remove delegation PccTunnelManagerImpl.this.setDelegation(plspId, null); // delegate to another PCE int index = session.getId(); for (int i = 1; i < PccTunnelManagerImpl.this.sessions.size(); i++) { index++; if (index == PccTunnelManagerImpl.this.sessions.size()) { index = 0; } final PccSession nextSession = PccTunnelManagerImpl.this.sessions.get(index); if (nextSession != null) { tunnel.cancelTimeouts(); final Tlvs tlvs = createLspTlvs( plspId.getValue(), true, getDestinationAddress( tunnel.getLspState().getEro().getSubobject(), PccTunnelManagerImpl.this.address), PccTunnelManagerImpl.this.address, PccTunnelManagerImpl.this.address, Optional.of(tunnel.getPathName())); nextSession.sendReport( createPcRtpMessage( createLsp( plspId.getValue(), true, Optional.<Tlvs>fromNullable(tlvs), true, false), NO_SRP, tunnel.getLspState())); tunnel.setDelegationHolder(nextSession.getId()); break; } } } }, this.redelegationTimeout, TimeUnit.SECONDS); tunnel.setRedelegationTimeout(newRedelegationTimeout); }
private void sendToAll( final Tunnel tunnel, final PlspId plspId, final List<Subobject> subobjects, final Srp srp, final Path path, final Lsp lsp) { for (final PccSession session : this.sessions.values()) { final boolean isDelegated = hasDelegation(tunnel, session); final Tlvs tlvs = createLspTlvs( plspId.getValue(), true, getDestinationAddress(subobjects, this.address), this.address, this.address, Optional.of(tunnel.getPathName())); final Pcrpt pcRpt = createPcRtpMessage( new LspBuilder(lsp) .setPlspId(plspId) .setOperational(OperationalStatus.Up) .setDelegate(isDelegated) .setSync(true) .addAugmentation( Lsp1.class, new Lsp1Builder() .setCreate(tunnel.getType() == LspType.PCE_LSP ? true : false) .build()) .setTlvs(tlvs) .build(), Optional.fromNullable(srp), path); session.sendReport(pcRpt); } }
Request buildLocalTunnel(Tunnel tunnel, LaunchSession launchSession) throws IOException { // Process destination host and port for replacement variables VariableReplacement r = new VariableReplacement(); r.setLaunchSession(launchSession); String destHost = r.replace(tunnel.getDestination().getHost()); ByteArrayWriter msg = new ByteArrayWriter(); msg.writeString(launchSession == null ? "" : launchSession.getId()); msg.writeInt(tunnel.getResourceId()); msg.writeString(tunnel.getResourceName()); msg.writeInt(tunnel.getType()); msg.writeString(tunnel.getTransport()); msg.writeString(tunnel.getSourceInterface()); msg.writeInt(tunnel.getSourcePort()); msg.writeInt(tunnel.getDestination().getPort()); msg.writeString(destHost); Request req = new Request(START_LOCAL_TUNNEL, msg.toByteArray()); return req; }
@Override public void takeDelegation(final Requests request, final PccSession session) { final PlspId plspId = request.getLsp().getPlspId(); final Tunnel tunnel = this.tunnels.get(plspId); final long srpId = request.getSrp().getOperationId().getValue(); if (tunnel != null) { // check if tunnel has no delegation if (tunnel.type == LspType.PCE_LSP && (tunnel.getDelegationHolder() == -1 || tunnel.getDelegationHolder() == session.getId())) { // set delegation tunnel.cancelTimeouts(); setDelegation(plspId, session); // send report final Tlvs tlvs = createLspTlvs( plspId.getValue(), true, getDestinationAddress(tunnel.getLspState().getEro().getSubobject(), this.address), this.address, this.address, Optional.of(tunnel.getPathName())); session.sendReport( createPcRtpMessage( new LspBuilder(request.getLsp()) .setSync(true) .setOperational(OperationalStatus.Up) .setDelegate(true) .setTlvs(tlvs) .build(), Optional.of(createSrp(srpId)), tunnel.getLspState())); } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.LSP_NOT_PCE_INITIATED, srpId)); } } else { session.sendError(MsgBuilderUtil.createErrorMsg(PCEPErrors.UNKNOWN_PLSP_ID, srpId)); } }
private void getRequestV4() throws IOException { int ver = in.read(); int cmd = in.read(); if (ver == -1 || cmd == -1) { // EOF in.close(); out.close(); return; } if (ver != 0 && ver != 4) { out.write(PROTO_VERS4); out.write(91); // Bad Request out.write(0); out.write(0); out.write(0); out.write(0); out.write(0); out.write(0); out.write(0); out.flush(); purge(); out.close(); in.close(); return; } if (cmd == CONNECT) { int port = ((in.read() & 0xff) << 8); port += (in.read() & 0xff); byte[] buf = new byte[4]; readBuf(in, buf); InetAddress addr = InetAddress.getByAddress(buf); // We don't use the username... int c; do { c = (in.read() & 0xff); } while (c != 0); boolean ok = true; try { dest = new Socket(addr, port); } catch (IOException e) { ok = false; } if (!ok) { out.write(PROTO_VERS4); out.write(91); out.write(0); out.write(0); out.write(buf); out.flush(); purge(); out.close(); in.close(); return; } out.write(PROTO_VERS4); out.write(90); // Success out.write((port >> 8) & 0xff); out.write(port & 0xff); out.write(buf); out.flush(); InputStream in2 = dest.getInputStream(); OutputStream out2 = dest.getOutputStream(); Tunnel tunnel = new Tunnel(in2, out); tunnel.start(); int b = 0; do { try { b = in.read(); if (b == -1) { in.close(); out2.close(); return; } out2.write(b); } catch (IOException ex) { } } while (!client.isClosed()); } }
protected void drawThis(GL2 gl) { gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); configureGL(gl); tunnel.draw(gl, distortion); field.draw(gl); }
private static boolean hasDelegation(final Tunnel tunnel, final PccSession session) { return tunnel.getDelegationHolder() == session.getId(); }