Almighty Bus Error

Snippet.Java: Using FilenameFilter

2009-12-15T10:47:00+00:00

To use a FilenameFilter it is needed to implement a method accept which has as arguments the directory where the file exists and the name of the file. It is normally used in conjuction with the list method of the File object.

The following example prints all the files with extension “jpg” in a certain directory:

public static void main(String[] args) {
    FilenameFilter filter = new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
            return name.endsWith(".jpg");
        }
    };

    for(String c : args) {
        File dir = new File(c);

        if(dir.isDirectory()) {
            System.out.println("Directory: " + c);
            for(String curr : dir.list(filter))
                System.out.println(curr);
        }
    }
}

More information can be found here.

Thank you for reading!

Drawing Splines in openGL

2009-12-04T19:04:00+00:00

This article will cover the basics of drawing bezier curves in openGL and how to convert from other curves to Bezier, such as Bspline and Catmull-Rom curves.

Declaring control Points

The way to declare a list of control points for openGL usage is an one dimensional matrix. Since a curve segment only has in account 4 control points:

cntlPoints[]

p0x	p0y	p0z
p1x	p1y	p1z
p2x	p2y	p2z
p3x	p3y	p3z

A Bezier curve only needs the last point of the previous curve to be continuous. Catmull-Rom and Bspline need to know the last 3 points from the previous curve to be continuous.

In the case you have more than 4 points, lets say 7, you would draw 2 curves from p0 to p3 and p3 to p6 in case of a Bezier curve and 5 curves in Catmull-Rom and Bspline going from p0 to p3, p1 to p4, p2 to p5 and p3 to p6 for them to become continous.

Drawing a Bezier curve in openGL

mBezier[]

-1	-3	3	1
3	-6	3	0
-3	3	0	0
1	0	0	0

OpenGL has the ability to draw Bezier curves almost directly using the map function but for completeness sake the matrix for a bezier curve is the following:

The following code in JOGL will draw a Bezier line using the map procedure:

public void drawLine(GL gl, double[] controlPoints) {
	DoubleBuffer ctrlPointBuffer = BufferUtil.newDoubleBuffer(3*controlPoints.length);

	for(int i = 0; i < controlPoints.length; i++)
		ctrlPointBuffer.put(controlPoints[i]);
	ctrlPointBuffer.rewind();

	gl.glMap1d(GL.GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, ctrlPointBuffer);

	gl.glEnable(GL.GL_MAP1_VERTEX_3);
	gl.glBegin(GL.GL_LINE_STRIP);
	for (int i = 0; i <= 30; i++) {
		gl.glEvalCoord1f(i / 30.0f);
	}
	gl.glEnd();
	gl.glFlush();
}

Converting other curves to Bezier

To convert the control points of another type of curve to a Bezier control points you need to:

mCustom * mInverseBezier * customCntlPoints = bezierCntlPoints

mBezier[]

^-1

0	0	0	1
0	0	1/3	1
0	1/3	2/3	1
1	1	1	1

The inverse of the Bezier matrix used for the conversion of the control points is:

Example of a conversion from Catmull-Rom to Bezier

-1/2	3/2	-3/2	1/2
1	-5/2	2	-1/2
-1/2	0	1/2	0
0	1	0	0

0	0	0	1
0	0	1/3	1
0	1/3	2/3	1
1	1	1	1

p0x	p0y	p0z
p1x	p1y	p1z
p2x	p2y	p2z
p3x	p3y	p3z

bezierCntlPoints[]

Example of a conversion from B-Spline to Bezier

-1/6	1/2	-1/2	1/6
1/2	-1	1/2	0
-1/2	0	1/2	0
1/6	4/6	1/6	0

0	0	0	1
0	0	1/3	1
0	1/3	2/3	1
1	1	1	1

p0x	p0y	p0z
p1x	p1y	p1z
p2x	p2y	p2z
p3x	p3y	p3z

bezierCntlPoints[]

That was it, thank you for reading.

Comments are welcome!

Note: I used Matrices in HTML to present the matrices in this post. It uses css and tables to present them correctly.

LaTex: Using Tables

2009-11-26T11:29:00+00:00

To create a table in LaTex you can just use a tabular block, or use a tabular block and a table wrapper block.

The table wrapper is used for positioning and additional presentation.

Table

\begin{table}[h,t,b,p]

Where each optional means:

‘h’ → “here”. Will appear where the table is declared.
‘t’/‘b’ → “top”/“bottom”. Will appear at the top/bottom of the page where it is declared.
‘p’ → “page” of floats. Will group all the table in one page.

A caption can be added to the table by doing:

\caption{Text}

Tabular

\begin{tabular}{width}{cols}

‘width’ is the fixed width of the table.
‘cols’ define the way columns are presented.

Defining a tabular’s presentation

Column presentation

{|l|c|r|}

‘l’/‘r’ means the cell’s content will be aligned to the left/right.
‘c’ will center the cells’s content.
‘|’ will insert an column seperator. ‘||’ will use a double seperation between two columns.

Line presentation

‘&’ marks the end of a cell and the placeholder of the seperator of a column.
‘\hline’ draws an horizontal line to seperate two rows. ‘\hline\hline’ will use a double seperation between two rows.
‘\\’ marks the end of a row.

Example

Is the result of:

\begin{table}[h]
\begin{tabular}{|l|c|r|}
    \hline
    Column 1 With long title & Column2 looooooong & Column3 longlong \\
    \hline
    Value1/1 & Value 1/2 & Value 1/3 \\
    \hline
    \hline
    Value2/2 & Value 2/2 & Value 2/3 \\
    \hline
\end{tabular}
\caption{Alot of stuff}
\end{table}

More information about LaTex tables can be found here.

Java: Remote Method Invocation

2009-10-14T23:42:00+01:00

The Java RMI is a way to create distributed services. It is composed of RMIRegistry which is a name registry which saves the resources available (servers) in a JVM. The registry is, however, accessible through different JVM’s when configured.

Since all the invocations are remote, most arguments are passed by value.
The exception is when an object the implements an interface that extends Remote. A server is passed by reference, since its concept requires that the information must to be consistent between all the clients accessing it.

Considering that the server object would be passed by value like any other argument. This means that for the server to be consistent between all clients, it would need for each client to relay the local changes of each individual server to the central server, this creates alot of useless workload since its easier to just change the central server directly, it would save CPU cycles and network traffic on the client side used to calculate the changes and the central server load doesn’t change.

Interface

public interface IStuffServer extends Remote
{
    public void doStuff() throws RemoteException;
}

Class

public class StuffServer extends UnicodeRemoteObject implements IInfoReceiver 
{
    StuffServer() throws RemoteException { super(); }
    public void doStuff() { System.out.println("Stuff done."); }
}

Every method of a class which extends Remote might throw a RemoteException (network connectivity).

Registering a resource

To create a registry there is a static method in the class LocateRegistry named createRegistry which receives an integer that specifies the port in which the registry will listen for requests. For the registry to be able to communicate with other JVM’s, it is needed to enable it by defining a policy.

policy.all

grant {
    permission java.security.AllPermission "", "";
};

Please bear in mind this might be insecure for critical applications.

Creating a “public” registry

System.getProperties().put("java.security.policy", "policy.all");
if (System.getSecurityManager() == null) {
    System.setSecurityManager(new RMISecurityManager());
}
try { // start rmiregistry
    LocateRegistry.createRegistry(1099);
} catch (RemoteException e) 
{   /* registry already created*/   }
InfoServerImpl server = new InfoServerImpl();
Naming.rebind("/StuffServer", server);
System.out.println("StuffServer bound in registry");

After creating the registry, the static class Naming is used to bind a name to the class using the method rebind, which in the example is “/StuffServer”. This name is only known by the registry in the current JVM.

A registry can be accessed by a simple netbios-like link, for example
“//localhost/StuffServer”.

Obtaining Server Reference

To obtain the server object reference the static Naming class is used again, this time with the lookup method.

IInfoServer server = null;
try {
    server = (IInfoServer) Naming.lookup("//localhost/StuffServer");
} catch(RemoteException e) 
    { System.out.println("Server not found"); }

After the server reference is obtained all the interaction to it is the same of a local object, except it might fail/be slower because of network connectivity issues.

server.doStuff();

The previous will print “Stuff done.” at the server’s console.

That was it about Java’s RMI. For more information go here.

Thank you for reading!

FTP in Python

2009-08-25T20:06:00+01:00

In Python, to create and maintain a FTP communication, the ftplib or urllib (explained in a future post) can be used.

Creating a FTP connection

from ftplib import FTP
try:
    conn = FTP('almightybuserror.com')
except:
    print "Could not connect to almightybuserror.com."
    return

Logging in…

For anonymous log in:

try:
    conn.login()
except:
    print "No anonymous connections allowed."
    return

Otherwise:

try:
    conn.login(user, passwd)
    print conn.getwelcome()
except:
    print "Wrong username or password."
    return

Sending commands and handling response.

To send commands (or requests) to the server there is a method for each command which can be consulted here, however I will show an example of an binary file download request.

try:
    conn.cwd('/stuff/more/misc/stuff/')
except:
    print "No such folder!"
    return
file = open('stuff', 'w')
try: # file.write acts as a function pointer
    conn.retrbinary('RETR stuff', file.write) 
except:
    print "Couldn't download stuff..."
finally:
    file.close()

Check downloader.py in github for a more complete example.

HTTP in Python

2009-08-22T17:51:00+01:00

To create and HTTP connection we use the httplib module which provides some simple yet effective methods to create a connection and send requests to an HTTP server. The module urllib can also be used and is easier, does, however only perform GET requests (explained in a future post).

Creating a connection

To create a connection, the method HTTPConnection does the job. For example:

import httplib
try:
    http = httplib.HTTPConnection('almightybuserror.com')
except:
    print 'Could not connect...'
    return

Sending a request

To send a request, a connection object is needed (we’ll use http from the previous example):

http.request("GET", "/")

Getting a response

To obtain a response, the getResponse() method is used. From this method we get a HTTPResponse object.

response = http.getResponse()
if response.status == httplib.OK:
    file = open('example.html', 'w')
    file.write(response.read())
    file.close()
else:
    print 'Error: %s %s' % (response.status, response.reason)
    return

For a more complete example check downloader.py in github.

The Comic Massacre

2009-08-04T15:12:00+01:00

By Shello, original can be found here.

Snippet.Py: Getting an image resolution

2009-08-03T21:49:00+01:00

Using PIL it is possible to get the width and height of a image using the property size.

The following example will take an undefined number of arguments and print all the resolutions:

import Image
import sys
def main():
    argv = sys.argv[1:]
    if (len(argv) == 0):
        print "No file given!"
    else:
        for name in argv:
            img = Image.open(name)
            print name + ": %d %d" % img.size
if __name__ == "__main__":
    main()

Credit for the snippet goes to meqif.
The code can also be found at github.

To the rescue!

2009-06-05T23:05:00+01:00

Source: ~Draken413o

Stop that fridge!

2009-05-31T23:05:00+01:00

Source: digg

The connectionless networking protocol

2009-05-30T18:05:00+01:00

Also known as UDP, like the title suggests, it does not have a logical idea of connection.

The way it communicates is by datagrams (or messages). The protocol is not able assert any type of confirmation at a transport layer level if a message got thru to the destination. A collateral effect of this is that UDP is a very lightweight protocol, perfect for scenarios where the loss of some information does not break the intended application.

In Java, to implement UDP communication it’s mostly used the following two objects from the java.net.* package: DatagramPacket and DatagramSocket.

The DatagramPacket is used to create a datagram that will be received or sent and configure destination/port in the latter:

DatagramPacket packet = new DatagramPacket(
someString.getBytes(), someString.length() );

To configure the destination of the datagram the following methods are used:

packet.setAddress( InetAddress.getByName( someServerName ) );
packet.setPort( port );

InetAddress.getByName is an static method that given a server name like “www.google.com” returns the IP address.

A DatagramPacket can be used to send any type of message that has been converted to an array of byte. There is, however, an UDP protocol 65,507 byte limit to the size of the array.

To extract the information from a received packet the following methods are used:

byte[] info = packet.getData();
int infoLength = packet.getLength();

A DatagramSocket is initialized using the constructor that receives a port which will be used for sending and receiving datagrams:

DatagramSocket socket = new DatagramSocket( port );

The methods used by this object are:

socket.send( DatagramPacket x );
socket.receive( DatagramPacket x );

The receive method is blocking, it will block the current execution flow until it has received a message.
To receive a packet, it doesn’t make sense to configure a destination and a port, only a buffer to where the data will be stored like in the declaration of the packet object.
Since all the complex ( i.e. Object ) argument passing is by reference, the received packet will overwrite all the information in x.

For more information on UDP go here.

Hope this has been useful.

Thank you for reading!

Multicast: An UDP strong point

2009-05-30T18:05:00+01:00

Multicast is a way to distribute UDP messages to multiple hosts in an automated fashion. It works by making every host join a group which is composed of an IP address in the range 224.0.0.0 to 239.255.255.255 and a port. Every message sent to a group will be delivered to every host that has joined it.
Since it can generate alot of traffic, multicast is only used at a LAN or intranet level.

In Java, to use Multicast there is an object named MulticastSocket. It has mostly the same usage as the DatagramSocket but has an joinGroup method and makes the process join a multicast group:

MulticastSocket mso = new MulticastSocket( 9001 );
mso.joinGroup( InetAddress.getByName("224.0.5.8") );

For more information about receiving and sending messages in UDP go here.

I shot the seriff

2009-05-28T17:46:00+01:00

Source: gamebittk.

HTTP Proxy: Implementation

2009-05-27T21:08:00+01:00

Continuing from “Concept Introduction” we will now see how a possible implementation is done.

To start implementing a proxy we must first create a simple server application which accepts a connection from a client to be redirected.

Creating Server

We start by creating a ServerSocket (for more information go here).

doIt( new ServerSocket( serverPort ) );

Now we need to implement the method doIt() which simply uses a non-stopping cycle to take requests.

public static void doIt( ServerSocket server )
{
    for(;;)
    {
        try
        {
            Socket request = server.accept();
            new RequestHandler( request ).start();
        }
        catch( IOException e )
        {   e.printStackTrace(); continue;  }
    }
}

Creating a RequestHandler

The object RequestHandler is the one that actually does all the work for one request. Because of that we thread it (more information here) so that the proxy can handle multiple requests at once. The utility functions used here are located at the end of the post.

The code to convert the request to HTTP/1.0 is as follows:

InputStream srcIs = source.getInputStream();
String req = readLine(srcIs);
Scanner head = new Scanner(req);
String request = head.next();
String[] link = parseUrl(head.next());
if(link[0].compareTo("http") != 0)
    throw new IOException("Incompatible Protocol");

request += String.format(" %s HTTP/1.0\r\n", link[3]);
String[] currentProperty = parseHttpHeader( readLine(srcIs) );
while(currentProperty != null)
{
    if(isBanned(currentProperty))
    {
        currentProperty = parseHttpHeader( readLine(srcIs) );
        continue;
    }
    request += String.format("%s:%s\r\n", currentProperty[0],
                                                    currentProperty[1]);
    currentProperty = parseHttpHeader( readLine(srcIs) );
}
request += "\r\n"; // Add last CRLF

The function isBanned is the filter for properties from HTTP/1.1:

private boolean isBanned(String[] property)
{
    return property[0].compareTo("Connection") == 0 ||
        property[0].compareTo("Keep-Alive") == 0 ||
        property[0].compareTo("Proxy-Connection") == 0;
}

Now that the request is ready, the only thing needed to be done, is to send the request and then dump the whole response from the server to the client.

InetAddress host = InetAddress.getByName(link[1]);
Socket destination = new Socket(host, Integer.parseInt(link[2]) );
OutputStream destOs = destination.getOutputStream();
InputStream destIs = destination.getInputStream();
destOs.write(request.getBytes());
dumpStream(destIs, source.getOutputStream());
destination.close();
source.close();

Note: source is a socket that is passed in the RequestHandler constructor.

Utility Functions

The parseHttpHeader function parses the properties that a normal HTTP request has so we can easily remove the properties that are exclusive to HTTP1.1.

public static String[] parseHttpHeader( String header )
{
    String[] result = new String[2];
    int pos0 = header.indexOf( ':' );
    if( pos0 == -1 )
        return null;
    result[0] = header.substring( 0, pos0 ).trim();
    result[1] = header.substring( pos0 + 1 ).trim();
    return result;
}

The readLine function keeps reading from a InputStream until it reaches a “\r\n”.

public static String readLine( InputStream is ) throws IOException
{
    StringBuffer sb = new StringBuffer();
    int c;
    while( (c = is.read() ) >= 0 ) {
        if( c == '\r' ) continue;
        if( c == '\n' ) break ;
        sb.append( new Character( (char)c ) );
    }
    return sb.toString();
}

The parseUrl function parses a header, for example “http://almightybuserror.com:5000/stuff/here/” will be transformed to:
[“http”, “almightybuserror.com”, “5000”, “/stuff/here/”].

public static String[] parseUrl(String url)
{
    String result[] = new String[4];
    int i = url.indexOf(':');
    result[0] = url.substring(0, i); // Protocol
    result[1] = url.substring(i+3);
    i = result[1].indexOf(':'); // Get possibly a port number
    int j = result[1].indexOf('/');
    // To parse the rest of the request
    result[2] = (i > 0 ? result[1].substring(i+1, j) : "80");
    result[3] = result[1].substring(j); // Request
    result[1] = (i > 0 ? result[1].substring(0, i) :
                                result[1].substring(0, j));
    //Concat so only the host remains
    return result;
}

The dumpStream function will also be used, you can find it here.

Thank you for reading. Comments are welcome!

Note: Credits for the functions readLine and parseHttpHeader go to ASC Department.

Snippet.Cpp: Comparing Types of Classes

2009-05-20T10:53:00+01:00

This snippet shows how to differentiate between two classes that have heritage from the same class.

Using the following classes:

class A {}
class B: public A { B(); }
class C: public A { C(); }

With the following variables:

A a;
A *b = new B();
A *c = new C();
if(typeid(b) == typeid(a))
    cout << "First is true" << endl; // A* != A
if(typeid(*b) == typeid(B))
    cout << "Second is true" << endl; // B = B
if(typeid(*b) == typeid(*c))
    cout << "Third is true" << endl; // B != C
if(typeid(b) == typeid(c))
    cout << "Fourth is true" << endl; // A* = A*

The pointer usage is important when using the typeid() in this situation.

As you might notice you can actually use the class name to compare like in the second example and not just objects.

Note: There is a name() method that can be used to print the class name. You might notice that there sometimes are pseudo-random numbers/letters before the actual name.

Snippet.Java: Dump InputStream → OutputStream

2009-05-19T11:16:00+01:00

This piece of code keeps reading 1024 bytes from the InputStream and writing to the OutStream until the read function returns an error value (-1) which means there is not anything else to read.

protected void dumpStream( InputStream in, OutputStream out )
throws IOException {
	byte[] arr = new byte[1024];
	int n;
	do {
		n = in.read( arr );
		out.write( arr, 0, n );
	} while (n != -1);
}

HTTP Proxy: Concept introduction

2009-05-14T18:50:00+01:00

An HTTP proxy is a program that acts as a seamless server (since the user does not notice its existence under normal circumstances) and forwards HTTP traffic.

A problem for people that are creating a proxy for learning purposes is that most browsers nowadays days use HTTP/1.1 which is far more complex than its HTTP/1.0 counterpart implementation-wise. For this very reason we will convert every HTTP/1.1 requests to HTTP/1.0.

For a browser using HTTP/1.0 to fetch a webpage, it first needs to establish a connection with the webserver and use a “GET” command on the index (or another page if specified). When it finishes receiving and processing that page, the browser identifies every resource the page uses (be it images, scripts or Cascading Style Sheets). For each resource it needs, the browser creates a connection and sends a request. The webserver closes the connection after it finishes sending the resource.

The proxy will work like the following:

A browser using HTTP/1.1 does, however use pipelining and persistent connections, which after requesting and receiving the webpage the server does not close the connection, and can keeps receiving requests from the browser for resources avaiable locally until the client closes the connection (by using the Connection property with keep-alive value).

For the proxy to convert the request headers to HTTP/1.0 it is needed to read and modify them, removing some fields from the HTTP/1.1 request.

For our purposes we will remove “Connection” and the non-obligatory “Keep-Alive” and “Proxy-Connection” properties since they are unique to HTTP/1.1 and change the protocol version from the header. Every line of a HTTP request and response ends using two special characters “\r\n”.

Example:

GET http://almightybuserror.com/ HTTP/1.1
Connection: keep-alive

And this last request gets converted and sent to the server “http://almightybuserror.com” as:

GET / HTTP/1.0

Note: There needs to exist an extra “\r\n” at the end of the request since it is the only way the server involved knows that the request has ended.

Thank for reading. Comments are welcome.

Threading in Java

2009-05-07T21:19:00+01:00

A thread is a lightweight process that will act as the child of the process that created it. If the parent process is interrupted the child will be inherited by the kernel process, however, most of the times when the parent dies and child loses its purpose.
A thread will seemingly run at the same time as the other processes which raises concurrency issues but this won’t be discussed in this article.

Threading in a Java implementation can be made by two ways: extending the Thread object and implementing the Runnable interface.

To create a thread in either way it is needed to implement the run() method. Run will be the entry execution point when a thread is created.

Extending Thread object

public class DummyThreadable extends Thread 
{
    DummyThreadable() { ; } //dummy constructor.
    public void Run()
    {
        //do some threaded stuff.
    }
}

To create a thread and run it use the start method like the following:

new DummyThreadable().start();

Implementing Runnable interface

public class DummyThreadable implements Runnable 
{
    DummyThreadable() { ; } //dummy constructor.
    public void Run()
    {
        //do some threaded stuff.
    }
}

To create a thread using a class that implements Runnable use the following example:

DummyThreadable t = new DummyThreadable();
new Thread(t).start();

A very useful method for thread programing is the sleep method. It receives a time in milliseconds (and optionally nanoseconds). It makes a thread stop its execution flow for the defined time.

long ms = 9001;
int ns = 901;
Thread.sleep(ms, ns);

Thank you for reading!

Snippet.C: Getting the length of an array.

2009-05-03T15:36:00+01:00

The following C macro gets the amount of memory the array uses and divides it by the size of the first position:

#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x)[0])

Credits go to meqif.

Snippet.Py: Showing all the filenames in a directory

2009-04-17T20:26:00+01:00

The following Python code prints the name of the chosen directory and all the files in it and then proceeds to print all the files in the other nested directories one nested directory at a time.
This method is recursive for nested directories.

def print_dir(loc):
    print loc + "\n"
    for root, dirs, files in os.walk(loc):
        for f in files:
           print f + "\n"
        for d in dirs:        
           print_dir(os.path.join(loc, d))
    return

The connection-oriented network protocol

2009-04-12T21:10:00+01:00

The TCP and unlike UDP it does have a connection definition within the protocol based on Acknowledge-type packets.

In TCP every sent information packet needs to be acknowledged by the destination and if it is missing, the packet is resent until there is confirmation thus creating a “connection” between two peers. If a packet is corrupted a request is to the source for a replacement. Because there is a need to acknowledge all sent packets and error correction, TCP becomes bulkier and slower than UDP but extremely reliable.

In Java, to implement TCP communication the following objects from the java.net.* package are used: Socket and ServerSocket. Other needed objects, from the java.io.* package: InputStream and OutputStream.

As you can see in Java there is such a thing as a Server and Client. A ServerSocket can be looked at as a Socket generator. Its accept method accepts an incoming connection from a client creating and returning a Socket object.

How to use a Socket

Socket aSocket = new Socket( server, port );

Reading from the socket

InputStream is = aSocket.getInputStream();
Scanner in = new Scanner( is );
( ... )

For more information on how to use a Scanner please refer to here.

Writing to the socket

OuputStream os = aSocket.getOutputStream();
byte[] message = new String( "Hello World!" ).getBytes();
os.write( message );

Closing a socket

socket.close();

How to use a ServerSocket

ServerSocket server = new ServerSocket( port );
Socket aSocket = server.accept();

The accept method is blocking, it will block the current execution flow. If there is need to process multiple clients at the same time the program must be multithreaded.

As we can observe, opposing UDP, the TCP approach, at least in Java, does not need a crafting of every single packet, there is an abstraction layer that makes it possible to just dump information and let the underlying implementation handle the low-level management.

For more information on TCP go here.

Thank you for reading!

Yes we kern

2009-04-05T19:47:00+01:00

Source: ilovetypography