/**
* Removes the specified account from the list of accounts that this provider factory is handling.
* If the specified accountID is unknown to the ProtocolProviderFactory, the call has no effect
* and false is returned. This method is persistent in nature and once called the account
* corresponding to the specified ID will not be loaded during future runs of the project.
*
* @param accountID the ID of the account to remove.
* @return true if an account with the specified ID existed and was removed and false otherwise.
*/
public boolean uninstallAccount(AccountID accountID) {
// unregister the protocol provider
ServiceReference serRef = getProviderForAccount(accountID);
if (serRef == null) return false;
ProtocolProviderService protocolProvider =
(ProtocolProviderService) SipActivator.getBundleContext().getService(serRef);
try {
protocolProvider.unregister();
} catch (OperationFailedException e) {
logger.error(
"Failed to unregister protocol provider for account : "
+ accountID
+ " caused by : "
+ e);
}
ServiceRegistration registration = (ServiceRegistration) registeredAccounts.remove(accountID);
if (registration == null) return false;
// kill the service
registration.unregister();
return removeStoredAccount(SipActivator.getBundleContext(), accountID);
}
/**
* Fetches the preferred TLS (TCP) port for secure communications in the user preferences or
* search is default value set in settings or fallback on a default value.
*
* @return the preferred network port for secure communications.
*/
private int getPreferredSecurePort() {
int preferredPort =
SipActivator.getConfigurationService().getInt(PREFERRED_SECURE_PORT_PROPERTY_NAME, -1);
if (preferredPort <= 1) {
// check for default value
preferredPort =
SipActivator.getResources().getSettingsInt(PREFERRED_SECURE_PORT_PROPERTY_NAME);
}
if (preferredPort <= 1) return ListeningPoint.PORT_5061;
else return preferredPort;
}
/**
* Shows an error and a short description.
*
* @param ex the exception
*/
static void showError(Throwable ex, String title, String message) {
try {
if (title == null) title = "Error in SIP contactlist storage";
if (message == null)
message = title + "\n" + ex.getClass().getName() + ": " + ex.getLocalizedMessage();
if (SipActivator.getUIService() != null)
SipActivator.getUIService()
.getPopupDialog()
.showMessagePopupDialog(message, title, PopupDialog.ERROR_MESSAGE);
} catch (Throwable t) {
logger.error("Error for error dialog", t);
}
}
/**
* Initializes and creates an account corresponding to the specified accountProperties and
* registers the resulting ProtocolProvider in the <tt>context</tt> BundleContext parameter.
*
* @param accountProperties a set of protocol (or implementation) specific properties defining the
* new account.
* @return the AccountID of the newly created account
*/
protected AccountID loadAccount(Map accountProperties) {
BundleContext context = SipActivator.getBundleContext();
if (context == null) throw new NullPointerException("The specified BundleContext was null");
String userIDStr = (String) accountProperties.get(USER_ID);
if (userIDStr == null)
throw new NullPointerException("The account properties contained no user id.");
if (accountProperties == null)
throw new NullPointerException("The specified property map was null");
String serverAddress = (String) accountProperties.get(SERVER_ADDRESS);
if (serverAddress == null)
throw new NullPointerException(serverAddress + " is not a valid ServerAddress");
if (!accountProperties.containsKey(PROTOCOL))
accountProperties.put(PROTOCOL, ProtocolNames.SIP);
SipAccountID accountID = new SipAccountID(userIDStr, accountProperties, serverAddress);
// get a reference to the configuration service and register whatever
// properties we have in it.
Hashtable properties = new Hashtable();
properties.put(PROTOCOL, ProtocolNames.SIP);
properties.put(USER_ID, userIDStr);
ProtocolProviderServiceSipImpl sipProtocolProvider = new ProtocolProviderServiceSipImpl();
try {
sipProtocolProvider.initialize(userIDStr, accountID);
// We store again the account in order to store all properties added
// during the protocol provider initialization.
this.storeAccount(SipActivator.getBundleContext(), accountID);
} catch (OperationFailedException ex) {
logger.error("Failed to initialize account", ex);
throw new IllegalArgumentException("Failed to initialize account" + ex.getMessage());
}
ServiceRegistration registration =
context.registerService(
ProtocolProviderService.class.getName(), sipProtocolProvider, properties);
registeredAccounts.put(accountID, registration);
return accountID;
}
/** Handles new incoming object. */
private void handle(JSONObject incomingObject) {
if (!incomingObject.containsKey("class")) return;
try {
String classField = (String) incomingObject.get("class");
if (classField.equals("loginko")) {
showError(null, null, "Unauthorized. Cannot login: "******"errorstring"));
logger.error("Error login: "******"errorstring"));
destroy();
return;
} else if (classField.equals("login_id_ok")) {
SipAccountIDImpl accountID = (SipAccountIDImpl) sipProvider.getAccountID();
boolean useSipCredentials = accountID.isClistOptionUseSipCredentials();
String password;
if (useSipCredentials) {
password = SipActivator.getProtocolProviderFactory().loadPassword(accountID);
} else {
password = accountID.getClistOptionPassword();
}
if (!authorize((String) incomingObject.get("sessionid"), password))
logger.error("Error login authorization!");
return;
} else if (classField.equals("login_pass_ok")) {
if (!sendCapas((JSONArray) incomingObject.get("capalist")))
logger.error("Error send capas!");
return;
} else if (classField.equals("login_capas_ok")) {
if (!sendFeatures(
(String) incomingObject.get("astid"), (String) incomingObject.get("xivo_userid")))
logger.error("Problem send features get!");
return;
} else if (classField.equals("features")) {
if (!getPhoneList()) logger.error("Problem send get phones!");
return;
} else if (classField.equals("phones")) {
phonesRecieved(incomingObject);
return;
} else if (classField.equals("disconn")) {
destroy();
return;
} else {
if (logger.isTraceEnabled()) logger.trace("unhandled classField: " + incomingObject);
return;
}
} catch (Throwable t) {
logger.error("Error handling incoming object", t);
}
}
/**
* Initializes and creates an account corresponding to the specified accountProperties and
* registers the resulting ProtocolProvider in the <tt>context</tt> BundleContext parameter.
*
* @param userIDStr the user identifier uniquely representing the newly created account within the
* protocol namespace.
* @param accountProperties a set of protocol (or implementation) specific properties defining the
* new account.
* @return the AccountID of the newly created account.
* @throws IllegalArgumentException if userID does not correspond to an identifier in the context
* of the underlying protocol or if accountProperties does not contain a complete set of
* account installation properties.
* @throws IllegalStateException if the account has already been installed.
* @throws NullPointerException if any of the arguments is null.
*/
public AccountID installAccount(String userIDStr, Map accountProperties) {
BundleContext context = SipActivator.getBundleContext();
if (context == null) throw new NullPointerException("The specified BundleContext was null");
if (userIDStr == null) throw new NullPointerException("The specified AccountID was null");
accountProperties.put(USER_ID, userIDStr);
if (accountProperties == null)
throw new NullPointerException("The specified property map was null");
String serverAddress = (String) accountProperties.get(SERVER_ADDRESS);
if (serverAddress == null) throw new NullPointerException("null is not a valid ServerAddress");
if (!accountProperties.containsKey(PROTOCOL))
accountProperties.put(PROTOCOL, ProtocolNames.SIP);
AccountID accountID = new SipAccountID(userIDStr, accountProperties, serverAddress);
// make sure we haven't seen this account id before.
if (registeredAccounts.containsKey(accountID))
throw new IllegalStateException("An account for id " + userIDStr + " was already installed!");
// first store the account and only then load it as the load generates
// an osgi event, the osgi event triggers (trhgough the UI) a call to
// the register() method and it needs to acces the configuration service
// and check for a password.
this.storeAccount(SipActivator.getBundleContext(), accountID);
try {
accountID = loadAccount(accountProperties);
} catch (RuntimeException exc) {
// it might happen that load-ing the account fails because of a bad
// initialization. if this is the case, make sure we remove it.
this.removeStoredAccount(SipActivator.getBundleContext(), accountID);
throw exc;
}
return accountID;
}
/** Prepares the factory for bundle shutdown. */
public void stop() {
logger.trace("Preparing to stop all SIP protocol providers.");
Enumeration registrations = this.registeredAccounts.elements();
while (registrations.hasMoreElements()) {
ServiceRegistration reg = ((ServiceRegistration) registrations.nextElement());
ProtocolProviderServiceSipImpl provider =
(ProtocolProviderServiceSipImpl)
SipActivator.getBundleContext().getService(reg.getReference());
// do an attempt to kill the provider
provider.shutdown();
reg.unregister();
}
registeredAccounts.clear();
}
/**
* Constructor for this class. Creates the JAIN-SIP stack.
*
* @throws OperationFailedException if creating the stack fails.
*/
SipStackSharing() throws OperationFailedException {
// init of the stack
try {
SipFactory sipFactory = SipFactory.getInstance();
sipFactory.setPathName("org.jitsi.gov.nist");
Properties sipStackProperties = new SipStackProperties();
// Create SipStack object
this.stack = sipFactory.createSipStack(sipStackProperties);
if (logger.isTraceEnabled()) logger.trace("Created stack: " + this.stack);
// set our custom address resolver managing SRV records
AddressResolverImpl addressResolver = new AddressResolverImpl();
((SIPTransactionStack) this.stack).setAddressResolver(addressResolver);
SipActivator.getNetworkAddressManagerService().addNetworkConfigurationChangeListener(this);
} catch (Exception ex) {
logger.fatal("Failed to get SIP Factory.", ex);
throw new OperationFailedException(
"Failed to get SIP Factory", OperationFailedException.INTERNAL_ERROR, ex);
}
}
/**
* Returns the password last saved for the specified account.
*
* @param accountID the AccountID for the account whose password we're looking for..
* @return a String containing the password for the specified accountID.
* @throws java.lang.IllegalArgumentException if no account corresponding to <tt>accountID</tt>
* has been previously stored.
*/
public String loadPassword(AccountID accountID) throws IllegalArgumentException {
return super.loadPassword(SipActivator.getBundleContext(), accountID);
}
/**
* Saves the password for the specified account after scrambling it a bit so that it is not
* visible from first sight (Method remains highly insecure).
*
* @param accountID the AccountID for the account whose password we're storing.
* @param passwd the password itself.
* @throws java.lang.IllegalArgumentException if no account corresponding to <tt>accountID</tt>
* has been previously stored.
*/
public void storePassword(AccountID accountID, String passwd) throws IllegalArgumentException {
super.storePassword(SipActivator.getBundleContext(), accountID, passwd);
}
/** Loads (and hence installs) all accounts previously stored in the configuration service. */
public void loadStoredAccounts() {
super.loadStoredAccounts(SipActivator.getBundleContext());
}
/**
* Fetches the number of times to retry when the binding of a JAIN-SIP <tt>ListeningPoint</tt>
* fails. Looks in the user preferences or fallbacks on a default value.
*
* @return the number of times to retry a failed bind.
*/
private int getBindRetriesValue() {
return SipActivator.getConfigurationService()
.getInt(
ProtocolProviderService.BIND_RETRIES_PROPERTY_NAME,
ProtocolProviderService.BIND_RETRIES_DEFAULT_VALUE);
}
/**
* Logs the specified message and details to the packet logging service if enabled.
*
* @param message the message to log
* @param sender determines whether we are the origin of this message.
*/
private void logPacket(SIPMessage message, boolean sender) {
try {
PacketLoggingService packetLogging = SipActivator.getPacketLogging();
if (packetLogging == null
|| !packetLogging.isLoggingEnabled(PacketLoggingService.ProtocolName.SIP)
/* Via not present in CRLF packet on TCP - causes NPE */
|| message.getTopmostVia() == null) return;
String transport = message.getTopmostVia().getTransport();
boolean isTransportUDP = transport.equalsIgnoreCase("UDP");
byte[] srcAddr;
int srcPort;
byte[] dstAddr;
int dstPort;
// if addresses are not set use empty byte array with length
// equals to the other address or just empty
// byte array with length 4 (ipv4 0.0.0.0)
if (sender) {
if (!isTransportUDP) {
InetSocketAddress localAddress =
getLocalAddressForDestination(
message.getRemoteAddress(),
message.getRemotePort(),
message.getLocalAddress(),
transport);
srcPort = localAddress.getPort();
srcAddr = localAddress.getAddress().getAddress();
} else {
srcPort = message.getLocalPort();
if (message.getLocalAddress() != null) srcAddr = message.getLocalAddress().getAddress();
else if (message.getRemoteAddress() != null)
srcAddr = new byte[message.getRemoteAddress().getAddress().length];
else srcAddr = new byte[4];
}
dstPort = message.getRemotePort();
if (message.getRemoteAddress() != null) dstAddr = message.getRemoteAddress().getAddress();
else dstAddr = new byte[srcAddr.length];
} else {
if (!isTransportUDP) {
InetSocketAddress dstAddress =
getLocalAddressForDestination(
message.getRemoteAddress(),
message.getRemotePort(),
message.getLocalAddress(),
transport);
dstPort = dstAddress.getPort();
dstAddr = dstAddress.getAddress().getAddress();
} else {
dstPort = message.getLocalPort();
if (message.getLocalAddress() != null) dstAddr = message.getLocalAddress().getAddress();
else if (message.getRemoteAddress() != null)
dstAddr = new byte[message.getRemoteAddress().getAddress().length];
else dstAddr = new byte[4];
}
srcPort = message.getRemotePort();
if (message.getRemoteAddress() != null) srcAddr = message.getRemoteAddress().getAddress();
else srcAddr = new byte[dstAddr.length];
}
byte[] msg = null;
if (message instanceof SIPRequest) {
SIPRequest req = (SIPRequest) message;
if (req.getMethod().equals(SIPRequest.MESSAGE)
&& message.getContentTypeHeader() != null
&& message.getContentTypeHeader().getContentType().equalsIgnoreCase("text")) {
int len = req.getContentLength().getContentLength();
if (len > 0) {
SIPRequest newReq = (SIPRequest) req.clone();
byte[] newContent = new byte[len];
Arrays.fill(newContent, (byte) '.');
newReq.setMessageContent(newContent);
msg = newReq.toString().getBytes("UTF-8");
}
}
}
if (msg == null) {
msg = message.toString().getBytes("UTF-8");
}
packetLogging.logPacket(
PacketLoggingService.ProtocolName.SIP,
srcAddr,
srcPort,
dstAddr,
dstPort,
isTransportUDP
? PacketLoggingService.TransportName.UDP
: PacketLoggingService.TransportName.TCP,
sender,
msg);
} catch (Throwable e) {
logger.error("Cannot obtain message body", e);
}
}
