code
stringlengths 73
34.1k
| label
stringclasses 1
value |
|---|---|
public int read() throws IOException
{
if ( total >= limit )
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", "Over the limit: -1");
}
return -1;
}
if ( pos >= count )
{
fill();
if ( pos >= count )
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", pos+" >= "+count+" : -1");
}
return -1;
}
}
total++;
return buf[pos++] & 0xff;
}
|
java
|
public int read(byte []read_buffer, int offset, int length) throws IOException {
// Copy as much as possible from the read buffer
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", "read length -->"+length);
}
if ( total >= limit )
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", "Over the limit: -1");
}
return -1;
}
int buf_len = count - pos;
if (buf_len > 0) {
if (buf_len >= length) {
// Copy part of read buffer
System.arraycopy(buf,pos,read_buffer,offset,length);
pos += length;
// begin 280584.2 java.io.IOException: SRVE0080E: Invalid content length WAS.webcontainer
this.total += length;
// end 280584.2 java.io.IOException: SRVE0080E: Invalid content length WAS.webcontainer
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", "read returning -->"+length);
}
return length;
}
// Copy all read buffer
System.arraycopy(buf,pos,read_buffer,offset,buf_len);
count = pos = 0; // reset buffer
offset += buf_len;
length -= buf_len;
}
// Try to read remainder directly from the input stream into
// the caller's buffer, avoiding an extra copy
int bytes_read = buf_len;
int rtn = 0;
if(length>0)
{
rtn = in.read(read_buffer,offset,length);
}
if (rtn > 0) {
bytes_read += rtn;
}
// begin 280584.2 java.io.IOException: SRVE0080E: Invalid content length WAS.webcontainer
this.total += bytes_read;
// end 280584.2 java.io.IOException: SRVE0080E: Invalid content length WAS.webcontainer
if (bytes_read == 0) {
bytes_read = -1;
}
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"read", "read returning -->"+bytes_read+", total="+total+",limit="+limit);
}
return bytes_read;
}
|
java
|
public int readLine(byte[] b, int off, int len) throws IOException
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"readLine", "readLine");
}
if ( total >= limit )
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"readLine", "readLine Over the limit: -1");
}
return -1;
}
int avail; //bytes available in buffer
int readlen; //amount to be read by copyline
int remain = 0; //amount remaining to be read
int newlen; //amount read by copyline
int totalread; //total amount read so far
remain = len;
avail = count - pos;
if ( avail <= 0 )
{
fill();
avail = count - pos;
if ( avail <= 0 )
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"readLine", "readLine avail less than 0: -1");
}
return -1;
}
}
if ( avail < len )
{
readlen = avail;
}
else
{
readlen = len;
}
newlen = copyLine(buf, pos, b, off, readlen);
pos += newlen;
total += newlen;
remain -= newlen;
totalread = newlen;
if ( totalread == 0 )
{
//should never happen
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"readLine", "readLine totalRead is 0: -1");
}
return -1;
}
while ( remain > 0 && b[off+totalread-1] != '\n' )
{
//loop through until the conditions of the method are satisfied
fill();
avail = count - pos;
if ( avail <= 0 )
{
// The stream is finished, return what we have.
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"readLine", "readLine returning --> "+totalread);
}
return totalread;
}
if ( avail < remain )
{
readlen = avail;
}
else
{
readlen = remain;
}
newlen = copyLine(buf, pos, b, off+totalread, readlen);
pos += newlen;
total += newlen;
remain -= newlen;
totalread += newlen;
}
return totalread;
}
|
java
|
protected void fill() throws IOException
{
if (TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) { //306998.15
logger.logp(Level.FINE, CLASS_NAME,"fill", "fill");
}
// PK79219 Start
long longLeft = limit-total;
int len;
if (longLeft>Integer.MAX_VALUE)
len = buf.length;
else
len = Math.min(buf.length, (int)longLeft);
// PK79219 End
if ( len > 0 )
{
len = in.read(buf, 0, len);
if ( len > 0 )
{
pos = 0;
count = len;
}
}
}
|
java
|
private String[] parseData(String hashedPassword) throws IllegalArgumentException {
// <algorithm>:<iterations>:<base64(salt)>:<base64(hash)>
String[] items = hashedPassword.split(":");
String error = null;
if (items.length == 4) {
if (SUPPORTED_ALGORITHMS.contains(items[0])) {
try {
Integer.parseInt(items[1]);
return items; // good.
} catch (Exception e) {
error = Tr.formatMessage(tc, "JAVAEESEC_CDI_INVALID_ITERATION", items[1]);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Invalid format: the iterations is not a number : " + items[1]);
}
}
} else {
error = Tr.formatMessage(tc, "JAVAEESEC_CDI_INVALID_ALGORITHM", items[0]);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Invalid format: the hash algorithm is not supported : " + items[0]);
}
}
} else {
error = Tr.formatMessage(tc, "JAVAEESEC_CDI_INVALID_ELEMENTS", items.length);
if (tc.isDebugEnabled()) {
Tr.debug(tc, "Invalid format: the number of the elements is not 4 but " + items.length);
}
}
String message = Tr.formatMessage(tc, "JAVAEESEC_CDI_ERROR_PASSWORDHASH_INVALID_DATA", error);
Tr.error(tc, message);
throw new IllegalArgumentException(message);
}
|
java
|
protected void parseParams(Map<String, String> params) {
generateAlgorithm = indexOf(PARAM_ALGORITHM, DEFAULT_ALGORITHM, SUPPORTED_ALGORITHMS, params.get(PARAM_ALGORITHM));
generateIterations = parseInt(PARAM_ITERATIONS, params.get(PARAM_ITERATIONS), DEFAULT_ITERATIONS, MINIMUM_ITERATIONS);
generateSaltSize = parseInt(PARAM_SALTSIZE, params.get(PARAM_SALTSIZE), DEFAULT_SALTSIZE, MINIMUM_SALTSIZE);
generateKeySize = parseInt(PARAM_KEYSIZE, params.get(PARAM_KEYSIZE), DEFAULT_KEYSIZE, MINIMUM_KEYSIZE);
}
|
java
|
public static boolean isValidType(Class clazz)
{
if (null == clazz) throw new IllegalArgumentException();
if (String.class == clazz) return true;
if (Boolean.class == clazz) return true;
if (JSONObject.class.isAssignableFrom(clazz)) return true;
if (JSONArray.class == clazz) return true;
if (Number.class.isAssignableFrom(clazz)) return true;
return false;
}
|
java
|
public final void initialize() throws PersistenceException, SevereMessageStoreException
{
PersistentMessageStore pm = _messageStore.getPersistentMessageStore();
final HashMap tupleMap = _buildTupleMap(pm);
_buildStreamTree(tupleMap);
_recoverStreamsWithInDoubts(pm);
}
|
java
|
public void commit() throws XAException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "commit", _txn);
// replay must have finished
if (_tranManager.isReplayComplete())
{
final int state = _txn.getTransactionState().getState();
switch (state)
{
case TransactionState.STATE_PREPARED :
try
{
// Suspend local transaction if present
suspend(); // @LIDB2110AA
try
{
// Resume imported transaction
_tranManager.resume(_txn);
}
catch (InvalidTransactionException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "prepare", new Object[] { "resume threw InvalidTransactionException", e });
resume();
throw new XAException(XAException.XAER_RMERR);
}
catch (IllegalStateException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "prepare", new Object[] { "resume threw IllegalStateException", e });
resume();
throw new XAException(XAException.XAER_PROTO);
} // @LIDB2110AA
_txn.getTransactionState().setState(TransactionState.STATE_COMMITTING);
_txn.internalCommit();
_txn.notifyCompletion();
}
catch (HeuristicMixedException e)
{
_heuristic = StatefulResource.HEURISTIC_MIXED;
}
catch (HeuristicHazardException e)
{
_heuristic = StatefulResource.HEURISTIC_HAZARD;
}
catch (HeuristicRollbackException e)
{
_heuristic = StatefulResource.HEURISTIC_ROLLBACK;
}
catch (SystemException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "commit", "internalCommit threw SystemException");
throw new XAException(XAException.XAER_RMERR);
}
finally // @LIDB2110AA
{
// Resume local transaction if we suspended it earlier
resume();
} // @LIDB2110AA
break;
case TransactionState.STATE_HEURISTIC_ON_ROLLBACK :
case TransactionState.STATE_HEURISTIC_ON_COMMIT :
// We had a heuristic on commit or rollback.
// Let's use whatever that was
_heuristic = _txn.getResources().getHeuristicOutcome();
if (tc.isDebugEnabled()) Tr.debug(tc, "Heuristic was: " + ResourceWrapper.printResourceStatus(_heuristic));
break;
case TransactionState.STATE_COMMITTED :
case TransactionState.STATE_COMMITTING :
// could be a retry, so just accept
break;
case TransactionState.STATE_ROLLING_BACK :
case TransactionState.STATE_ROLLED_BACK :
_heuristic = StatefulResource.HEURISTIC_ROLLBACK;
break;
case TransactionState.STATE_NONE :
// transaction has completed and has now finished
break;
default :
if (tc.isEntryEnabled()) Tr.exit(tc, "commit", "transaction is not in a prepared state");
throw new XAException(XAException.XAER_PROTO);
}
recordHeuristicOnCommit();
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "commit", "throwing XAER_RMFAIL");
throw new XAException(XAException.XAER_RMFAIL);
}
if (tc.isEntryEnabled()) Tr.exit(tc, "commit");
}
|
java
|
public void commitOnePhase() throws XAException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "commitOnePhase", _txn);
final int state = _txn.getTransactionState().getState();
switch (state)
{
case TransactionState.STATE_ACTIVE :
// Suspend local transaction if present
suspend();
try
{
// Resume imported transaction
_tranManager.resume(_txn);
_txn.prolongFinish();
_txn.commit_one_phase();
_txn.notifyCompletion();
}
catch (RollbackException e)
{
_txn.notifyCompletion();
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase", "commit threw RollbackException");
throw new XAException(XAException.XA_RBROLLBACK);
}
catch (HeuristicMixedException e)
{
_heuristic = StatefulResource.HEURISTIC_MIXED;
}
catch (HeuristicHazardException e)
{
_heuristic = StatefulResource.HEURISTIC_HAZARD;
}
catch (HeuristicRollbackException e)
{
_heuristic = StatefulResource.HEURISTIC_ROLLBACK;
}
catch (IllegalStateException e)
{
_txn.notifyCompletion();
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase", "commit threw IllegalStateException");
throw new XAException(XAException.XAER_PROTO);
}
catch (InvalidTransactionException e) // tm.resume
{
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase", "commit threw InvalidTransactionException");
throw new XAException(XAException.XAER_RMERR);
}
catch (SystemException e)
{
_txn.notifyCompletion();
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase", "commit threw SystemException");
throw new XAException(XAException.XAER_RMERR);
}
finally
{
// Resume local transaction if we suspended it earlier
resume();
}
break;
case TransactionState.STATE_COMMITTING :
case TransactionState.STATE_COMMITTED :
// probably a retry, just accept
break;
case TransactionState.STATE_ROLLING_BACK :
case TransactionState.STATE_ROLLED_BACK :
case TransactionState.STATE_HEURISTIC_ON_ROLLBACK :
_heuristic = StatefulResource.HEURISTIC_ROLLBACK;
break;
case TransactionState.STATE_HEURISTIC_ON_COMMIT :
_heuristic = StatefulResource.HEURISTIC_COMMIT;
break;
case TransactionState.STATE_NONE :
// transaction has completed and is now finished
break;
default :
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase", "transaction is in an incorrect state");
throw new XAException(XAException.XAER_PROTO);
}
recordHeuristicOnCommitOnePhase();
if (tc.isEntryEnabled()) Tr.exit(tc, "commitOnePhase");
}
|
java
|
public synchronized void rollback() throws XAException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "rollback", _txn);
// If we've been prepared then replay must
// have finished before we can rollback
if (_prepared && !_tranManager.isReplayComplete())
{
if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", "throwing XAER_RMFAIL(1)");
throw new XAException(XAException.XAER_RMFAIL);
}
final int state = _txn.getTransactionState().getState();
switch (state)
{
case TransactionState.STATE_ACTIVE :
case TransactionState.STATE_PREPARED :
try
{
// Suspend local transaction if present
suspend(); // @LIDB2110AA
try
{
// Resume imported transaction
_tranManager.resume(_txn);
}
catch (InvalidTransactionException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "prepare", new Object[] { "resume threw InvalidTransactionException", e });
resume();
throw new XAException(XAException.XAER_RMERR);
}
catch (IllegalStateException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "prepare", new Object[] { "resume threw IllegalStateException", e });
resume();
throw new XAException(XAException.XAER_PROTO);
} // @LIDB2110AA
_txn.getTransactionState().setState(TransactionState.STATE_ROLLING_BACK);
_txn.cancelAlarms();
_txn.internalRollback();
_txn.notifyCompletion();
}
catch (IllegalStateException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", "throwing XAER_PROTO(1)");
throw new XAException(XAException.XAER_PROTO);
}
catch (SystemException e)
{
if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", "throwing XAER_RMERR");
throw new XAException(XAException.XAER_RMERR);
}
catch (HeuristicMixedException e)
{
_heuristic = StatefulResource.HEURISTIC_MIXED;
}
catch (HeuristicHazardException e)
{
_heuristic = StatefulResource.HEURISTIC_HAZARD;
}
catch (HeuristicCommitException e)
{
_heuristic = StatefulResource.HEURISTIC_COMMIT;
}
finally // @LIDB2110AA
{
// Resume local transaction if we suspended it earlier
resume();
} // @LIDB2110AA
break;
case TransactionState.STATE_HEURISTIC_ON_COMMIT :
case TransactionState.STATE_HEURISTIC_ON_ROLLBACK :
_heuristic = _txn.getResources().getHeuristicOutcome();
break;
case TransactionState.STATE_ROLLING_BACK :
case TransactionState.STATE_ROLLED_BACK :
// probably a retry, just accept
break;
case TransactionState.STATE_NONE :
// transaction has completed and is now finished
break;
default :
_txn.notifyCompletion();
if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", "throwing XAER_PROTO(2)");
throw new XAException(XAException.XAER_PROTO);
}
recordHeuristicOnRollback();
if (tc.isEntryEnabled()) Tr.exit(tc, "rollback");
}
|
java
|
public synchronized void forget() throws XAException
{
if (tc.isEntryEnabled()) Tr.entry(tc, "forget", _txn);
// replay must have finished
if (_tranManager.isReplayComplete())
{
_heuristic = StatefulResource.NONE;
_txn.notifyCompletion();
}
else
{
if (tc.isEntryEnabled()) Tr.exit(tc, "forget", "throwing XAER_RMFAIL");
throw new XAException(XAException.XAER_RMFAIL);
}
if (tc.isEntryEnabled()) Tr.exit(tc, "forget");
}
|
java
|
public void reset()
{
_dstack.reset();
_current1.reset();
_last1.reset();
_eof = false;
_s = 0;
_p = null;
}
|
java
|
private void findFirst(
DeleteStack stack)
{
boolean x = optimisticFindFirst(stack);
if (x == pessimisticNeeded)
pessimisticFindFirst(stack);
}
|
java
|
private boolean optimisticFindFirst(
DeleteStack stack)
{
Object q = null;
int v1 = _index.vno();
int x1 = _index.xno();
if ((v1&1) != 0)
return pessimisticNeeded;
synchronized(this)
{
}
try
{
q = getFirst(stack);
}
catch (NullPointerException npe)
{
//No FFDC Code Needed.
_nullPointerExceptions++;
return GBSTree.checkForPossibleIndexChange(v1, _index.vno(), npe, "optimisticFindFirst");
}
catch (OptimisticDepthException ode)
{
//No FFDC Code Needed.
_optimisticDepthExceptions++;
return GBSTree.checkForPossibleIndexChange(v1, _index.vno(), ode, "optimisticFindFirst");
}
if (v1 != _index.vno())
return pessimisticNeeded;
_current1.setLocation(q, v1, x1);
_optimisticFindFirsts++;
return optimisticWorked;
}
|
java
|
private void pessimisticFindFirst(
DeleteStack stack)
{
Object q = null;
int v1 = 0;
int x1 = 0;
synchronized(_index)
{
q = getFirst(stack);
v1 = _index.vno();
x1 = _index.xno();
_pessimisticFindFirsts++;
}
_current1.setLocation(q, v1, x1);
}
|
java
|
private Object getFirst(
DeleteStack stack)
{
Object q = null;
GBSNode n = leftMostChild(stack);
if (n != null)
{
q = n.leftMostKey();
_current1.setLocation(n, 0);
}
return q;
}
|
java
|
private GBSNode leftMostChild(
DeleteStack stack)
{
GBSNode p;
p = _index.root(); /* Root of tree */
GBSNode lastl = null; /* Will point to left-most child */
if (p != null) /* Root is not null, we have a tree */
{
/* Remember father of root */
stack.start(_index.dummyTopNode(), "GBSIterator.leftMostChild");
lastl = leftMostChild(stack, p);
}
return lastl;
}
|
java
|
private void findNextAfterEof(
DeleteStack stack)
{
if ( !_eof )
throw new RuntimeException("findNextAfterEof called when _eof false.");
if (_current1._vno != _index.vno())
{
boolean state = pessimisticNeeded;
state = optimisticSearchNext(stack);
if (state == pessimisticNeeded)
pessimisticSearchNext(stack);
}
}
|
java
|
private boolean optimisticSearchNext(
DeleteStack stack)
{
int v1 = _index.vno();
int x1 = _index.xno();
if ((v1&1) != 0)
return pessimisticNeeded;
synchronized(this)
{
}
try
{
internalSearchNext(stack, v1, x1);
}
catch (NullPointerException npe)
{
//No FFDC Code Needed.
_nullPointerExceptions++;
return GBSTree.checkForPossibleIndexChange(v1, _index.vno(), npe, "optimisticSearchNext");
}
catch (OptimisticDepthException ode)
{
//No FFDC Code Needed.
_optimisticDepthExceptions++;
return GBSTree.checkForPossibleIndexChange(v1, _index.vno(), ode, "optimisticSearchNext");
}
if (v1 != _index.vno())
{
_current1.setVersion(1);
return pessimisticNeeded;
}
_optimisticSearchNexts++;
return optimisticWorked;
}
|
java
|
private void pessimisticSearchNext(
DeleteStack stack)
{
synchronized(_index)
{
internalSearchNext(stack, _index.vno(), _index.xno());
_pessimisticSearchNexts++;
}
}
|
java
|
private void internalSearchNext(
DeleteStack stack,
int v1,
int x1)
{
SearchComparator comp = searchComparator(SearchComparator.GT);
_s = 0;
_p = null;
_eof = true;
_current1.setVersion(v1);
SearchNode sn = searchNode();
Object q = _index.iteratorFind(_dstack, comp, _last1.key(), sn);
if (q != null)
{
_current1.setLocation(sn.foundNode(), sn.foundIndex());
_current1.setLocation(sn.key(), v1, x1);
_s = NodeStack.VISIT_RIGHT;
_p = sn.foundNode();
_eof = false;
}
}
|
java
|
private void pessimisticGetNext(
DeleteStack stack)
{
synchronized(_index)
{
internalGetNext(stack, _index.vno(), _index.xno());
_pessimisticGetNexts++;
}
}
|
java
|
private GBSNode nextNode(
DeleteStack stack)
{
if (_eof)
throw new RuntimeException("_eof is set on entry to nextNode()");
boolean done = false;
GBSNode q = null;
GBSNode nextp = null;
while ( !done )
{
if (stack.index() > GBSTree.maxDepth)
throw new OptimisticDepthException(
"maxDepth (" + GBSTree.maxDepth +
") exceeded in GBSIterator.nextNode().");
switch (_s)
{
case NodeStack.VISIT_LEFT:
_s = NodeStack.PROCESS_CURRENT;
q = _p.leftChild();
while (q != null)
{
stack.push(_s, _p, "GBSIterator.nextNode:VISIT_LEFT");
_p = q;
q = _p.leftChild();
}
break;
case NodeStack.PROCESS_CURRENT:
_s = NodeStack.VISIT_RIGHT;
done = true;
nextp = _p; /* Next node to visit */
break;
case NodeStack.VISIT_RIGHT:
_s = NodeStack.DONE_VISITS;
q = _p.rightChild();
if (q != null)
{
stack.push(_s, _p, "GBSIterator.nextNode:VISIT_RIGHT");
_s = NodeStack.VISIT_LEFT;
_p = _p.rightChild();
}
break;
case NodeStack.DONE_VISITS:
if (stack.index() <= 0) /* Have finally hit end of sub-tree */
done = true;
else
{
_s = stack.state();
_p = stack.node();
stack.pop();
}
break;
default:
throw new RuntimeException("Help!, _s = " + _s + ", _p = " + _p + ".");
} /* switch(_s) */
} /* while ( !done ) */
return nextp;
}
|
java
|
public Object next()
{
_current1.reset();
if (_last1.key() == null)
findFirst(_dstack);
else
{
findNext(_dstack);
if (_current1.key() == null)
_eof = true;
}
if (_current1.key() != null)
_last1.setLocation(_current1);
return _current1.key();
}
|
java
|
public InetSocketAddress getLocalAddress()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getLocalAddress");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getLocalAddress","rc="+null);
return null;
}
|
java
|
public InetSocketAddress getRemoteAddress()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "getRemoteAddress");
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "getRemoteAddress","rc="+remoteAddress);
return remoteAddress;
}
|
java
|
public static Number convert(Number value, Class<?> type) {
if (int.class.equals(type) || Integer.class.equals(type))
value = value.intValue();
else if (long.class.equals(type) || Long.class.equals(type))
value = value.longValue();
else if (short.class.equals(type) || Short.class.equals(type))
value = value.shortValue();
else if (byte.class.equals(type) || Byte.class.equals(type))
value = value.byteValue();
else if (double.class.equals(type) || Double.class.equals(type))
value = value.doubleValue();
else if (float.class.equals(type) || Float.class.equals(type))
value = value.floatValue();
return value;
}
|
java
|
public static Object convert(String str, Class<?> type) throws Exception {
Object value;
if (int.class.equals(type) || Integer.class.equals(type))
value = Integer.parseInt(str);
else if (boolean.class.equals(type) || Boolean.class.equals(type))
value = Boolean.parseBoolean(str);
else if (long.class.equals(type) || Long.class.equals(type))
value = Long.parseLong(str);
else if (short.class.equals(type) || Short.class.equals(type))
value = Short.parseShort(str);
else if (byte.class.equals(type) || Byte.class.equals(type))
value = Byte.parseByte(str);
else if (double.class.equals(type) || Double.class.equals(type))
value = Double.parseDouble(str);
else if (float.class.equals(type) || Float.class.equals(type))
value = Float.parseFloat(str);
else if (char.class.equals(type) || Character.class.equals(type))
value = str.charAt(0);
else
value = type.getConstructor(String.class).newInstance(str);
return value;
}
|
java
|
public static byte[] serObjByte(Object pk) throws IOException {
final boolean trace = TraceComponent.isAnyTracingEnabled();
if (trace && tc.isEntryEnabled())
Tr.entry(tc, "serObjByte", pk == null ? null : pk.getClass());
byte[] b;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bos);
out.writeObject(pk);
out.flush();
out.close();
b = bos.toByteArray();
} catch (IOException e) {
FFDCFilter.processException(e, Utils.class.getName(), "336");
if (trace && tc.isEntryEnabled())
Tr.exit(tc, "serObjByte", new Object[] { "Unable to serialize: " + pk, e });
throw e;
} catch (Error e) {
FFDCFilter.processException(e, Utils.class.getName(), "342");
if (trace && tc.isEntryEnabled())
Tr.exit(tc, "serObjByte", new Object[] { "Unable to serialize: " + pk, e });
throw e;
}
if (trace && tc.isEntryEnabled())
Tr.exit(tc, "serObjByte");
return b;
}
|
java
|
public static void checkAccessibility(String resourceName, String adapterName, String embeddedApp, String accessingApp,
boolean isEndpoint) throws ResourceException {
if (embeddedApp != null) {
if (!embeddedApp.equals(accessingApp)) {
String msg = null;
if (isEndpoint) {
if (accessingApp != null) {
msg = TraceNLS.getFormattedMessage(Utils.class, tc.getResourceBundleName(), "J2CA8810.embedded.activation.failed",
new Object[] { resourceName, adapterName, embeddedApp, accessingApp },
"J2CA8810.embedded.activation.failed");
} else {
msg = TraceNLS.getFormattedMessage(Utils.class, tc.getResourceBundleName(), "J2CA8812.embedded.activation.failed",
new Object[] { resourceName, adapterName, embeddedApp },
"J2CA8812.embedded.activation.failed");
}
} else {
if (accessingApp != null) {
msg = TraceNLS.getFormattedMessage(Utils.class, tc.getResourceBundleName(), "J2CA8809.embedded.lookup.failed",
new Object[] { resourceName, adapterName, embeddedApp, accessingApp },
"J2CA8809.embedded.lookup.failed");
} else {
msg = TraceNLS.getFormattedMessage(Utils.class, tc.getResourceBundleName(), "J2CA8811.embedded.lookup.failed",
new Object[] { resourceName, adapterName, embeddedApp },
"J2CA8811.embedded.lookup.failed");
}
}
throw new ResourceException(msg);
}
}
}
|
java
|
private Map<String, Object> getUserinfoFromRegistryMap(Set<String> claims,
Map<String, Object> inputMap,
boolean isJson) throws Exception {
Map<String, Object> result = inputMap;
VMMService vmmService = JwtUtils.getVMMService();
if (vmmService != null) {
PropertyControl vmmServiceProps = new PropertyControl();
Properties claimsToVMMProperties = new Properties();
if (!claims.isEmpty()) {
// Properties claimsToVMMProps = jwtConfig.getClaimToUserRegistryMap(); //TODO
for (String claim : claims) {
String vmmProperty = claim;// claimsToVMMProps.getProperty(claim);
// if (vmmProperty == null) {
// vmmProperty = claim;
// if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
// Tr.debug(tc, "claim: " + claim + " is not mapped to a vmm property, using the claim name as the vmm property name");
// }
// }
// else if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
// Tr.debug(tc, "claim: " + claim + " mapped to vmmProperty: " + vmmProperty);
// }
claimsToVMMProperties.put(claim, vmmProperty);
vmmServiceProps.getProperties().add(vmmProperty);
}
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "claimsToVMMProperties: " + claimsToVMMProperties);
Tr.debug(tc, "getting VMM properties: " + vmmServiceProps.getProperties());
}
if (!vmmServiceProps.getProperties().isEmpty()) {
// Call VMM to get the user's properties
// IdentifierType id = new IdentifierType();
// String uniqueId = RegistryHelper.getUserRegistry(null).getUniqueUserId(userName);
// id.setUniqueName(uniqueId);
// Entity entity = new Entity();
// entity.setIdentifier(id);
// Root root = new Root();
// root.getEntities().add(entity);
// root.getControls().add(vmmServiceProps);
// root = vmmService.get(root);
// PersonAccount person = (PersonAccount) root.getEntities().get(0);
PersonAccount person = getUser(vmmService, vmmServiceProps);
// Now add the claims/values to the JSON
for (Entry<Object, Object> e : claimsToVMMProperties.entrySet()) {
String claim = (String) e.getKey();
String vmmProperty = (String) e.getValue();
Object value = person.get(vmmProperty);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "get for claim: " + claim + " vmmProperty: " + vmmProperty + ", returned: " + value);
}
String strValue = vmmPropertyToString(value);
if (strValue != null && !strValue.isEmpty()) {
result.put(claim, strValue);
// if (isJson && claim.equals("address")) {
// JSONObject addressJSON = new JSONObject();
// addressJSON.put("formatted", strValue);
// result.put(claim, addressJSON);
// } else {
// result.put(claim, strValue);
// }
}
}
}
}
else {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "VMM service not available - not returning any extra claims");
}
}
return result;
}
|
java
|
@SuppressWarnings("rawtypes")
public String vmmPropertyToString(Object value) {
String result = null;
if (value == null || value instanceof String) {
result = (String) value;
}
else if (value instanceof List) {
StringBuffer strBuff = null;
for (Object element : (List) value) {
String elem = element.toString();
if (elem != null) {
if (strBuff == null) {
strBuff = new StringBuffer();
}
else {
strBuff.append(" ");
}
strBuff.append(elem);
}
}
if (strBuff != null) {
result = strBuff.toString();
}
}
else {
result = value.toString();
}
return result;
}
|
java
|
public static String decode(String encoded) {
// speedily leave if we're not needed
if (encoded == null)
return null;
if (encoded.indexOf('%') == -1 && encoded.indexOf('+') == -1)
return encoded;
//allocate the buffer - use byte[] to avoid calls to new.
byte holdbuffer[] = new byte[encoded.length()];
char holdchar;
int bufcount = 0;
for (int count = 0; count < encoded.length(); count++) {
char cur = encoded.charAt(count);
if (cur == '%') {
holdbuffer[bufcount++] = (byte) Integer.parseInt(encoded.substring(count + 1, count + 3), 16);
if (count + 2 >= encoded.length())
count = encoded.length();
else
count += 2;
}
else if (cur == '+') {
holdbuffer[bufcount++] = (byte) ' ';
}
else {
holdbuffer[bufcount++] = (byte) cur;
}
}
// REVISIT -- remedy for Deprecated warning.
//return new String(holdbuffer,0,0,bufcount);
return new String(holdbuffer, 0, bufcount);
}
|
java
|
public static String URLEncode(String s, String enc) {
if (s == null) {
return "null";
}
if (enc == null) {
enc = "ISO-8859-1"; // Is this right?
}
StringBuffer out = new StringBuffer(s.length());
ByteArrayOutputStream buf = new ByteArrayOutputStream();
OutputStreamWriter writer = null;
try {
writer = new OutputStreamWriter(buf, enc);
} catch (java.io.UnsupportedEncodingException ex) {
// Use the default encoding?
writer = new OutputStreamWriter(buf);
}
for (int i = 0; i < s.length(); i++) {
int c = s.charAt(i);
if (c == ' ') {
out.append('+');
} else if (isSafeChar(c)) {
out.append((char)c);
} else {
// convert to external encoding before hex conversion
try {
writer.write(c);
writer.flush();
} catch(IOException e) {
buf.reset();
continue;
}
byte[] ba = buf.toByteArray();
for (int j = 0; j < ba.length; j++) {
out.append('%');
// Converting each byte in the buffer
out.append(Character.forDigit((ba[j]>>4) & 0xf, 16));
out.append(Character.forDigit(ba[j] & 0xf, 16));
}
buf.reset();
}
}
return out.toString();
}
|
java
|
public void doStartup(ConfigurationProvider cp, boolean isSQLRecoveryLog) {
if (tc.isDebugEnabled())
Tr.debug(tc, "doStartup with cp: " + cp + " and flag: " + isSQLRecoveryLog);
// Create an AppId that will be unique for this server to be used in the generation of Xids.
// Locate the user directory in the Liberty install
String userDirEnv = System.getenv("WLP_USER_DIR");
if (tc.isDebugEnabled())
Tr.debug(tc, "TMS, WLP_USER_DIR env variable is - " + userDirEnv);
// Retrieve the server name.
String serverName = cp.getServerName();
if (tc.isDebugEnabled())
Tr.debug(tc, "TMS, serverName is - " + serverName);
// Retrieve the host name
String hostName = "";
hostName = AccessController.doPrivileged(new PrivilegedAction<String>() {
@Override
public String run() {
String theHost = "";
try {
InetAddress addr = InetAddress.getLocalHost();
theHost = addr.getCanonicalHostName().toLowerCase();
} catch (UnknownHostException e) {
theHost = "localhost";
}
return theHost;
}
});
byte[] theApplId = createApplicationId(userDirEnv, serverName, hostName);
cp.setApplId(theApplId);
if (tc.isDebugEnabled())
Tr.debug(tc, "TMS, cp - " + cp + " set applid - " + Util.toHexString(theApplId));
if (!xaFlowCallbacksInitialised) {
// -------------------------------------------------------
// Initialize the XA Flow callbacks by
// attempting to load the test class.
// -------------------------------------------------------
if (tc.isDebugEnabled())
Tr.debug(tc, "initialise the XA Flow callbacks");
XAFlowCallbackControl.initialize();
xaFlowCallbacksInitialised = true;
}
if (cp.isRecoverOnStartup()) {
try {
TMHelper.start(cp.isWaitForRecovery());
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.ws.transaction.services.TransactionManagerService.doStartup", "60", this);
}
}
}
|
java
|
public void doShutdown(boolean isSQLRecoveryLog) {
if (tc.isEntryEnabled())
Tr.entry(tc, "doShutdown with flag: " + isSQLRecoveryLog);
if (isSQLRecoveryLog) {
try {
TMHelper.shutdown();
} catch (Exception e) {
FFDCFilter.processException(e, "com.ibm.ws.transaction.services.TransactionManagerService.doShutdown", "60", this);
}
}
if (tc.isEntryEnabled())
Tr.exit(tc, "doShutdown");
}
|
java
|
private byte[] createApplicationId(String userDir, String serverName, String hostName) {
final boolean traceOn = TraceComponent.isAnyTracingEnabled();
if (tc.isEntryEnabled())
Tr.entry(tc, "createApplicationId", new Object[] { userDir, serverName, hostName });
byte[] result;
try {
// tWAS - Create a dummy IOR based on this host's IP address and server's port
// tWAS - Note: the object must be remoteable, so use Current as an example.
// tWAS - String s = CORBAUtils.getORB().object_to_string(CurrentImpl.instance());
// On Liberty concatenate the user directory, the server name and the host name. Then add in the time.
String s = userDir + serverName + hostName + System.currentTimeMillis();
// Create a 20-byte hash value using a secure one-way hash function
result = java.security.MessageDigest.getInstance("SHA").digest(s.getBytes());
} catch (Throwable t) {
FFDCFilter.processException(t, "com.ibm.ws.transaction.createApplicationId", "608", this);
String tempStr = "j" + (System.currentTimeMillis() % 9997) + ":" + userDir + hostName;
result = tempStr.getBytes();
}
if (traceOn && tc.isEntryEnabled())
Tr.exit(tc, "createApplicationId", Util.toHexString(result));
return result;
}
|
java
|
@Override
public EntityManager createEntityManager()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "createEntityManager : " + this);
EntityManager em = getEntityManager(false, false);
JPAPooledEntityManager pem = new JPAPooledEntityManager(this, em, ivAbstractJpaComponent, true);
return pem;
}
|
java
|
@Override
public EntityManager createEntityManager(Map arg0)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "createEntityManager : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
@Override
public Cache getCache()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getCache : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
@Override
public CriteriaBuilder getCriteriaBuilder()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getCriteriaBuilder : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
@Override
public Metamodel getMetamodel()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getMetamodel : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
@Override
public PersistenceUnitUtil getPersistenceUnitUtil()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getPersistenceUnitUtil : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
@Override
public Map<String, Object> getProperties()
{
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
Tr.debug(tc, "getProperties : " + this);
throw new UnsupportedOperationException("This operation is not supported on a pooling EntityManagerFactory.");
}
|
java
|
public void complete(VirtualConnection vc, TCPReadRequestContext rsc) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "complete() called: vc=" + vc);
}
HttpOutboundServiceContextImpl mySC = (HttpOutboundServiceContextImpl) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPOSC);
// keep reading and handling new data until either we're done
// parsing headers or until we're waiting on a read to finish
// Note: parseMessage will allocate the read buffers
boolean rc = false;
while (!rc && null != vc) {
rc = handleNewData(mySC, vc);
// if we're not done parsing, then read more data
if (!rc) {
// read whatever is available
vc = rsc.read(1, this, false, mySC.getReadTimeout());
}
}
// if rc is false, then this callback will be used later on when
// the read completes, otherwise check the status code from the
// response message
if (rc) {
StatusCodes status = mySC.getResponse().getStatusCode();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "100-continue scenario received " + status);
}
if (status.equals(StatusCodes.CONTINUE)) {
// got the 100-continue
mySC.resetRead();
mySC.getAppWriteCallback().complete(vc);
} else {
// anything else, pass along the ExpectationFailedException
mySC.setPersistent(false);
mySC.getAppWriteCallback().error(vc, new ExpectationFailedException(status.getIntCode() + " " + mySC.getResponse().getReasonPhrase()));
}
}
}
|
java
|
public void error(VirtualConnection vc, TCPReadRequestContext rsc, IOException ioe) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "error() called: vc=" + vc + " ioe=" + ioe);
}
HttpOutboundServiceContextImpl mySC = (HttpOutboundServiceContextImpl) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPOSC);
mySC.setPersistent(false);
mySC.reConnect(vc, ioe);
}
|
java
|
public void doFilter(ServletRequest request, ServletResponse response) throws ServletException, IOException {
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "entry");
try {
// if there are no filters, just invoke the requested servlet
if (!_filtersDefined) {
invokeTarget(request, response);
}
else {
// increment the filter index
_currentFilterIndex++;
if (_currentFilterIndex < _numberOfFilters) {
// more filters to go...invoke the next one
FilterInstanceWrapper wrapper = ((FilterInstanceWrapper) _filters.get(_currentFilterIndex));
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)){ //306998.15
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "executing filter -->" + wrapper.getFilterName());
}
wrapper.doFilter(request, response, this);
}
else {
invokeTarget(request, response);
}
}
}
catch (UnavailableException e) {
throw e;
}
catch (IOException ioe) {
throw ioe;
}
catch (ServletException e) {
Throwable t = e.getCause();
if (t!=null && t instanceof FileNotFoundException) {
//don't log a FFDC
logger.logp(Level.FINE, CLASS_NAME, "doFilter", "FileNotFound");
}
else{
//start 140014
if(webapp.getDestroyed() != true)
com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(e, "com.ibm.ws.webcontainer.filter.WebAppFilterChain.doFilter", "82", this);
else if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "Can not invoke filter because application is destroyed", e);
//end 140014
}
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "exit");
throw e;
}
catch (RuntimeException re) {
throw re;
}
catch (Throwable th) {
com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(th, "com.ibm.ws.webcontainer.filter.WebAppFilterChain.doFilter", "89", this);
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "exit");
throw new ServletErrorReport(th);
}
if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE))
logger.logp(Level.FINE, CLASS_NAME,"doFilter", "exit");
}
|
java
|
public ClassLoader beginContextClassLoader(ClassLoader raClassLoader) {
return raClassLoader == null ? null
: AccessController.doPrivileged(new GetAndSetContextClassLoader(raClassLoader));
}
|
java
|
public void endContextClassLoader(ClassLoader raClassLoader, ClassLoader previousClassLoader) {
if (raClassLoader != null) {
AccessController.doPrivileged(new GetAndSetContextClassLoader(previousClassLoader));
}
}
|
java
|
public static ConnectionType getVCConnectionType(VirtualConnection vc) {
if (vc == null) {
return null;
}
return (ConnectionType) vc.getStateMap().get(CONNECTION_TYPE_VC_KEY);
}
|
java
|
public static void setVCConnectionType(VirtualConnection vc, ConnectionType connType) {
if (vc == null || connType == null) {
return;
}
Map<Object, Object> map = vc.getStateMap();
// Internal connections are both inbound and outbound (they're connections
// to ourselves)
// so while we prevent setting Outbound ConnTypes for inbound connections
// and vice versa,
// we don't prevent internal types from being set as either.
if (vc instanceof InboundVirtualConnection && ConnectionType.isOutbound(connType.type)) {
throw new IllegalStateException("Cannot set outbound ConnectionType on inbound VirtualConnection");
} else if (vc instanceof OutboundVirtualConnection && ConnectionType.isInbound(connType.type)) {
throw new IllegalStateException("Cannot set inbound ConnectionType on outbound VirtualConnection");
}
map.put(CONNECTION_TYPE_VC_KEY, connType);
}
|
java
|
public static ConnectionType getConnectionType(byte type) {
switch (type) {
case TYPE_OUTBOUND:
return OUTBOUND;
case TYPE_OUTBOUND_CR_TO_REMOTE:
return OUTBOUND_CR_TO_REMOTE;
case TYPE_OUTBOUND_SR_TO_CR_REMOTE:
return OUTBOUND_SR_TO_CR_REMOTE;
case TYPE_INBOUND:
return INBOUND;
case TYPE_INBOUND_CR:
return INBOUND_CR;
case TYPE_INTERNAL_CR_SR:
return INTERNAL_CR_SR;
}
return null;
}
|
java
|
static public int asInt(byte[] array) {
if (null == array || 4 != array.length) {
throw new IllegalArgumentException("Length of the byte array should be 4");
}
return ((array[0] << 24)
+ ((array[1] & 255) << 16)
+ ((array[2] & 255) << 8) + (array[3] & 255));
}
|
java
|
static public byte[] asBytes(int value) {
if (0 > value) {
throw new IllegalArgumentException("value cannot be less than zero");
}
byte[] result = new byte[4];
result[0] = (byte) ((value >>> 24) & 0xFF);
result[1] = (byte) ((value >>> 16) & 0xFF);
result[2] = (byte) ((value >>> 8) & 0xFF);
result[3] = (byte) ((value) & 0xFF);
return result;
}
|
java
|
static public String getEnglishString(WsByteBuffer[] list) {
if (null == list) {
return null;
}
int size = 0;
int i;
for (i = 0; i < list.length && null != list[i]; i++) {
size += list[i].remaining();
}
if (0 == size) {
return null;
}
byte[] value = new byte[size];
int offset = 0;
for (int x = 0; x < i; x++) {
size = list[x].remaining();
list[x].get(value, offset, size);
offset += size;
list[x].position(0);
}
return getEnglishString(value);
}
|
java
|
static public void dumpArrayToTraceLog(byte[] arr) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "[ ");
if (null == arr) {
Tr.debug(tc, "null");
} else {
for (int i = 0; i < arr.length; i++) {
Tr.debug(tc, arr[i] + " ");
}
}
Tr.debug(tc, "]");
}
}
|
java
|
static public byte[] expandByteArray(byte[] src, byte[] dst) {
int srcLength = (null != src) ? src.length : 0;
int dstLength = (null != dst) ? dst.length : 0;
return expandByteArray(src, dst, 0, srcLength, 0, dstLength);
}
|
java
|
static public byte[] expandByteArray(byte[] src, byte b) {
int srcLength = (null != src) ? src.length : 0;
int totalLen = srcLength + 1;
byte[] rc = new byte[totalLen];
try {
if (null != src) {
System.arraycopy(src, 0, rc, 0, srcLength);
}
rc[srcLength] = b;
} catch (Exception e) {
// no FFDC required
// any error from arraycopy, we'll just return null
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Exception " + e + " while copying.");
}
rc = null;
}
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc,
"expandByteArray returning: [" + getEnglishString(rc) + "]");
}
return rc;
}
|
java
|
static public byte[] getBytes(StringBuffer data) {
if (null == data) {
return null;
}
int len = data.length();
char[] chars = new char[len];
data.getChars(0, len, chars, 0);
byte[] bytes = new byte[len];
for (int i = 0; i < len; i++) {
bytes[i] = (byte) chars[i];
}
return bytes;
}
|
java
|
static public byte[] getBytes(String input) {
if (null != input) {
int length = input.length();
byte[] output = new byte[length];
for (int i = 0; i < length; i++) {
output[i] = (byte) input.charAt(i);
}
return output;
}
return null;
}
|
java
|
static public String getEnglishString(byte[] data) {
if (null == data) {
return null;
}
char chars[] = new char[data.length];
for (int i = 0; i < data.length; i++) {
chars[i] = (char) (data[i] & 0xff);
}
return new String(chars);
}
|
java
|
static private StringBuilder formatHexData(StringBuilder buffer, byte[] data, int inOffset) {
int offset = inOffset;
int end = offset + 8;
if (offset >= data.length) {
// have nothing, just print empty chars
buffer.append(" ");
return buffer;
}
buffer.append(convertHex((0xff & data[offset]) / 16));
buffer.append(convertHex((0xff & data[offset]) % 16));
for (++offset; offset < end; offset++) {
if (offset >= data.length) {
buffer.append(" ");
continue;
}
buffer.append(' ');
buffer.append(convertHex((0xff & data[offset]) / 16));
buffer.append(convertHex((0xff & data[offset]) % 16));
}
return buffer;
}
|
java
|
static private StringBuilder formatTextData(StringBuilder buffer, byte[] data, int inOffset) {
int offset = inOffset;
int end = offset + 16;
for (; offset < end; offset++) {
if (offset >= data.length) {
buffer.append(" ");
continue;
}
if (Character.isLetterOrDigit(data[offset])) {
buffer.append((char) data[offset]);
} else {
buffer.append('.');
}
}
return buffer;
}
|
java
|
static public int skipToChar(byte[] data, int start, byte target) {
int index = start;
while (index < data.length && target != data[index]) {
index++;
}
return index;
}
|
java
|
static public int skipToChars(byte[] data, int start, byte[] targets) {
int index = start;
int y = 0;
byte current;
for (; index < data.length; index++) {
current = data[index];
for (y = 0; y < targets.length; y++) {
if (current == targets[y]) {
return index;
}
}
}
return index;
}
|
java
|
static public int skipWhiteSpace(byte[] data, int start) {
int index = start + 1;
while (index < data.length && BNFHeaders.SPACE == data[index]) {
index++;
}
return index;
}
|
java
|
static public int sizeOf(WsByteBuffer[] list) {
if (null == list) {
return 0;
}
int size = 0;
for (int i = 0; i < list.length; i++) {
if (null != list[i]) {
size += list[i].remaining();
}
}
return size;
}
|
java
|
static public byte[] readValue(ObjectInput in, int len) throws IOException {
int bytesRead = 0;
byte[] data = new byte[len];
for (int offset = 0; offset < len; offset += bytesRead) {
bytesRead = in.read(data, offset, len - offset);
if (bytesRead == -1) {
throw new IOException("Could not retrieve ");
}
}
return data;
}
|
java
|
static public String blockContents(byte[] value) {
if (null == value) {
return null;
}
char[] data = new char[value.length];
for (int i = 0; i < data.length; i++) {
data[i] = '*';
}
return new String(data);
}
|
java
|
private void handleCollectiveLogin(X509Certificate certChain[], CollectiveAuthenticationPlugin plugin,
boolean collectiveCert) throws InvalidNameException, AuthenticationException, Exception {
// If the chain is not authenticated, it will throw an AuthenticationException
plugin.authenticateCertificateChain(certChain, collectiveCert);
X509Certificate cert = certChain[0];
X500Principal x509Subject = cert.getSubjectX500Principal();
String accessId = AccessIdUtil.createAccessId(AccessIdUtil.TYPE_SERVER,
"collective",
x509Subject.getName());
username = x509Subject.getName();
authenticatedId = x509Subject.getName();
addCredentials(accessId);
}
|
java
|
private void addCredentials(String accessId) throws Exception {
temporarySubject = new Subject();
Hashtable<String, Object> hashtable = new Hashtable<String, Object>();
hashtable.put(AttributeNameConstants.WSCREDENTIAL_UNIQUEID, AccessIdUtil.getUniqueId(accessId));
temporarySubject.getPublicCredentials().add(hashtable);
setWSPrincipal(temporarySubject, username, accessId, WSPrincipal.AUTH_METHOD_CERTIFICATE);
setCredentials(temporarySubject, username, username);
temporarySubject.getPublicCredentials().remove(hashtable);
}
|
java
|
private void handleUserLogin(X509Certificate certChain[]) throws RegistryException, CertificateMapNotSupportedException, CertificateMapFailedException, EntryNotFoundException, Exception {
UserRegistry userRegistry = getUserRegistry();
username = userRegistry.mapCertificate(certChain);
authenticatedId = userRegistry.getUniqueUserId(username);
securityName = userRegistry.getUserSecurityName(authenticatedId);
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "username=[" + username +
"] authenticatedId=[" + authenticatedId +
"] securityName=[" + securityName + "]");
}
setUpTemporarySubject();
}
|
java
|
private BeanDiscoveryMode getBeanDiscoveryMode() {
if (beanDiscoveryMode == null) {
BeansXml beansXml = getBeansXml();
beanDiscoveryMode = BeanDiscoveryMode.ANNOTATED;
if (beansXml != null) {
beanDiscoveryMode = beansXml.getBeanDiscoveryMode();
} else if ((cdiRuntime.isImplicitBeanArchivesScanningDisabled(this.archive) || isExtension())) {
// If the server.xml has the configuration of enableImplicitBeanArchives sets to false, we will not scan the implicit bean archives
beanDiscoveryMode = BeanDiscoveryMode.NONE;
}
}
return beanDiscoveryMode;
}
|
java
|
private void removeVetoedClasses(Set<Class<?>> classes) {
//get hold of classnames
Set<String> classNames = new HashSet<String>();
for (Class<?> clazz : classes) {
classNames.add(clazz.getName());
}
// take into considerations of the exclude in beans.xml
Collection<String> includedClasses = WeldCDIUtils.filterClassesBasedOnBeansXML(this.beansXml, this.resourceLoader, classNames);
Iterator<Class<?>> iterator = classes.iterator();
while (iterator.hasNext()) {
Class<?> clazz = iterator.next();
if (WeldCDIUtils.isClassVetoed(clazz)) {
iterator.remove();
} else if (!includedClasses.contains(clazz.getName())) {
iterator.remove();
}
}
}
|
java
|
private ControllableSubscription getSubscription(String id)
throws SIMPControllableNotFoundException
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.entry(tc, "getSubscription", id);
//id is assumed to be SIBUuid12
SIBUuid12 uuid = new SIBUuid12(id);
SubscriptionTypeFilter filter = new SubscriptionTypeFilter();
filter.LOCAL = Boolean.TRUE;
ControllableSubscription sub = getSubscriptionIndex().findByUuid(uuid, filter);
// If the sub is null, throw an exception
if (sub == null)
{
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(
tc,
"getLocalSubscriptionControlByID",
"SIMPControllableNotFoundException");
throw new SIMPControllableNotFoundException(
nls.getFormattedMessage(
"SUBSCRIPTION_NOT_FOUND_ERROR_CWSIP0271",
new Object[]{id},
null));
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
SibTr.exit(tc, "getSubscription", sub);
return sub;
}
|
java
|
@SuppressWarnings("unused")
@Activate
protected void activate(ComponentContext context) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Activating the HTTP pipeline event handler");
}
}
|
java
|
@SuppressWarnings("unused")
@Deactivate
protected void deactivate(ComponentContext context) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(tc, "Deactivating the HTTP pipeline event handler");
}
}
|
java
|
static public byte[] getEnglishBytes(String data) {
if (null == data) {
return null;
}
char[] chars = data.toCharArray();
byte[] bytes = new byte[chars.length];
for (int i = 0; i < chars.length; i++) {
bytes[i] = (byte) chars[i];
}
return bytes;
}
|
java
|
static public String getEnglishString(byte[] data, int start, int end) {
int len = end - start;
if (0 >= len || null == data) {
return null;
}
char chars[] = new char[len];
for (int i = start; i < end; i++) {
chars[i] = (char) (data[i] & 0xff);
}
return new String(chars);
}
|
java
|
public void createInterceptorInstances(InjectionEngine injectionEngine,
Object[] interceptors,
ManagedObjectContext managedObjectContext,
ManagedBeanOBase targetContext) throws Exception {
final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
if (isTraceOn && tc.isEntryEnabled()) {
Tr.entry(tc, "createInterceptorInstances");
}
if (ivInterceptorClasses != null) {
int numberOfInterceptors = ivInterceptorClasses.length;
for (int i = 0; i < numberOfInterceptors; i++) {
if (ivInterceptorFactories == null || ivInterceptorFactories[i] == null) {
interceptors[i] = createInterceptorInstanceUsingConstructor(injectionEngine, ivInterceptorClasses[i], ivInterceptorInjectionTargets[i], targetContext);
} else {
interceptors[i] = createInterceptorInstancesUsingMOF(ivInterceptorInjectionTargets[i], managedObjectContext, targetContext, ivInterceptorFactories[i]);
}
}
}
if (isTraceOn && tc.isEntryEnabled()) {
Tr.exit(tc, "createInterceptorInstances");
}
}
|
java
|
public void run() {
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.entry(tc, "run");
}
try {
framework.stopChain(chainName, 0L);
} catch (Exception e) {
FFDCFilter.processException(e, getClass().getName() + ".run", "68",
this, new Object[] { chainName });
}
if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
Tr.exit(tc, "run");
}
}
|
java
|
@Override
public String[] getOptionValues() {
String[] values = new String[valueOptions.size()];
for (int i = 0; i < values.length; i++) {
values[i] = valueOptions.get(i)[0];
}
return values;
}
|
java
|
@Override
public String[] getOptionLabels() {
String[] labels = new String[valueOptions.size()];
for (int i = 0; i < labels.length; i++) {
labels[i] = valueOptions.get(i)[1];
}
return labels;
}
|
java
|
private SubscriptionMessage createSubscriptionMessage()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "createSubscriptionMessage");
ControlMessageFactory factory = null;
SubscriptionMessage subscriptionMessage = null;
try
{
factory = MessageProcessor.getControlMessageFactory();
subscriptionMessage = factory.createNewSubscriptionMessage();
}
catch (Exception e)
{
FFDCFilter.processException(
e,
"com.ibm.ws.sib.processor.proxyhandler.SubscriptionMessageHandler.createSubscriptionMessage",
"1:162:1.34",
this);
SibTr.exception(tc, e);
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "createSubscriptionMessage", subscriptionMessage);
return subscriptionMessage;
}
|
java
|
private void reset()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "reset");
if (iInitialised)
{
// Reset the ArrayLists associated with this message
iTopics.clear();
iTopicSpaces.clear();
iTopicSpaceMappings.clear();
// Create a new message to send to this Neighbour.
iSubscriptionMessage = createSubscriptionMessage();
}
else
{
iInitialised = true;
}
if (tc.isEntryEnabled())
SibTr.exit(tc, "reset");
}
|
java
|
protected void resetCreateSubscriptionMessage(MESubscription subscription, boolean isLocalBus)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "resetCreateSubscriptionMessage", new Object[]{subscription, new Boolean(isLocalBus)});
// Reset the state
reset();
// Indicate that this is a create message
iSubscriptionMessage.setSubscriptionMessageType(
SubscriptionMessageType.CREATE);
// Add the subscription related information.
iTopics.add(subscription.getTopic());
if(isLocalBus)
{
//see defect 267686:
//local bus subscriptions expect the subscribing ME's
//detination uuid to be set in the iTopicSpaces field
iTopicSpaces.add(subscription.getTopicSpaceUuid().toString());
}
else
{
//see defect 267686:
//foreign bus subscriptions need to set the subscribers's topic space name.
//This is because the messages sent to this topic over the link
//will need to have a routing destination set, which requires
//this value.
iTopicSpaces.add(subscription.getTopicSpaceName().toString());
}
iTopicSpaceMappings.add(subscription.getForeignTSName());
if (tc.isEntryEnabled())
SibTr.exit(tc, "resetCreateSubscriptionMessage");
}
|
java
|
protected void resetDeleteSubscriptionMessage()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "resetDeleteSubscriptionMessage");
// Reset the state
reset();
// Indicate that this is a create message
iSubscriptionMessage.setSubscriptionMessageType(
SubscriptionMessageType.DELETE);
if (tc.isEntryEnabled())
SibTr.exit(tc, "resetDeleteSubscriptionMessage");
}
|
java
|
protected void resetResetSubscriptionMessage()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "resetResetSubscriptionMessage");
// Reset the state
reset();
// Indicate that this is a create message
iSubscriptionMessage.setSubscriptionMessageType(
SubscriptionMessageType.RESET);
if (tc.isEntryEnabled())
SibTr.exit(tc, "resetResetSubscriptionMessage");
}
|
java
|
protected void resetReplySubscriptionMessage()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "resetReplySubscriptionMessage");
// Reset the state
reset();
// Indicate that this is a create message
iSubscriptionMessage.setSubscriptionMessageType(
SubscriptionMessageType.REPLY);
if (tc.isEntryEnabled())
SibTr.exit(tc, "resetReplySubscriptionMessage");
}
|
java
|
protected void addSubscriptionToMessage(MESubscription subscription, boolean isLocalBus)
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "addSubscriptionToMessage", new Object[]{subscription, new Boolean(isLocalBus)});
// Add the subscription related information.
iTopics.add(subscription.getTopic());
if(isLocalBus)
{
//see defect 267686:
//local bus subscriptions expect the subscribing ME's
//detination uuid to be set in the iTopicSpaces field
iTopicSpaces.add(subscription.getTopicSpaceUuid().toString());
}
else
{
//see defect 267686:
//foreign bus subscriptions need to set the subscribers's topic space name.
//This is because the messages sent to this topic over the link
//will need to have a routing destination set, which requires
//this value.
iTopicSpaces.add(subscription.getTopicSpaceName().toString());
}
iTopicSpaceMappings.add(subscription.getForeignTSName());
if (tc.isEntryEnabled())
SibTr.exit(tc, "addSubscriptionToMessage");
}
|
java
|
protected SubscriptionMessage getSubscriptionMessage()
{
if (tc.isEntryEnabled())
SibTr.entry(tc, "getSubscriptionMessage");
// Set the values in the message
iSubscriptionMessage.setTopics(iTopics);
iSubscriptionMessage.setMEName(iMEName);
iSubscriptionMessage.setMEUUID(iMEUUID.toByteArray());
iSubscriptionMessage.setBusName(iBusName);
iSubscriptionMessage.setReliability(Reliability.ASSURED_PERSISTENT); //PK36530
iSubscriptionMessage.setTopicSpaces(iTopicSpaces);
iSubscriptionMessage.setTopicSpaceMappings(iTopicSpaceMappings);
if (tc.isEntryEnabled())
SibTr.exit(tc, "getSubscriptionMessage", new Object[] {
iTopics, iMEName, iMEUUID, iBusName, iTopicSpaces, iTopicSpaceMappings});
return iSubscriptionMessage;
}
|
java
|
private void auditEventSafAuthDetails(Object[] methodParams) {
// Getting object array which have audit fields
Object[] varargs = (Object[]) methodParams[1];
// Get audit fields and convert them to respective type
int safReturnCode = (Integer) varargs[0];
int racfReturnCode = (Integer) varargs[1];
int racfReasonCode = (Integer) varargs[2];
String userSecurityName = (String) varargs[3];
String safProfile = (String) varargs[4];
String safClass = (String) varargs[5];
Boolean authDecision = (Boolean) varargs[6];
String principalName = (String) varargs[7];
String applid = (String) varargs[8];
if (auditServiceRef.getService() != null
&& auditServiceRef.getService().isAuditRequired(AuditConstants.SECURITY_SAF_AUTHZ_DETAILS,
AuditConstants.SUCCESS)) {
// Create audit event
SAFAuthorizationDetailsEvent safAuthDetails = new SAFAuthorizationDetailsEvent(safReturnCode,
racfReturnCode, racfReasonCode, userSecurityName, applid, safProfile, safClass, authDecision,
principalName);
auditServiceRef.getService().sendEvent(safAuthDetails);
}
}
|
java
|
private String[] getValues(Object propValue) {
String[] keys = null;
if (propValue instanceof String) {
keys = new String[] { (String) propValue };
} else if (propValue instanceof String[]) {
keys = (String[]) propValue;
} else {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "Ignoring property with value: " + propValue);
}
return null;
}
for (String key : keys) {
// Ensure it starts with a slash ('/')
if (!key.startsWith("/")) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "Ignoring property with value: " + key + " as it does not start with slash ('/')");
}
return null;
}
// Ensure its longer than just slash ('/')
if (key.isEmpty()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
Tr.event(this, tc, "Ignoring proerty with value: " + key + " as it is empty");
}
return null;
}
}
return keys;
}
|
java
|
public HandlerInfo getHandler(String requestURL) {
Iterator<HandlerPath> keys = handlerKeys.iterator();
if (requestURL == null || keys == null) {
return null;
}
// Check to see if we have a direct hit
Iterator<ServiceAndServiceReferencePair<RESTHandler>> itr = handlerMap.getServicesWithReferences(requestURL);
if (itr != null && itr.hasNext()) {
ServiceAndServiceReferencePair<RESTHandler> handler = itr.next();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Found direct URL match: " + handler);
}
return new HandlerInfo(handler.getService(), handler.getServiceReference());
}
// If no direct match, then try to match each one. Longest match wins.
HandlerPath bestMatchRoot = null;
while (keys.hasNext()) {
HandlerPath key = keys.next();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Checking HandlerPath: " + key.getRegisteredPath() + " | length: " + key.length());
}
if (key.matches(requestURL)) {
if (bestMatchRoot == null || key.length() > bestMatchRoot.length()) {
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(this, tc, "New best match: " + key.getRegisteredPath());
}
bestMatchRoot = key;
}
}
}
// If we found a match...
if (bestMatchRoot != null) {
// Get the iterator. We MUST check hasNext first, because of how
// the underlying implementation is written.
itr = handlerMap.getServicesWithReferences(bestMatchRoot.getRegisteredPath());
if (itr != null && itr.hasNext()) {
ServiceAndServiceReferencePair<RESTHandler> handler = itr.next();
if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
Tr.debug(this, tc, "Final best handler: " + handler);
}
return new HandlerInfo(handler.getService(), handler.getServiceReference(), bestMatchRoot);
}
}
return null;
}
|
java
|
@Override
public Iterator<String> registeredKeys() {
Iterator<HandlerPath> paths = handlerKeys.iterator();
List<String> registeredKeys = new ArrayList<String>(handlerKeys.size());
while (paths.hasNext()) {
HandlerPath path = paths.next();
if (!path.isHidden()) {
registeredKeys.add(path.getRegisteredPath());
}
}
return registeredKeys.iterator();
}
|
java
|
synchronized public Element get(long index) {
int bind = ((int)index & Integer.MAX_VALUE) % buckets.length;
Element[] bucket = buckets[bind];
if (bucket == null)
return null;
for (int i = 0; i < counts[bind]; i++)
if (bucket[i].getIndex() == index)
return bucket[i];
return null;
}
|
java
|
synchronized public void set(Element value) {
int bind = ((int)value.getIndex() & Integer.MAX_VALUE) % buckets.length;
Element[] bucket = buckets[bind];
int count = counts[bind];
if (bucket == null)
buckets[bind] = bucket = new Element[initBucketSize];
else if (bucket.length == count) {
bucket = new Element[count * 2];
System.arraycopy(buckets[bind], 0, bucket, 0, count);
buckets[bind] = bucket;
}
bucket[count] = value;
counts[bind] = count + 1;
totalSize += 1;
}
|
java
|
synchronized public Object[] toArray(Object[] values) {
int count = 0;
for (int bind = 0; bind < buckets.length; bind++) {
if (counts[bind] > 0)
System.arraycopy(buckets[bind], 0, values, count, counts[bind]);
count += counts[bind];
}
return values;
}
|
java
|
@SuppressWarnings("unchecked")
private <T> T getProperty(Map<String, Object> properties, String name, T deflt) {
T value = deflt;
try {
T prop = (T) properties.get(name);
if (prop != null) {
value = prop;
}
} catch (ClassCastException e) {
//auto FFDC and allow the default value to be returned so that the server still starts
}
return value;
}
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.