code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
protected PasswordAuthentication getPasswordAuthentication() {
// Don't worry, this is just a hack to figure out if we were able
// to set this Authenticator through the setDefault method.
if (!sInitialized && MAGIC.equals(getRequestingScheme()) && getRequestingPort() == FOURTYTWO) {
return new PasswordAuthentication(MAGIC, ("" + FOURTYTWO).toCharArray());
}
/*
System.err.println("getPasswordAuthentication");
System.err.println(getRequestingSite());
System.err.println(getRequestingPort());
System.err.println(getRequestingProtocol());
System.err.println(getRequestingPrompt());
System.err.println(getRequestingScheme());
*/
// TODO:
// Look for a more specific PasswordAuthenticatior before using
// Default:
//
// if (...)
// return pa.requestPasswordAuthentication(getRequestingSite(),
// getRequestingPort(),
// getRequestingProtocol(),
// getRequestingPrompt(),
// getRequestingScheme());
return passwordAuthentications.get(new AuthKey(getRequestingSite(),
getRequestingPort(),
getRequestingProtocol(),
getRequestingPrompt(),
getRequestingScheme()));
} | java |
public PasswordAuthentication registerPasswordAuthentication(URL pURL, PasswordAuthentication pPA) {
return registerPasswordAuthentication(NetUtil.createInetAddressFromURL(pURL),
pURL.getPort(),
pURL.getProtocol(),
null, // Prompt/Realm
BASIC,
pPA);
} | java |
public PasswordAuthentication registerPasswordAuthentication(InetAddress pAddress, int pPort, String pProtocol, String pPrompt, String pScheme, PasswordAuthentication pPA) {
/*
System.err.println("registerPasswordAuthentication");
System.err.println(pAddress);
System.err.println(pPort);
System.err.println(pProtocol);
System.err.println(pPrompt);
System.err.println(pScheme);
*/
return passwordAuthentications.put(new AuthKey(pAddress, pPort, pProtocol, pPrompt, pScheme), pPA);
} | java |
public PasswordAuthentication unregisterPasswordAuthentication(URL pURL) {
return unregisterPasswordAuthentication(NetUtil.createInetAddressFromURL(pURL), pURL.getPort(), pURL.getProtocol(), null, BASIC);
} | java |
public PasswordAuthentication unregisterPasswordAuthentication(InetAddress pAddress, int pPort, String pProtocol, String pPrompt, String pScheme) {
return passwordAuthentications.remove(new AuthKey(pAddress, pPort, pProtocol, pPrompt, pScheme));
} | java |
@InitParam(name = "accept-mappings-file")
public void setAcceptMappingsFile(String pPropertiesFile) throws ServletConfigException {
// NOTE: Format is:
// <agent-name>=<reg-exp>
// <agent-name>.accept=<http-accept-header>
Properties mappings = new Properties();
try {
log("Reading Accept-mappings properties file: " + pPropertiesFile);
mappings.load(getServletContext().getResourceAsStream(pPropertiesFile));
//System.out.println("--> Loaded file: " + pPropertiesFile);
}
catch (IOException e) {
throw new ServletConfigException("Could not read Accept-mappings properties file: " + pPropertiesFile, e);
}
parseMappings(mappings);
} | java |
public int doEndTag() throws JspException {
// Trim
String trimmed = truncateWS(bodyContent.getString());
try {
// Print trimmed content
//pageContext.getOut().print("<!--TWS-->\n");
pageContext.getOut().print(trimmed);
//pageContext.getOut().print("\n<!--/TWS-->");
}
catch (IOException ioe) {
throw new JspException(ioe);
}
return super.doEndTag();
} | java |
private static String truncateWS(String pStr) {
char[] chars = pStr.toCharArray();
int count = 0;
boolean lastWasWS = true; // Avoids leading WS
for (int i = 0; i < chars.length; i++) {
if (!Character.isWhitespace(chars[i])) {
// if char is not WS, just store
chars[count++] = chars[i];
lastWasWS = false;
}
else {
// else, if char is WS, store first, skip the rest
if (!lastWasWS) {
if (chars[i] == 0x0d) {
chars[count++] = 0x0a; //Always new line
}
else {
chars[count++] = chars[i];
}
}
lastWasWS = true;
}
}
// Return the trucated string
return new String(chars, 0, count);
} | java |
private ImageServletResponse createImageServletResponse(final ServletRequest pRequest, final ServletResponse pResponse) {
if (pResponse instanceof ImageServletResponseImpl) {
ImageServletResponseImpl response = (ImageServletResponseImpl) pResponse;
// response.setRequest(pRequest);
return response;
}
return new ImageServletResponseImpl(pRequest, pResponse, getServletContext());
} | java |
protected RenderedImage doFilter(BufferedImage pImage, ServletRequest pRequest, ImageServletResponse pResponse) {
// Get angle
double ang = getAngle(pRequest);
// Get bounds
Rectangle2D rect = getBounds(pRequest, pImage, ang);
int width = (int) rect.getWidth();
int height = (int) rect.getHeight();
// Create result image
BufferedImage res = ImageUtil.createTransparent(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = res.createGraphics();
// Get background color and clear
String str = pRequest.getParameter(PARAM_BGCOLOR);
if (!StringUtil.isEmpty(str)) {
Color bgcolor = StringUtil.toColor(str);
g.setBackground(bgcolor);
g.clearRect(0, 0, width, height);
}
// Set mHints (why do I always get jagged edgdes?)
RenderingHints hints = new RenderingHints(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
hints.add(new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY));
hints.add(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
hints.add(new RenderingHints(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC));
g.setRenderingHints(hints);
// Rotate around center
AffineTransform at = AffineTransform
.getRotateInstance(ang, width / 2.0, height / 2.0);
// Move to center
at.translate(width / 2.0 - pImage.getWidth() / 2.0,
height / 2.0 - pImage.getHeight() / 2.0);
// Draw it, centered
g.drawImage(pImage, at, null);
return res;
} | java |
private double getAngle(ServletRequest pReq) {
double angle = 0.0;
String str = pReq.getParameter(PARAM_ANGLE);
if (!StringUtil.isEmpty(str)) {
angle = Double.parseDouble(str);
// Convert to radians, if needed
str = pReq.getParameter(PARAM_ANGLE_UNITS);
if (!StringUtil.isEmpty(str)
&& ANGLE_DEGREES.equalsIgnoreCase(str)) {
angle = Math.toRadians(angle);
}
}
return angle;
} | java |
private Rectangle2D getBounds(ServletRequest pReq, BufferedImage pImage,
double pAng) {
// Get dimensions of original image
int width = pImage.getWidth(); // loads the image
int height = pImage.getHeight();
// Test if we want to crop image (default)
// if true
// - find the largest bounding box INSIDE the rotated image,
// that matches the original proportions (nearest 90deg)
// (scale up to fit dimensions?)
// else
// - find the smallest bounding box OUTSIDE the rotated image.
// - that matches the original proportions (nearest 90deg) ?
// (scale down to fit dimensions?)
AffineTransform at =
AffineTransform.getRotateInstance(pAng, width / 2.0, height / 2.0);
Rectangle2D orig = new Rectangle(width, height);
Shape rotated = at.createTransformedShape(orig);
if (ServletUtil.getBooleanParameter(pReq, PARAM_CROP, false)) {
// TODO: Inside box
return rotated.getBounds2D();
}
else {
return rotated.getBounds2D();
}
} | java |
void initIRGB(int[] pTemp) {
final int x = (1 << TRUNCBITS); // 8 the size of 1 Dimension of each quantized cell
final int xsqr = 1 << (TRUNCBITS * 2); // 64 - twice the smallest step size vale of quantized colors
final int xsqr2 = xsqr + xsqr;
for (int i = 0; i < numColors; ++i) {
if (i == transparentIndex) {
// Skip the transparent pixel
continue;
}
int red, r, rdist, rinc, rxx;
int green, g, gdist, ginc, gxx;
int blue, b, bdist, binc, bxx;
// HaraldK 20040801: Added support for int[]
if (rgbMapByte != null) {
red = rgbMapByte[i * 4] & 0xFF;
green = rgbMapByte[i * 4 + 1] & 0xFF;
blue = rgbMapByte[i * 4 + 2] & 0xFF;
}
else if (rgbMapInt != null) {
red = (rgbMapInt[i] >> 16) & 0xFF;
green = (rgbMapInt[i] >> 8) & 0xFF;
blue = rgbMapInt[i] & 0xFF;
}
else {
throw new IllegalStateException("colormap == null");
}
rdist = red - x / 2; // distance of red to center of current cell
gdist = green - x / 2; // green
bdist = blue - x / 2; // blue
rdist = rdist * rdist + gdist * gdist + bdist * bdist;
rinc = 2 * (xsqr - (red << TRUNCBITS));
ginc = 2 * (xsqr - (green << TRUNCBITS));
binc = 2 * (xsqr - (blue << TRUNCBITS));
int rgbI = 0;
for (r = 0, rxx = rinc; r < MAXQUANTVAL; rdist += rxx, ++r, rxx += xsqr2) {
for (g = 0, gdist = rdist, gxx = ginc; g < MAXQUANTVAL; gdist += gxx, ++g, gxx += xsqr2) {
for (b = 0, bdist = gdist, bxx = binc; b < MAXQUANTVAL; bdist += bxx, ++b, ++rgbI, bxx += xsqr2) {
if (i == 0 || pTemp[rgbI] > bdist) {
pTemp[rgbI] = bdist;
inverseRGB[rgbI] = (byte) i;
}
}
}
}
}
} | java |
public static Class unwrapType(Class pType) {
if (pType == Boolean.class) {
return Boolean.TYPE;
}
else if (pType == Byte.class) {
return Byte.TYPE;
}
else if (pType == Character.class) {
return Character.TYPE;
}
else if (pType == Double.class) {
return Double.TYPE;
}
else if (pType == Float.class) {
return Float.TYPE;
}
else if (pType == Integer.class) {
return Integer.TYPE;
}
else if (pType == Long.class) {
return Long.TYPE;
}
else if (pType == Short.class) {
return Short.TYPE;
}
throw new IllegalArgumentException("Not a primitive wrapper: " + pType);
} | java |
private static boolean canRead(final DataInput pInput, final boolean pReset) {
long pos = FREE_SID;
if (pReset) {
try {
if (pInput instanceof InputStream && ((InputStream) pInput).markSupported()) {
((InputStream) pInput).mark(8);
}
else if (pInput instanceof ImageInputStream) {
((ImageInputStream) pInput).mark();
}
else if (pInput instanceof RandomAccessFile) {
pos = ((RandomAccessFile) pInput).getFilePointer();
}
else if (pInput instanceof LittleEndianRandomAccessFile) {
pos = ((LittleEndianRandomAccessFile) pInput).getFilePointer();
}
else {
return false;
}
}
catch (IOException ignore) {
return false;
}
}
try {
byte[] magic = new byte[8];
pInput.readFully(magic);
return Arrays.equals(magic, MAGIC);
}
catch (IOException ignore) {
// Ignore
}
finally {
if (pReset) {
try {
if (pInput instanceof InputStream && ((InputStream) pInput).markSupported()) {
((InputStream) pInput).reset();
}
else if (pInput instanceof ImageInputStream) {
((ImageInputStream) pInput).reset();
}
else if (pInput instanceof RandomAccessFile) {
((RandomAccessFile) pInput).seek(pos);
}
else if (pInput instanceof LittleEndianRandomAccessFile) {
((LittleEndianRandomAccessFile) pInput).seek(pos);
}
}
catch (IOException e) {
// TODO: This isn't actually good enough...
// Means something fucked up, and will fail...
e.printStackTrace();
}
}
}
return false;
} | java |
private SIdChain getSIdChain(final int pSId, final long pStreamSize) throws IOException {
SIdChain chain = new SIdChain();
int[] sat = isShortStream(pStreamSize) ? shortSAT : SAT;
int sid = pSId;
while (sid != END_OF_CHAIN_SID && sid != FREE_SID) {
chain.addSID(sid);
sid = sat[sid];
}
return chain;
} | java |
private void seekToSId(final int pSId, final long pStreamSize) throws IOException {
long pos;
if (isShortStream(pStreamSize)) {
// The short stream is not continuous...
Entry root = getRootEntry();
if (shortStreamSIdChain == null) {
shortStreamSIdChain = getSIdChain(root.startSId, root.streamSize);
}
// System.err.println("pSId: " + pSId);
int shortPerSId = sectorSize / shortSectorSize;
// System.err.println("shortPerSId: " + shortPerSId);
int offset = pSId / shortPerSId;
// System.err.println("offset: " + offset);
int shortOffset = pSId - (offset * shortPerSId);
// System.err.println("shortOffset: " + shortOffset);
// System.err.println("shortStreamSIdChain.offset: " + shortStreamSIdChain.get(offset));
pos = HEADER_SIZE
+ (shortStreamSIdChain.get(offset) * (long) sectorSize)
+ (shortOffset * (long) shortSectorSize);
// System.err.println("pos: " + pos);
}
else {
pos = HEADER_SIZE + pSId * (long) sectorSize;
}
if (input instanceof LittleEndianRandomAccessFile) {
((LittleEndianRandomAccessFile) input).seek(pos);
}
else if (input instanceof ImageInputStream) {
((ImageInputStream) input).seek(pos);
}
else {
((SeekableLittleEndianDataInputStream) input).seek(pos);
}
} | java |
protected Object initPropertyValue(String pValue, String pType, String pFormat) throws ClassNotFoundException {
// System.out.println("pValue=" + pValue + " pType=" + pType
// + " pFormat=" + pFormat);
// No value to convert
if (pValue == null) {
return null;
}
// No conversion needed for Strings
if ((pType == null) || pType.equals("String") || pType.equals("java.lang.String")) {
return pValue;
}
Object value;
if (pType.equals("Date") || pType.equals("java.util.Date")) {
// Special parser needed
try {
// Parse date through StringUtil
if (pFormat == null) {
value = StringUtil.toDate(pValue, sDefaultFormat);
} else {
value = StringUtil.toDate(pValue, new SimpleDateFormat(pFormat));
}
} catch (IllegalArgumentException e) {
// Not parseable...
throw e;
}
// Return
return value;
} else if (pType.equals("java.sql.Timestamp")) {
// Special parser needed
try {
// Parse timestamp through StringUtil
value = StringUtil.toTimestamp(pValue);
} catch (IllegalArgumentException e) {
// Not parseable...
throw new RuntimeException(e.getMessage());
}
// Return
return value;
} else {
int dot = pType.indexOf(".");
if (dot < 0) {
pType = "java.lang." + pType;
}
// Get class
Class cl = Class.forName(pType);
// Try to create instance from <Constructor>(String)
value = createInstance(cl, pValue);
if (value == null) {
// createInstance failed for some reason
// Try to invoke the static method valueof(String)
value = invokeStaticMethod(cl, "valueOf", pValue);
// If the value is still null, well, then I cannot help...
}
}
// Return
return value;
} | java |
private Object createInstance(Class pClass, Object pParam) {
Object value;
try {
// Create param and argument arrays
Class[] param = { pParam.getClass() };
Object[] arg = { pParam };
// Get constructor
Constructor constructor = pClass.getDeclaredConstructor(param);
// Invoke and create instance
value = constructor.newInstance(arg);
} catch (Exception e) {
return null;
}
return value;
} | java |
private Object invokeStaticMethod(Class pClass, String pMethod, Object pParam) {
Object value = null;
try {
// Create param and argument arrays
Class[] param = { pParam.getClass() };
Object[] arg = { pParam };
// Get method
// *** If more than one such method is found in the class, and one
// of these methods has a RETURN TYPE that is more specific than
// any of the others, that method is reflected; otherwise one of
// the methods is chosen ARBITRARILY.
// java/lang/Class.html#getMethod(java.lang.String, java.lang.Class[])
java.lang.reflect.Method method = pClass.getMethod(pMethod, param);
// Invoke public static method
if (Modifier.isPublic(method.getModifiers()) && Modifier.isStatic(method.getModifiers())) {
value = method.invoke(null, arg);
}
} catch (Exception e) {
return null;
}
return value;
} | java |
public synchronized String setPropertyFormat(String pKey, String pFormat) {
// Insert format
return StringUtil.valueOf(mFormats.put(pKey, pFormat));
} | java |
private static void insertElement(Document pDocument, String pName, Object pValue, String pFormat) {
// Get names of all elements we need
String[] names = StringUtil.toStringArray(pName, ".");
// Get value formatted as string
String value = null;
if (pValue != null) {
// ---
if (pValue instanceof Date) {
// Special threatment of Date
if (pFormat != null) {
value = new SimpleDateFormat(pFormat).format(pValue);
}
else {
value = sDefaultFormat.format(pValue);
}
}
else {
value = String.valueOf(pValue);
}
// ---
}
// Loop through document from root, and insert parents as needed
Element element = pDocument.getDocumentElement();
for (int i = 0; i < names.length; i++) {
boolean found = false;
// Get children
NodeList children = element.getElementsByTagName(PROPERTY);
Element child = null;
// Search for correct name
for (int j = 0; j < children.getLength(); j++) {
child = (Element) children.item(j);
if (names[i].equals(child.getAttribute(PROPERTY_NAME))) {
// Found
found = true;
element = child;
break; // Next name
}
}
// Test if the node was not found, otherwise we need to insert
if (!found) {
// Not found
child = pDocument.createElement(PROPERTY);
child.setAttribute(PROPERTY_NAME, names[i]);
// Insert it
element.appendChild(child);
element = child;
}
// If it's the destination node, set the value
if ((i + 1) == names.length) {
// If the value string contains special data,
// use a CDATA block instead of the "value" attribute
if (StringUtil.contains(value, "\n") || StringUtil.contains(value, "\t") || StringUtil.contains(value, "\"")
|| StringUtil.contains(value, "&") || StringUtil.contains(value, "<") || StringUtil.contains(value, ">")) {
// Create value element
Element valueElement = pDocument.createElement(PROPERTY_VALUE);
// Set type attribute
String className = pValue.getClass().getName();
className = StringUtil.replace(className, "java.lang.", "");
if (!DEFAULT_TYPE.equals(className)) {
valueElement.setAttribute(PROPERTY_TYPE, className);
}
// Set format attribute
if (pFormat != null) {
valueElement.setAttribute(PROPERTY_FORMAT, pFormat);
}
// Crate cdata section
CDATASection cdata = pDocument.createCDATASection(value);
// Append to document tree
valueElement.appendChild(cdata);
child.appendChild(valueElement);
}
else {
// Just set normal attribute value
child.setAttribute(PROPERTY_VALUE, value);
// Set type attribute
String className = pValue.getClass().getName();
className = StringUtil.replace(className, "java.lang.", "");
if (!DEFAULT_TYPE.equals(className)) {
child.setAttribute(PROPERTY_TYPE, className);
}
// If format is set, store in attribute
if (pFormat != null) {
child.setAttribute(PROPERTY_FORMAT, pFormat);
}
}
}
}
} | java |
public int doEndTag() throws JspException {
// Get body content (trim is CRUCIAL, as some XML parsers are picky...)
String body = bodyContent.getString().trim();
// Do transformation
transform(new StreamSource(new ByteArrayInputStream(body.getBytes())));
return super.doEndTag();
} | java |
public void transform(Source pIn) throws JspException {
try {
// Create transformer
Transformer transformer = TransformerFactory.newInstance()
.newTransformer(getSource(mStylesheetURI));
// Store temporary output in a bytearray, as the transformer will
// usually try to flush the stream (illegal operation from a custom
// tag).
ByteArrayOutputStream os = new ByteArrayOutputStream();
StreamResult out = new StreamResult(os);
// Perform the transformation
transformer.transform(pIn, out);
// Write the result back to the JSP writer
pageContext.getOut().print(os.toString());
}
catch (MalformedURLException murle) {
throw new JspException(murle.getMessage(), murle);
}
catch (IOException ioe) {
throw new JspException(ioe.getMessage(), ioe);
}
catch (TransformerException te) {
throw new JspException("XSLT Trandformation failed: " + te.getMessage(), te);
}
} | java |
private StreamSource getSource(String pURI)
throws IOException, MalformedURLException {
if (pURI != null && pURI.indexOf("://") < 0) {
// If local, get as stream
return new StreamSource(getResourceAsStream(pURI));
}
// ...else, create from URI string
return new StreamSource(pURI);
} | java |
private static BufferedImage createSolid(BufferedImage pOriginal, Color pBackground) {
// Create a temporary image of same dimension and type
BufferedImage solid = new BufferedImage(pOriginal.getColorModel(), pOriginal.copyData(null), pOriginal.isAlphaPremultiplied(), null);
Graphics2D g = solid.createGraphics();
try {
// Clear in background color
g.setColor(pBackground);
g.setComposite(AlphaComposite.DstOver);// Paint "underneath"
g.fillRect(0, 0, pOriginal.getWidth(), pOriginal.getHeight());
}
finally {
g.dispose();
}
return solid;
} | java |
private static void applyAlpha(BufferedImage pImage, BufferedImage pAlpha) {
// Apply alpha as transparency, using threshold of 25%
for (int y = 0; y < pAlpha.getHeight(); y++) {
for (int x = 0; x < pAlpha.getWidth(); x++) {
// Get alpha component of pixel, if less than 25% opaque
// (0x40 = 64 => 25% of 256), the pixel will be transparent
if (((pAlpha.getRGB(x, y) >> 24) & 0xFF) < 0x40) {
pImage.setRGB(x, y, 0x00FFFFFF); // 100% transparent
}
}
}
} | java |
@Override
public byte[] toByteArray() {
byte newBuf[] = new byte[count];
System.arraycopy(buf, 0, newBuf, 0, count);
return newBuf;
} | java |
public void writeHeadersTo(final CacheResponse pResponse) {
String[] headers = getHeaderNames();
for (String header : headers) {
// HACK...
// Strip away internal headers
if (HTTPCache.HEADER_CACHED_TIME.equals(header)) {
continue;
}
// TODO: Replace Last-Modified with X-Cached-At? See CachedEntityImpl
String[] headerValues = getHeaderValues(header);
for (int i = 0; i < headerValues.length; i++) {
String headerValue = headerValues[i];
if (i == 0) {
pResponse.setHeader(header, headerValue);
}
else {
pResponse.addHeader(header, headerValue);
}
}
}
} | java |
public void writeContentsTo(final OutputStream pStream) throws IOException {
if (content == null) {
throw new IOException("Cache is null, no content to write.");
}
content.writeTo(pStream);
} | java |
public String[] getHeaderNames() {
Set<String> headers = this.headers.keySet();
return headers.toArray(new String[headers.size()]);
} | java |
public Path2D path() throws IOException {
List<List<AdobePathSegment>> subPaths = new ArrayList<List<AdobePathSegment>>();
List<AdobePathSegment> currentPath = null;
int currentPathLength = 0;
AdobePathSegment segment;
while ((segment = nextSegment()) != null) {
if (DEBUG) {
System.out.println(segment);
}
if (segment.selector == AdobePathSegment.OPEN_SUBPATH_LENGTH_RECORD || segment.selector == AdobePathSegment.CLOSED_SUBPATH_LENGTH_RECORD) {
if (currentPath != null) {
if (currentPathLength != currentPath.size()) {
throw new IIOException(String.format("Bad path, expected %d segments, found only %d", currentPathLength, currentPath.size()));
}
subPaths.add(currentPath);
}
currentPath = new ArrayList<AdobePathSegment>(segment.length);
currentPathLength = segment.length;
}
else if (segment.selector == AdobePathSegment.OPEN_SUBPATH_BEZIER_LINKED
|| segment.selector == AdobePathSegment.OPEN_SUBPATH_BEZIER_UNLINKED
|| segment.selector == AdobePathSegment.CLOSED_SUBPATH_BEZIER_LINKED
|| segment.selector == AdobePathSegment.CLOSED_SUBPATH_BEZIER_UNLINKED) {
if (currentPath == null) {
throw new IIOException("Bad path, missing subpath length record");
}
if (currentPath.size() >= currentPathLength) {
throw new IIOException(String.format("Bad path, expected %d segments, found%d", currentPathLength, currentPath.size()));
}
currentPath.add(segment);
}
}
// now add the last one
if (currentPath != null) {
if (currentPathLength != currentPath.size()) {
throw new IIOException(String.format("Bad path, expected %d segments, found only %d", currentPathLength, currentPath.size()));
}
subPaths.add(currentPath);
}
// now we have collected the PathPoints now create a Shape.
return pathToShape(subPaths);
} | java |
private int getFontStyle(String pStyle) {
if (pStyle == null || StringUtil.containsIgnoreCase(pStyle, FONT_STYLE_PLAIN)) {
return Font.PLAIN;
}
// Try to find bold/italic
int style = Font.PLAIN;
if (StringUtil.containsIgnoreCase(pStyle, FONT_STYLE_BOLD)) {
style |= Font.BOLD;
}
if (StringUtil.containsIgnoreCase(pStyle, FONT_STYLE_ITALIC)) {
style |= Font.ITALIC;
}
return style;
} | java |
private double getAngle(ServletRequest pRequest) {
// Get angle
double angle = ServletUtil.getDoubleParameter(pRequest, PARAM_TEXT_ROTATION, 0.0);
// Convert to radians, if needed
String units = pRequest.getParameter(PARAM_TEXT_ROTATION_UNITS);
if (!StringUtil.isEmpty(units) && ROTATION_DEGREES.equalsIgnoreCase(units)) {
angle = Math.toRadians(angle);
}
return angle;
} | java |
public final String getName() {
switch (type) {
case ServletConfig:
return servletConfig.getServletName();
case FilterConfig:
return filterConfig.getFilterName();
case ServletContext:
return servletContext.getServletContextName();
default:
throw new IllegalStateException();
}
} | java |
public final ServletContext getServletContext() {
switch (type) {
case ServletConfig:
return servletConfig.getServletContext();
case FilterConfig:
return filterConfig.getServletContext();
case ServletContext:
return servletContext;
default:
throw new IllegalStateException();
}
} | java |
protected int fill() throws IOException {
buffer.clear();
int read = decoder.decode(in, buffer);
// TODO: Enforce this in test case, leave here to aid debugging
if (read > buffer.capacity()) {
throw new AssertionError(
String.format(
"Decode beyond buffer (%d): %d (using %s decoder)",
buffer.capacity(), read, decoder.getClass().getName()
)
);
}
buffer.flip();
if (read == 0) {
return -1;
}
return read;
} | java |
public void logDebug(String message, Exception exception) {
if (!(logDebug || globalLog.logDebug))
return;
if (debugLog != null)
log(debugLog, "DEBUG", owner, message, exception);
else
log(globalLog.debugLog, "DEBUG", owner, message, exception);
} | java |
public void logWarning(String message, Exception exception) {
if (!(logWarning || globalLog.logWarning))
return;
if (warningLog != null)
log(warningLog, "WARNING", owner, message, exception);
else
log(globalLog.warningLog, "WARNING", owner, message, exception);
} | java |
public void logError(String message, Exception exception) {
if (!(logError || globalLog.logError))
return;
if (errorLog != null)
log(errorLog, "ERROR", owner, message, exception);
else
log(globalLog.errorLog, "ERROR", owner, message, exception);
} | java |
public void logInfo(String message, Exception exception) {
if (!(logInfo || globalLog.logInfo))
return;
if (infoLog != null)
log(infoLog, "INFO", owner, message, exception);
else
log(globalLog.infoLog, "INFO", owner, message, exception);
} | java |
private static OutputStream getStream(String name) throws IOException {
OutputStream os = null;
synchronized (streamCache) {
if ((os = (OutputStream) streamCache.get(name)) != null)
return os;
os = new FileOutputStream(name, true);
streamCache.put(name, os);
}
return os;
} | java |
private static void log(PrintStream ps, String header,
String owner, String message, Exception ex) {
// Only allow one instance to print to the given stream.
synchronized (ps) {
// Create output stream for logging
LogStream logStream = new LogStream(ps);
logStream.time = new Date(System.currentTimeMillis());
logStream.header = header;
logStream.owner = owner;
if (message != null)
logStream.println(message);
if (ex != null) {
logStream.println(ex.getMessage());
ex.printStackTrace(logStream);
}
}
} | java |
public final Point getHotSpot(final int pImageIndex) throws IOException {
DirectoryEntry.CUREntry entry = (DirectoryEntry.CUREntry) getEntry(pImageIndex);
return entry.getHotspot();
} | java |
public Object toObject(String pString, Class pType, String pFormat)
throws ConversionException {
if (StringUtil.isEmpty(pString))
return null;
TimeFormat format;
try {
if (pFormat == null) {
// Use system default format
format = TimeFormat.getInstance();
}
else {
// Get format from cache
format = getTimeFormat(pFormat);
}
return format.parse(pString);
}
catch (RuntimeException rte) {
throw new ConversionException(rte);
}
} | java |
static Entry readEntry(final DataInput pInput) throws IOException {
Entry p = new Entry();
p.read(pInput);
return p;
} | java |
private void read(final DataInput pInput) throws IOException {
byte[] bytes = new byte[64];
pInput.readFully(bytes);
// NOTE: Length is in bytes, including the null-terminator...
int nameLength = pInput.readShort();
name = new String(bytes, 0, nameLength - 2, Charset.forName("UTF-16LE"));
// System.out.println("name: " + name);
type = pInput.readByte();
// System.out.println("type: " + type);
nodeColor = pInput.readByte();
// System.out.println("nodeColor: " + nodeColor);
prevDId = pInput.readInt();
// System.out.println("prevDId: " + prevDId);
nextDId = pInput.readInt();
// System.out.println("nextDId: " + nextDId);
rootNodeDId = pInput.readInt();
// System.out.println("rootNodeDId: " + rootNodeDId);
// UID (16) + user flags (4), ignored
if (pInput.skipBytes(20) != 20) {
throw new CorruptDocumentException();
}
createdTimestamp = CompoundDocument.toJavaTimeInMillis(pInput.readLong());
modifiedTimestamp = CompoundDocument.toJavaTimeInMillis(pInput.readLong());
startSId = pInput.readInt();
// System.out.println("startSId: " + startSId);
streamSize = pInput.readInt();
// System.out.println("streamSize: " + streamSize);
// Reserved
pInput.readInt();
} | java |
public static Path2D readPath(final ImageInputStream stream) throws IOException {
notNull(stream, "stream");
int magic = readMagic(stream);
if (magic == PSD.RESOURCE_TYPE) {
// This is a PSD Image Resource Block, we can parse directly
return buildPathFromPhotoshopResources(stream);
}
else if (magic == PSD.SIGNATURE_8BPS) {
// PSD version
// 4 byte magic, 2 byte version, 6 bytes reserved, 2 byte channels,
// 4 byte height, 4 byte width, 2 byte bit depth, 2 byte mode
stream.skipBytes(26);
// 4 byte color mode data length + n byte color mode data
long colorModeLen = stream.readUnsignedInt();
stream.skipBytes(colorModeLen);
// 4 byte image resources length
long imageResourcesLen = stream.readUnsignedInt();
// Image resources
return buildPathFromPhotoshopResources(new SubImageInputStream(stream, imageResourcesLen));
}
else if (magic >>> 16 == JPEG.SOI && (magic & 0xff00) == 0xff00) {
// JPEG version
Map<Integer, java.util.List<String>> segmentIdentifiers = new LinkedHashMap<>();
segmentIdentifiers.put(JPEG.APP13, singletonList("Photoshop 3.0"));
List<JPEGSegment> photoshop = JPEGSegmentUtil.readSegments(stream, segmentIdentifiers);
if (!photoshop.isEmpty()) {
return buildPathFromPhotoshopResources(new MemoryCacheImageInputStream(photoshop.get(0).data()));
}
}
else if (magic >>> 16 == TIFF.BYTE_ORDER_MARK_BIG_ENDIAN && (magic & 0xffff) == TIFF.TIFF_MAGIC
|| magic >>> 16 == TIFF.BYTE_ORDER_MARK_LITTLE_ENDIAN && (magic & 0xffff) == TIFF.TIFF_MAGIC << 8) {
// TIFF version
CompoundDirectory IFDs = (CompoundDirectory) new TIFFReader().read(stream);
Directory directory = IFDs.getDirectory(0);
Entry photoshop = directory.getEntryById(TIFF.TAG_PHOTOSHOP);
if (photoshop != null) {
return buildPathFromPhotoshopResources(new ByteArrayImageInputStream((byte[]) photoshop.getValue()));
}
}
// Unknown file format, or no path found
return null;
} | java |
public static BufferedImage applyClippingPath(final Shape clip, final BufferedImage image) {
return applyClippingPath(clip, notNull(image, "image"), new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB));
} | java |
public static BufferedImage readClipped(final ImageInputStream stream) throws IOException {
Shape clip = readPath(stream);
stream.seek(0);
BufferedImage image = ImageIO.read(stream);
if (clip == null) {
return image;
}
return applyClippingPath(clip, image);
} | java |
protected void service(HttpServletRequest pRequest, HttpServletResponse pResponse) throws ServletException, IOException {
// Sanity check configuration
if (remoteServer == null) {
log(MESSAGE_REMOTE_SERVER_NOT_CONFIGURED);
pResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
MESSAGE_REMOTE_SERVER_NOT_CONFIGURED);
return;
}
HttpURLConnection remoteConnection = null;
try {
// Recreate request URI for remote request
String requestURI = createRemoteRequestURI(pRequest);
URL remoteURL = new URL(pRequest.getScheme(), remoteServer, remotePort, requestURI);
// Get connection, with method from original request
// NOTE: The actual connection is not done before we ask for streams...
// NOTE: The HttpURLConnection is supposed to handle multiple
// requests to the same server internally
String method = pRequest.getMethod();
remoteConnection = (HttpURLConnection) remoteURL.openConnection();
remoteConnection.setRequestMethod(method);
// Copy header fields
copyHeadersFromClient(pRequest, remoteConnection);
// Do proxy specifc stuff?
// TODO: Read up the specs from RFC 2616 (HTTP) on proxy behaviour
// TODO: RFC 2616 says "[a] proxy server MUST NOT establish an HTTP/1.1
// persistent connection with an HTTP/1.0 client"
// Copy message body from client to remote server
copyBodyFromClient(pRequest, remoteConnection);
// Set response status code from remote server to client
int responseCode = remoteConnection.getResponseCode();
pResponse.setStatus(responseCode);
//System.out.println("Response is: " + responseCode + " " + remoteConnection.getResponseMessage());
// Copy header fields back
copyHeadersToClient(remoteConnection, pResponse);
// More proxy specific stuff?
// Copy message body from remote server to client
copyBodyToClient(remoteConnection, pResponse);
}
catch (ConnectException e) {
// In case we could not connecto to the remote server
log("Could not connect to remote server.", e);
pResponse.sendError(HttpServletResponse.SC_BAD_GATEWAY, e.getMessage());
}
finally {
// Disconnect from server
// TODO: Should we actually do this?
if (remoteConnection != null) {
remoteConnection.disconnect();
}
}
} | java |
private String createRemoteRequestURI(HttpServletRequest pRequest) {
StringBuilder requestURI = new StringBuilder(remotePath);
requestURI.append(pRequest.getPathInfo());
if (!StringUtil.isEmpty(pRequest.getQueryString())) {
requestURI.append("?");
requestURI.append(pRequest.getQueryString());
}
return requestURI.toString();
} | java |
public void setExpiryTime(long pExpiryTime) {
long oldEexpiryTime = expiryTime;
expiryTime = pExpiryTime;
if (expiryTime < oldEexpiryTime) {
// Expire now
nextExpiryTime = 0;
removeExpiredEntries();
}
} | java |
private synchronized void removeExpiredEntriesSynced(long pTime) {
if (pTime > nextExpiryTime) {
////
long next = Long.MAX_VALUE;
nextExpiryTime = next; // Avoid multiple runs...
for (Iterator<Entry<K, V>> iterator = new EntryIterator(); iterator.hasNext();) {
TimedEntry<K, V> entry = (TimedEntry<K, V>) iterator.next();
////
long expires = entry.expires();
if (expires < next) {
next = expires;
}
////
}
////
nextExpiryTime = next;
}
} | java |
static void bitRotateCW(final byte[] pSrc, int pSrcPos, int pSrcStep,
final byte[] pDst, int pDstPos, int pDstStep) {
int idx = pSrcPos;
int lonyb;
int hinyb;
long lo = 0;
long hi = 0;
for (int i = 0; i < 8; i++) {
lonyb = pSrc[idx] & 0xF;
hinyb = (pSrc[idx] >> 4) & 0xF;
lo |= RTABLE[i][lonyb];
hi |= RTABLE[i][hinyb];
idx += pSrcStep;
}
idx = pDstPos;
pDst[idx] = (byte)((hi >> 24) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)((hi >> 16) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)((hi >> 8) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)(hi & 0xFF);
idx += pDstStep;
}
}
}
if (idx < pDst.length) {
pDst[idx] = (byte)((lo >> 24) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)((lo >> 16) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)((lo >> 8) & 0xFF);
idx += pDstStep;
if (idx < pDst.length) {
pDst[idx] = (byte)(lo & 0xFF);
}
}
}
}
} | java |
public static void readPixels(DataInput in, float[] data, int numpixels) throws IOException {
byte[] rgbe = new byte[4];
float[] rgb = new float[3];
int offset = 0;
while (numpixels-- > 0) {
in.readFully(rgbe);
rgbe2float(rgb, rgbe, 0);
data[offset++] = rgb[0];
data[offset++] = rgb[1];
data[offset++] = rgb[2];
}
} | java |
public static void float2rgbe(byte[] rgbe, float red, float green, float blue) {
float v;
int e;
v = red;
if (green > v) {
v = green;
}
if (blue > v) {
v = blue;
}
if (v < 1e-32f) {
rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
}
else {
FracExp fe = frexp(v);
v = (float) (fe.getFraction() * 256.0 / v);
rgbe[0] = (byte) (red * v);
rgbe[1] = (byte) (green * v);
rgbe[2] = (byte) (blue * v);
rgbe[3] = (byte) (fe.getExponent() + 128);
}
} | java |
protected RenderedImage doFilter(BufferedImage pImage, ServletRequest pRequest, ImageServletResponse pResponse) {
// Get crop coordinates
int x = ServletUtil.getIntParameter(pRequest, PARAM_CROP_X, -1);
int y = ServletUtil.getIntParameter(pRequest, PARAM_CROP_Y, -1);
int width = ServletUtil.getIntParameter(pRequest, PARAM_CROP_WIDTH, -1);
int height = ServletUtil.getIntParameter(pRequest, PARAM_CROP_HEIGHT, -1);
boolean uniform =
ServletUtil.getBooleanParameter(pRequest, PARAM_CROP_UNIFORM, false);
int units = getUnits(ServletUtil.getParameter(pRequest, PARAM_CROP_UNITS, null));
// Get crop bounds
Rectangle bounds =
getBounds(x, y, width, height, units, uniform, pImage);
// Return cropped version
return pImage.getSubimage((int) bounds.getX(), (int) bounds.getY(),
(int) bounds.getWidth(),
(int) bounds.getHeight());
//return scaled.getSubimage(x, y, width, height);
} | java |
private static String hashFile(final File file, final int pieceSize)
throws InterruptedException, IOException {
return hashFiles(Collections.singletonList(file), pieceSize);
} | java |
public static PeerMessage parse(ByteBuffer buffer, TorrentInfo torrent)
throws ParseException {
int length = buffer.getInt();
if (length == 0) {
return KeepAliveMessage.parse(buffer, torrent);
} else if (length != buffer.remaining()) {
throw new ParseException("Message size did not match announced " +
"size!", 0);
}
Type type = Type.get(buffer.get());
if (type == null) {
throw new ParseException("Unknown message ID!",
buffer.position() - 1);
}
switch (type) {
case CHOKE:
return ChokeMessage.parse(buffer.slice(), torrent);
case UNCHOKE:
return UnchokeMessage.parse(buffer.slice(), torrent);
case INTERESTED:
return InterestedMessage.parse(buffer.slice(), torrent);
case NOT_INTERESTED:
return NotInterestedMessage.parse(buffer.slice(), torrent);
case HAVE:
return HaveMessage.parse(buffer.slice(), torrent);
case BITFIELD:
return BitfieldMessage.parse(buffer.slice(), torrent);
case REQUEST:
return RequestMessage.parse(buffer.slice(), torrent);
case PIECE:
return PieceMessage.parse(buffer.slice(), torrent);
case CANCEL:
return CancelMessage.parse(buffer.slice(), torrent);
default:
throw new IllegalStateException("Message type should have " +
"been properly defined by now.");
}
} | java |
private void serveError(Status status, String error, RequestHandler requestHandler) throws IOException {
this.serveError(status, HTTPTrackerErrorMessage.craft(error), requestHandler);
} | java |
private void serveError(Status status, ErrorMessage.FailureReason reason, RequestHandler requestHandler) throws IOException {
this.serveError(status, reason.getMessage(), requestHandler);
} | java |
protected String formatAnnounceEvent(
AnnounceRequestMessage.RequestEvent event) {
return AnnounceRequestMessage.RequestEvent.NONE.equals(event)
? ""
: String.format(" %s", event.name());
} | java |
protected void handleTrackerAnnounceResponse(TrackerMessage message,
boolean inhibitEvents, String hexInfoHash) throws AnnounceException {
if (message instanceof ErrorMessage) {
ErrorMessage error = (ErrorMessage) message;
throw new AnnounceException(error.getReason());
}
if (!(message instanceof AnnounceResponseMessage)) {
throw new AnnounceException("Unexpected tracker message type " +
message.getType().name() + "!");
}
AnnounceResponseMessage response =
(AnnounceResponseMessage) message;
this.fireAnnounceResponseEvent(
response.getComplete(),
response.getIncomplete(),
response.getInterval(),
hexInfoHash);
if (inhibitEvents) {
return;
}
this.fireDiscoveredPeersEvent(
response.getPeers(),
hexInfoHash);
} | java |
protected void fireAnnounceResponseEvent(int complete, int incomplete, int interval, String hexInfoHash) {
for (AnnounceResponseListener listener : this.listeners) {
listener.handleAnnounceResponse(interval, complete, incomplete, hexInfoHash);
}
} | java |
protected void fireDiscoveredPeersEvent(List<Peer> peers, String hexInfoHash) {
for (AnnounceResponseListener listener : this.listeners) {
listener.handleDiscoveredPeers(peers, hexInfoHash);
}
} | java |
@Override
public void finish() throws IOException {
try {
myLock.writeLock().lock();
logger.debug("Closing file channel to " + this.current.getName() +
" (download complete).");
if (this.channel.isOpen()) {
this.channel.force(true);
}
// Nothing more to do if we're already on the target file.
if (this.isFinished()) {
return;
}
try {
FileUtils.deleteQuietly(this.target);
this.raf.close();
FileUtils.moveFile(this.current, this.target);
} catch (Exception ex) {
logger.error("An error occurred while moving file to its final location", ex);
if (this.target.exists()) {
throw new IOException("Was unable to delete existing file " + target.getAbsolutePath(), ex);
}
FileUtils.copyFile(this.current, this.target);
}
this.current = this.target;
FileUtils.deleteQuietly(this.partial);
myIsOpen = false;
logger.debug("Moved torrent data from {} to {}.",
this.partial.getName(),
this.target.getName());
} finally {
myLock.writeLock().unlock();
}
} | java |
public static HTTPAnnounceResponseMessage craft(int interval,
int complete, int incomplete,
List<Peer> peers, String hexInfoHash) throws IOException, UnsupportedEncodingException {
Map<String, BEValue> response = new HashMap<String, BEValue>();
response.put("interval", new BEValue(interval));
response.put("complete", new BEValue(complete));
response.put("incomplete", new BEValue(incomplete));
if (hexInfoHash != null) {
response.put("torrentIdentifier", new BEValue(hexInfoHash));
}
ByteBuffer data = ByteBuffer.allocate(peers.size() * 6);
for (Peer peer : peers) {
byte[] ip = peer.getRawIp();
if (ip == null || ip.length != 4) {
continue;
}
data.put(ip);
data.putShort((short) peer.getPort());
}
response.put("peers", new BEValue(Arrays.copyOf(data.array(), data.position())));
return new HTTPAnnounceResponseMessage(
BEncoder.bencode(response),
interval, complete, incomplete, peers, hexInfoHash);
} | java |
private List<FileOffset> select(long offset, long length) {
if (offset + length > this.size) {
throw new IllegalArgumentException("Buffer overrun (" +
offset + " + " + length + " > " + this.size + ") !");
}
List<FileOffset> selected = new LinkedList<FileOffset>();
long bytes = 0;
for (FileStorage file : this.files) {
if (file.offset() >= offset + length) {
break;
}
if (file.offset() + file.size() < offset) {
continue;
}
long position = offset - file.offset();
position = position > 0 ? position : 0;
long size = Math.min(
file.size() - position,
length - bytes);
selected.add(new FileOffset(file, position, size));
bytes += size;
}
if (selected.size() == 0 || bytes < length) {
throw new IllegalStateException("Buffer underrun (only got " +
bytes + " out of " + length + " byte(s) requested)!");
}
return selected;
} | java |
@Override
protected void handleTrackerAnnounceResponse(TrackerMessage message,
boolean inhibitEvents, String hexInfoHash) throws AnnounceException {
this.validateTrackerResponse(message);
super.handleTrackerAnnounceResponse(message, inhibitEvents, hexInfoHash);
} | java |
@Override
protected void close() {
this.stop = true;
// Close the socket to force blocking operations to return.
if (this.socket != null && !this.socket.isClosed()) {
this.socket.close();
}
} | java |
private void validateTrackerResponse(TrackerMessage message)
throws AnnounceException {
if (message instanceof ErrorMessage) {
throw new AnnounceException(((ErrorMessage) message).getReason());
}
if (message instanceof UDPTrackerMessage &&
(((UDPTrackerMessage) message).getTransactionId() != this.transactionId)) {
throw new AnnounceException("Invalid transaction ID!");
}
} | java |
private void handleTrackerConnectResponse(TrackerMessage message)
throws AnnounceException {
this.validateTrackerResponse(message);
if (!(message instanceof ConnectionResponseMessage)) {
throw new AnnounceException("Unexpected tracker message type " +
message.getType().name() + "!");
}
UDPConnectResponseMessage connectResponse =
(UDPConnectResponseMessage) message;
this.connectionId = connectResponse.getConnectionId();
Calendar now = Calendar.getInstance();
now.add(Calendar.MINUTE, 1);
this.connectionExpiration = now.getTime();
} | java |
private void send(ByteBuffer data) {
try {
this.socket.send(new DatagramPacket(
data.array(),
data.capacity(),
this.address));
} catch (IOException ioe) {
logger.info("Error sending datagram packet to tracker at {}: {}.", this.address, ioe.getMessage());
}
} | java |
private ByteBuffer recv(int attempt)
throws IOException, SocketException, SocketTimeoutException {
int timeout = UDP_BASE_TIMEOUT_SECONDS * (int) Math.pow(2, attempt);
logger.trace("Setting receive timeout to {}s for attempt {}...",
timeout, attempt);
this.socket.setSoTimeout(timeout * 1000);
try {
DatagramPacket p = new DatagramPacket(
new byte[UDP_PACKET_LENGTH],
UDP_PACKET_LENGTH);
this.socket.receive(p);
return ByteBuffer.wrap(p.getData(), 0, p.getLength());
} catch (SocketTimeoutException ste) {
throw ste;
}
} | java |
public String getString(String encoding) throws InvalidBEncodingException {
try {
return new String(this.getBytes(), encoding);
} catch (ClassCastException cce) {
throw new InvalidBEncodingException(cce.toString());
} catch (UnsupportedEncodingException uee) {
throw new InternalError(uee.toString());
}
} | java |
public Number getNumber() throws InvalidBEncodingException {
try {
return (Number) this.value;
} catch (ClassCastException cce) {
throw new InvalidBEncodingException(cce.toString());
}
} | java |
@SuppressWarnings("unchecked")
public List<BEValue> getList() throws InvalidBEncodingException {
if (this.value instanceof ArrayList) {
return (ArrayList<BEValue>) this.value;
} else {
throw new InvalidBEncodingException("Excepted List<BEvalue> !");
}
} | java |
@SuppressWarnings("unchecked")
public Map<String, BEValue> getMap() throws InvalidBEncodingException {
if (this.value instanceof HashMap) {
return (Map<String, BEValue>) this.value;
} else {
throw new InvalidBEncodingException("Expected Map<String, BEValue> !");
}
} | java |
public void start(final boolean startPeerCleaningThread) throws IOException {
logger.info("Starting BitTorrent tracker on {}...",
getAnnounceUrl());
connection = new SocketConnection(new ContainerServer(myTrackerServiceContainer));
List<SocketAddress> tries = new ArrayList<SocketAddress>() {{
try {
add(new InetSocketAddress(InetAddress.getByAddress(new byte[4]), myPort));
} catch (Exception ex) {
}
try {
add(new InetSocketAddress(InetAddress.getLocalHost(), myPort));
} catch (Exception ex) {
}
try {
add(new InetSocketAddress(InetAddress.getByName(new URL(getAnnounceUrl()).getHost()), myPort));
} catch (Exception ex) {
}
}};
boolean started = false;
for (SocketAddress address : tries) {
try {
if ((myBoundAddress = connection.connect(address)) != null) {
logger.info("Started torrent tracker on {}", address);
started = true;
break;
}
} catch (IOException ioe) {
logger.info("Can't start the tracker using address{} : ", address.toString(), ioe.getMessage());
}
}
if (!started) {
logger.error("Cannot start tracker on port {}. Stopping now...", myPort);
stop();
return;
}
if (startPeerCleaningThread) {
if (myPeerCollectorThread == null || !myPeerCollectorThread.isAlive() || myPeerCollectorThread.getState() != Thread.State.NEW) {
myPeerCollectorThread = new PeerCollectorThread(myTorrentsRepository);
}
myPeerCollectorThread.setName("peer-peerCollectorThread:" + myPort);
myPeerCollectorThread.start();
}
} | java |
public void announce(final AnnounceRequestMessage.RequestEvent event,
boolean inhibitEvents, final AnnounceableInformation torrentInfo, final List<Peer> adresses) throws AnnounceException {
logAnnounceRequest(event, torrentInfo);
final List<HTTPTrackerMessage> trackerResponses = new ArrayList<HTTPTrackerMessage>();
for (final Peer address : adresses) {
final URL target = encodeAnnounceToURL(event, torrentInfo, address);
try {
sendAnnounce(target, "GET", new ResponseParser() {
@Override
public void parse(InputStream inputStream, int responseCode) throws IOException, MessageValidationException {
if (responseCode != 200) {
logger.info("received not http 200 code from tracker for request " + target);
return;
}
trackerResponses.add(HTTPTrackerMessage.parse(inputStream));
}
});
} catch (ConnectException e) {
throw new AnnounceException(e.getMessage(), e);
}
}
// we process only first request:
if (trackerResponses.size() > 0) {
final HTTPTrackerMessage message = trackerResponses.get(0);
this.handleTrackerAnnounceResponse(message, inhibitEvents, torrentInfo.getHexInfoHash());
}
} | java |
private HTTPAnnounceRequestMessage buildAnnounceRequest(
AnnounceRequestMessage.RequestEvent event, AnnounceableInformation torrentInfo, Peer peer)
throws IOException,
MessageValidationException {
// Build announce request message
final long uploaded = torrentInfo.getUploaded();
final long downloaded = torrentInfo.getDownloaded();
final long left = torrentInfo.getLeft();
return HTTPAnnounceRequestMessage.craft(
torrentInfo.getInfoHash(),
peer.getPeerIdArray(),
peer.getPort(),
uploaded,
downloaded,
left,
true, false, event,
peer.getIp(),
AnnounceRequestMessage.DEFAULT_NUM_WANT);
} | java |
public URL buildAnnounceURL(URL trackerAnnounceURL)
throws UnsupportedEncodingException, MalformedURLException {
String base = trackerAnnounceURL.toString();
StringBuilder url = new StringBuilder(base);
url.append(base.contains("?") ? "&" : "?")
.append("info_hash=")
.append(URLEncoder.encode(
new String(this.getInfoHash(), Constants.BYTE_ENCODING),
Constants.BYTE_ENCODING))
.append("&peer_id=")
.append(URLEncoder.encode(
new String(this.getPeerId(), Constants.BYTE_ENCODING),
Constants.BYTE_ENCODING))
.append("&port=").append(this.getPort())
.append("&uploaded=").append(this.getUploaded())
.append("&downloaded=").append(this.getDownloaded())
.append("&left=").append(this.getLeft())
.append("&compact=").append(this.isCompact() ? 1 : 0)
.append("&no_peer_id=").append(this.canOmitPeerId() ? 1 : 0);
if (this.getEvent() != null &&
!RequestEvent.NONE.equals(this.getEvent())) {
url.append("&event=").append(this.getEvent().getEventName());
}
if (this.getIp() != null) {
url.append("&ip=").append(this.getIp());
}
return new URL(url.toString());
} | java |
public synchronized void add(long count) {
this.bytes += count;
if (this.reset == 0) {
this.reset = System.currentTimeMillis();
}
this.last = System.currentTimeMillis();
} | java |
public byte[] getRawIp() {
final InetAddress address = this.address.getAddress();
if (address == null) return null;
return address.getAddress();
} | java |
public static void main(String[] args) {
BasicConfigurator.configure(new ConsoleAppender(
new PatternLayout("%d [%-25t] %-5p: %m%n")));
CmdLineParser parser = new CmdLineParser();
CmdLineParser.Option help = parser.addBooleanOption('h', "help");
CmdLineParser.Option port = parser.addIntegerOption('p', "port");
try {
parser.parse(args);
} catch (CmdLineParser.OptionException oe) {
System.err.println(oe.getMessage());
usage(System.err);
System.exit(1);
}
// Display help and exit if requested
if (Boolean.TRUE.equals((Boolean)parser.getOptionValue(help))) {
usage(System.out);
System.exit(0);
}
Integer portValue = (Integer)parser.getOptionValue(port,
Integer.valueOf(Tracker.DEFAULT_TRACKER_PORT));
String[] otherArgs = parser.getRemainingArgs();
if (otherArgs.length > 1) {
usage(System.err);
System.exit(1);
}
// Get directory from command-line argument or default to current
// directory
String directory = otherArgs.length > 0
? otherArgs[0]
: ".";
FilenameFilter filter = new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".torrent");
}
};
try {
Tracker t = new Tracker(portValue);
File parent = new File(directory);
for (File f : parent.listFiles(filter)) {
logger.info("Loading torrent from " + f.getName());
t.announce(TrackedTorrent.load(f));
}
logger.info("Starting tracker with {} announced torrents...",
t.getTrackedTorrents().size());
t.start(true);
} catch (Exception e) {
logger.error("{}", e.getMessage(), e);
System.exit(2);
}
} | java |
public static void main(String[] args) {
BasicConfigurator.configure(new ConsoleAppender(
new PatternLayout("%d [%-25t] %-5p: %m%n")));
CmdLineParser parser = new CmdLineParser();
CmdLineParser.Option help = parser.addBooleanOption('h', "help");
CmdLineParser.Option output = parser.addStringOption('o', "output");
CmdLineParser.Option iface = parser.addStringOption('i', "iface");
CmdLineParser.Option seedTime = parser.addIntegerOption('s', "seed");
CmdLineParser.Option maxUpload = parser.addDoubleOption('u', "max-upload");
CmdLineParser.Option maxDownload = parser.addDoubleOption('d', "max-download");
try {
parser.parse(args);
} catch (CmdLineParser.OptionException oe) {
System.err.println(oe.getMessage());
usage(System.err);
System.exit(1);
}
// Display help and exit if requested
if (Boolean.TRUE.equals((Boolean) parser.getOptionValue(help))) {
usage(System.out);
System.exit(0);
}
String outputValue = (String) parser.getOptionValue(output,
DEFAULT_OUTPUT_DIRECTORY);
String ifaceValue = (String) parser.getOptionValue(iface);
int seedTimeValue = (Integer) parser.getOptionValue(seedTime, -1);
String[] otherArgs = parser.getRemainingArgs();
if (otherArgs.length != 1) {
usage(System.err);
System.exit(1);
}
SimpleClient client = new SimpleClient();
try {
Inet4Address iPv4Address = getIPv4Address(ifaceValue);
File torrentFile = new File(otherArgs[0]);
File outputFile = new File(outputValue);
client.downloadTorrent(
torrentFile.getAbsolutePath(),
outputFile.getAbsolutePath(),
iPv4Address);
if (seedTimeValue > 0) {
Thread.sleep(seedTimeValue * 1000);
}
} catch (Exception e) {
logger.error("Fatal error: {}", e.getMessage(), e);
System.exit(2);
} finally {
client.stop();
}
} | java |
public Piece getPiece(int index) {
if (this.pieces == null) {
throw new IllegalStateException("Torrent not initialized yet.");
}
if (index >= this.pieces.length) {
throw new IllegalArgumentException("Invalid piece index!");
}
return this.pieces[index];
} | java |
public synchronized void markCompleted(Piece piece) {
if (this.completedPieces.get(piece.getIndex())) {
return;
}
// A completed piece means that's that much data left to download for
// this torrent.
myTorrentStatistic.addLeft(-piece.size());
this.completedPieces.set(piece.getIndex());
if (completedPieces.cardinality() == getPiecesCount()) {
logger.info("all pieces are received for torrent {}. Validating...", this);
}
} | java |
public void start(final URI defaultTrackerURI, final AnnounceResponseListener listener, final Peer[] peers, final int announceInterval) {
myAnnounceInterval = announceInterval;
myPeers.addAll(Arrays.asList(peers));
if (defaultTrackerURI != null) {
try {
myDefaultTracker = myTrackerClientFactory.createTrackerClient(myPeers, defaultTrackerURI);
myDefaultTracker.register(listener);
this.clients.put(defaultTrackerURI.toString(), myDefaultTracker);
} catch (Exception e) {
}
} else {
myDefaultTracker = null;
}
this.stop = false;
this.forceStop = false;
if (this.thread == null || !this.thread.isAlive()) {
this.thread = new Thread(this);
this.thread.setName("torrent tracker announce thread");
this.thread.start();
}
} | java |
public void setAnnounceInterval(int announceInterval) {
if (announceInterval <= 0) {
this.stop(true);
return;
}
if (this.myAnnounceInterval == announceInterval) {
return;
}
logger.trace("Setting announce interval to {}s per tracker request.",
announceInterval);
this.myAnnounceInterval = announceInterval;
} | java |
public TrackerClient getCurrentTrackerClient(AnnounceableInformation torrent) {
final URI uri = getURIForTorrent(torrent);
if (uri == null) return null;
return this.clients.get(uri.toString());
} | java |
public static BEValue bdecode(ByteBuffer data) throws IOException {
return BDecoder.bdecode(new ByteArrayInputStream(data.array()));
} | java |
public BEValue bdecode() throws IOException {
if (this.getNextIndicator() == -1)
return null;
if (this.indicator >= '0' && this.indicator <= '9')
return this.bdecodeBytes();
else if (this.indicator == 'i')
return this.bdecodeNumber();
else if (this.indicator == 'l')
return this.bdecodeList();
else if (this.indicator == 'd')
return this.bdecodeMap();
else
throw new InvalidBEncodingException
("Unknown indicator '" + this.indicator + "'");
} | java |
public BEValue bdecodeBytes() throws IOException {
int c = this.getNextIndicator();
int num = c - '0';
if (num < 0 || num > 9)
throw new InvalidBEncodingException("Number expected, not '"
+ (char) c + "'");
this.indicator = 0;
c = this.read();
int i = c - '0';
while (i >= 0 && i <= 9) {
// This can overflow!
num = num * 10 + i;
c = this.read();
i = c - '0';
}
if (c != ':') {
throw new InvalidBEncodingException("Colon expected, not '" +
(char) c + "'");
}
return new BEValue(read(num));
} | java |
public BEValue bdecodeNumber() throws IOException {
int c = this.getNextIndicator();
if (c != 'i') {
throw new InvalidBEncodingException("Expected 'i', not '" +
(char) c + "'");
}
this.indicator = 0;
c = this.read();
if (c == '0') {
c = this.read();
if (c == 'e')
return new BEValue(BigInteger.ZERO);
else
throw new InvalidBEncodingException("'e' expected after zero," +
" not '" + (char) c + "'");
}
// We don't support more the 255 char big integers
char[] chars = new char[256];
int off = 0;
if (c == '-') {
c = this.read();
if (c == '0')
throw new InvalidBEncodingException("Negative zero not allowed");
chars[off] = '-';
off++;
}
if (c < '1' || c > '9')
throw new InvalidBEncodingException("Invalid Integer start '"
+ (char) c + "'");
chars[off] = (char) c;
off++;
c = this.read();
int i = c - '0';
while (i >= 0 && i <= 9) {
chars[off] = (char) c;
off++;
c = read();
i = c - '0';
}
if (c != 'e')
throw new InvalidBEncodingException("Integer should end with 'e'");
String s = new String(chars, 0, off);
return new BEValue(new BigInteger(s));
} | java |
public BEValue bdecodeList() throws IOException {
int c = this.getNextIndicator();
if (c != 'l') {
throw new InvalidBEncodingException("Expected 'l', not '" +
(char) c + "'");
}
this.indicator = 0;
List<BEValue> result = new ArrayList<BEValue>();
c = this.getNextIndicator();
while (c != 'e') {
result.add(this.bdecode());
c = this.getNextIndicator();
}
this.indicator = 0;
return new BEValue(result);
} | java |
public boolean validate(SharedTorrent torrent, Piece piece) throws IOException {
logger.trace("Validating {}...", this);
// TODO: remove cast to int when large ByteBuffer support is
// implemented in Java.
byte[] pieceBytes = data.array();
final byte[] calculatedHash = TorrentUtils.calculateSha1Hash(pieceBytes);
this.valid = Arrays.equals(calculatedHash, this.hash);
logger.trace("validating result of piece {} is {}", this.index, this.valid);
return this.isValid();
} | java |
private ByteBuffer _read(long offset, long length, ByteBuffer buffer) throws IOException {
if (offset + length > this.length) {
throw new IllegalArgumentException("Piece#" + this.index +
" overrun (" + offset + " + " + length + " > " +
this.length + ") !");
}
// TODO: remove cast to int when large ByteBuffer support is
// implemented in Java.
int position = buffer.position();
byte[] bytes = this.pieceStorage.readPiecePart(this.index, (int)offset, (int)length);
buffer.put(bytes);
buffer.rewind();
buffer.limit(bytes.length + position);
return buffer;
} | java |
public ByteBuffer read(long offset, int length, ByteBuffer block)
throws IllegalArgumentException, IllegalStateException, IOException {
if (!this.valid) {
throw new IllegalStateException("Attempting to read an " +
"known-to-be invalid piece!");
}
return this._read(offset, length, block);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.