presentitymanager.java

The source code for this package is located in src/gov/nist/sip/proxy. The proxy is a pure JAIN-SIP

		}

		// 6. Examine If-Match header

		Header ifMatchHeader = (Header) request.getHeader("SIP-If-Match");
		String entityTag = new String();
		if (ifMatchHeader != null) {
			String ifMatchString = ifMatchHeader.toString();
			int colon = ifMatchString.indexOf(":");
			entityTag = ifMatchString.substring(colon + 1).trim();
		}
		// if(more than one entity-tag) return 400(Invalid request)

		// 7. Expiration header
		// This is ignored for now, published data is used until
		// updated

		// 8. Process body
		if (responseCode == Response.OK) {
			Object content = request.getContent();
			String newBody = null;
			if (content instanceof String) {
				newBody = (String) content;
			} else if (content instanceof byte[]) {
				newBody = new String((byte[]) content);
			}

			// get oldBody from notifier
			String oldBody = notifier.getFullState();

			if (oldBody.length() > 0) {
				// Merge the old and new body.

				// parse old body
				xmlCpimParser.parseCPIMString(oldBody.trim());
				PresenceTag oldPresenceTag = xmlCpimParser.getPresenceTag();
				Vector oldTupleTagList = oldPresenceTag.getTupleTagList();

				// parse new body, generate a list of all id's
				xmlCpimParser.parseCPIMString(newBody.trim());
				PresenceTag newPresenceTag = xmlCpimParser.getPresenceTag();
				if (newPresenceTag == null) {
					logger.error("ERROR: The incoming presence Tag is null!!!");
					return Response.BAD_REQUEST;
				}
				Vector newTupleTagList = newPresenceTag.getTupleTagList();

				// Iterate through the old list and update old Tuples
				for (int i = 0; i < oldTupleTagList.size(); i++) {
					TupleTag oldTupleTag = (TupleTag) oldTupleTagList.get(i);
					String tupleId = oldTupleTag.getId();
					for (int j = 0; j < newTupleTagList.size(); j++) {
						TupleTag newTag = (TupleTag) newTupleTagList.get(j);
						if (newTag.getId().equals(tupleId)) {
							// replace the old tuple with the new
							oldTupleTagList.setElementAt(
									(Object) newTupleTagList.remove(j), i);
							break;
						}
					}
				}

				// add new tuples
				while (!newTupleTagList.isEmpty()) {
					TupleTag newTT = (TupleTag) newTupleTagList.remove(0);
					oldPresenceTag.addTupleTag(newTT);
				}

				newBody = oldPresenceTag.toString();
			}

			// Update the notifier
			notifier.setFullState(newBody);

			// Update subscribers. Should be partial update someday
			Collection notifiersSubscriberKeys = notifier.getSubscribers();
			Iterator it = notifiersSubscriberKeys.iterator();
			while (it.hasNext()) {
				String dialogId = (String) it.next();
				if (logger.isDebugEnabled())
					logger.debug("getting subscriber for " + dialogId);
				Subscriber subscriber = (Subscriber) subscribers.get(dialogId);
				subscriber.updateNotifyBody(newBody);
			}

		}

		return responseCode;
	}

	/**
	 * Processes incoming notify requests from virtual subscribers.
	 * 
	 */
	public synchronized int processNotify(Request request, Dialog dialog) {

		int responseCode;

		// Check event. If not recognized, return 489 BAD_EVENT

		String dialogId = dialog.getDialogId();
		VirtualSubscription virtualSubscription = (VirtualSubscription) virtualSubscriptions
				.get(dialogId);
		if (virtualSubscription == null)
			return Response.CALL_OR_TRANSACTION_DOES_NOT_EXIST;

		SubscriptionStateHeader subscriptionStateHeader = (SubscriptionStateHeader) request
				.getHeader(SubscriptionStateHeader.NAME);
		String subscriptionState = subscriptionStateHeader.getState();

		// check if event is understood, else send 489 (Bad Event)
		EventHeader eventHeader = (EventHeader) request
				.getHeader(EventHeader.NAME);
		if ((eventHeader == null)
				|| !(eventHeader.getEventType().equalsIgnoreCase("presence")))
			return Response.BAD_EVENT;

		// update subscriptionState
		String oldState = virtualSubscription.getSubscriptionState();
		virtualSubscription.setSubscriptionState(subscriptionState);

		// if Subscription-State has expires-parameter, update expirestime
		if (subscriptionStateHeader.getParameter("expires") != null) {
			int expires = subscriptionStateHeader.getExpires();
			virtualSubscription.setExpiresTime(expires);
		}

		// if body exist, update body
		Object content = request.getContent();
		String text = null;
		if (content instanceof String) {
			text = (String) content;
		} else if (content instanceof byte[]) {
			text = new String((byte[]) content);
		}

		responseCode = virtualSubscription.processNotify(text);

		// if subscription-state was "terminated", check for retry-parameter and
		// behave accordingly

		if (responseCode == Response.OK) {
			// update vs's subscribers body (a single virtual subscription state
			// cannot effect a whole subscriber)
			Collection subSubscribers = virtualSubscription.getSubscribers();
			Iterator it = subSubscribers.iterator();
			while (it.hasNext()) {
				Subscriber s = (Subscriber) it.next();
				s.updateNotifyBody(text);
			}

		}

		return responseCode;

	}

	// *****************************
	// Other Methods
	// *****************************

	/**
	 * @param notifierURI
	 *            cleaned SipURI as found in a SUBSCRIBE To-header
	 */
	public boolean hasNotifier(String notifierURI) {
		return notifiers.containsKey(notifierURI);
	}

	/**
	 * @param notifierURI
	 *            cleaned SipURI as found in a SUBSCRIBE To-header
	 * @param subscriberURI
	 *            cleaned SipURI as found in a SUBSCRIBE To-header
	 */
	protected synchronized boolean hasSubscriber(String notifierURI,
			String subscriberURI) {
		Notifier notifier = (Notifier) notifiers.get(notifierURI);
		return notifier.hasSubscriber(subscriberURI);
	}

	// *****************************
	// UTILITY METHODS
	// *****************************

	/**
	 * Subscribers come in many flavours. This method determines which
	 * Subscriber subclass should be created and creates it.
	 * 
	 * @return A type-casted Subscriber object or null if the headers in the
	 *         subscription were ambigous or insufficient.
	 */
	private Subscriber createSubscriber(Request request, String subscriberKey,
			Dialog dialog, int expires) {

		// Examine event header, this determines the type of subscriber
		EventHeader eventHeader = (EventHeader) request
				.getHeader(EventHeader.NAME);
		String event;
		if (eventHeader == null) {
			return null;
		} else {
			event = eventHeader.getEventType();
		}

		if (event.equalsIgnoreCase("presence")) {

			boolean partialNotification = false;
			ListIterator acceptHeadersIterator = (ListIterator) request
					.getHeaders(AcceptHeader.NAME);

			while (acceptHeadersIterator.hasNext()) {
				String subtype = ((AcceptHeader) acceptHeadersIterator.next())
						.getContentSubType();

				if (subtype.equalsIgnoreCase("pidf-partial+xml")) {
					partialNotification = true;
					break;
				}
			}

			return new SubscriberPresence(subscriberKey, dialog, expires,
					partialNotification);

		} else if (event.equalsIgnoreCase("watcher.presence")) {
			// get notifier
			// get winfo file
			// SubscriberWinfo subscriberWinfo = new
			// SubscriberWinfo(subscriberKey, dialog, expires, winfoFile);
			return new Subscriber(subscriberKey, dialog, expires);
		}

		return null;

	}

	private boolean isResourceListSubscriber(Request request) {
		EventHeader eventHeader = (EventHeader) request
				.getHeader(EventHeader.NAME);
		String event;
		if ((eventHeader == null)
				|| !(eventHeader.getEventType().equalsIgnoreCase("presence"))) {
			return false;
		} else {
			ListIterator supportedHeadersIterator = (ListIterator) request
					.getHeaders(SupportedHeader.NAME);
			while (supportedHeadersIterator.hasNext()) {
				String header = ((SupportedHeader) supportedHeadersIterator
						.next()).toString();
				if (header.indexOf("resourceList") > 0) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * Returns the value of a named header
	 */
	protected String getKey(Message message, String header) {
		try {
			Address address = null;
			if (header.equals("From")) {
				FromHeader fromHeader = (FromHeader) message
						.getHeader(FromHeader.NAME);
				address = fromHeader.getAddress();

			} else if (header.equals("To")) {
				ToHeader toHeader = (ToHeader) message.getHeader(ToHeader.NAME);
				address = toHeader.getAddress();

			}

			javax.sip.address.URI cleanedUri = null;
			if (address == null) {
				cleanedUri = getCleanUri(((Request) message).getRequestURI());
			} else {
				// We have to build the key, all
				// URI parameters MUST be removed:
				cleanedUri = getCleanUri(address.getURI());
			}

			if (cleanedUri == null)
				return null;

			String keyresult = cleanedUri.toString();
			logger.debug("DEBUG, PresenceServer, getKey(), the key is: "
					+ keyresult);
			return keyresult.toLowerCase();

		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * Helper for getKey. Removes parameters from URI
	 */
	protected static URI getCleanUri(URI uri) {
		if (uri instanceof SipURI) {
			SipURI sipURI = (SipURI) uri.clone();

			Iterator iterator = sipURI.getParameterNames();
			while (iterator != null && iterator.hasNext()) {
				String name = (String) iterator.next();
				sipURI.removeParameter(name);
			}
			return sipURI;
		} else
			return uri;
	}

	public void run() {
		while (this.isRunning) {
			try {
				Thread.sleep(1000); // millisecs
			} catch (InterruptedException ex) {

			}
			if (!this.isRunning)
				return;

			int expires = 0;
			synchronized (subscribers) {

				Iterator sit = subscribers.values().iterator();
				while (sit.hasNext()) {
					Subscriber s = (Subscriber) sit.next();

					if (s.hasExpired()) {
						s.setSubscriptionState("terminated");
						// add reason=timeout parameter
						presenceServer.sendNotifyRequest(s);
						continue;
					}

					if (s.isTerminated()) {
						sit.remove();
						continue;
					}

					if (s.sendNotify()) {
						presenceServer.sendNotifyRequest(s);
						logger.debug("Thread::Sending notify");
					}

					// collect max expiresTime for possible server
					// resubscription
					int thisExpires = s.getExpiresTime();
					if (thisExpires > expires) {
						expires = thisExpires;
					}
				}
			}// end subscribers

			synchronized (notifiers) {
				Iterator nit = notifiers.values().iterator();
				while (nit.hasNext()) {
					Notifier n = (Notifier) nit.next();
					if (n.hasExpired()) {
						System.out.println("removing NOTIIFER");
						nit.remove();
					}
				}
			} // end notifiers

			synchronized (virtualSubscriptions) {
				Iterator vit = virtualSubscriptions.values().iterator();
				while (vit.hasNext()) {
					VirtualSubscription vs = (VirtualSubscription) vit.next();
					if (vs.hasNoSubscribers()) {
						vit.remove();
					}
					if (vs.needToResubscribe()) {
						presenceServer.sendSubscribeRequest(vs.getURI(), vs
								.getRequiredExpiresTime(), vs.getDialog());
					}
				}
			} // end virtualSubscriptions

		}
	}

}