Converting quadriladerals in an OBJ file into triangles?

At first, it seemed obvious... Make 2 triangles per face wherever 4 indices were found, right?
Meaning, the following:

v 1.000000 1.000000 0.000000
v -1.000000 1.000000 -0.000000
v 1.000000 -1.000000 0.000000
v -1.000000 -1.000000 -0.000000
f -4 -3 -2 -1

... would, in turn, need to be converted into something like:

v 1.000000 1.000000 0.000000
v -1.000000 1.000000 -0.000000
v 1.000000 -1.000000 0.000000
v -1.000000 -1.000000 -0.000000
f -4 -3 -2
f -2 -3 -1

This particular example, of course, would render correctly.
However, not all cases are as simple as splitting the face into two faces (where the first face contains the first three vertices of the original face, and the second face contains the last 3 vertices, as per the above example). Take the following cube, for example:

v 0.000000 1.000000 1.000000
v 0.000000 0.000000 1.000000
v 1.000000 0.000000 1.000000
v 1.000000 1.000000 1.000000
v 0.000000 1.000000 0.000000
v 0.000000 0.000000 0.000000
v 1.000000 0.000000 0.000000
v 1.000000 1.000000 0.000000
f 1 2 3 4
f 8 7 6 5
f 4 3 7 8
f 5 1 4 8
f 5 6 2 1
f 2 6 7 3

These faces cannot be split the same way in the previous example... So, I would need some way of knowing how to split a quadrilateral face into two triangle faces, whilst using the correct indices for the second face...

How can this be achieved? Please note that I am NOT using the fixed-function pipeline, and therefore, using GL_QUADS is NOT an option. My rendering engine is pretty much stuck on using GL_TRIANGLES only.

If you have 4 indices, e.g.:

0 1 2 3

The division into two triangles would be one with the first 3 indices, and one with the first, third, and fourth. In this example:

0 1 2
0 2 3

Let's try some ASCII art to illustrate this:

3-------2
|      /|
|    /  |
|  /    |
|/      |
0-------1

Here you see 0 1 2 3 as the quad, 0 1 2 as the first triangle (bottom-right), and 0 2 3 as the second triangle (top left).

More generally, for faces with n vertices, you generate triangles:

0 (i) (i + 1)  [for i in 1..(n - 2)]

If you don't insist on separate triangles, you can also use GL_TRIANGLE_FAN primitives, which are still in core OpenGL. That way, you can draw any convex polygon with a triangle fan, using the original sequence of indices. So a triangle fan with vertex sequence 0 1 2 3 describes the quad in this case, and it very easily generalizes to faces with more than 4 vertices.

Edit: Since you still appear to have problems, let's see how this applies to the example in your post. I'll list the original index sequence of the quad for each face, and the index sequence for the two triangles after splitting the quad.

f 1 2 3 4 --> (1 2 3) (1 3 4)
f 8 7 6 5 --> (8 7 6) (8 6 5)
f 4 3 7 8 --> (4 3 7) (4 7 8)
f 5 1 4 8 --> (5 1 4) (5 4 8)
f 5 6 2 1 --> (5 6 2) (5 2 1)
f 2 6 7 3 --> (2 6 7) (2 7 3)

That looks correct to me when I draw the cube. Remember to subtract 1 from the indices for your use, since these are 1-based indices, and you will almost certainly need 0-based indices.

Writing my own obj loader and reading the spec very carefully, the details on the 'f' parameter are very vague, especially seeing some files contain 'f' lines with > 4 arguments on them.

Turns out that these are actually a triangle strip in an odd order. Correct conversion to triangles is as follows (psuedo code):

n = 0;
triangles[n++] = [values[0], values[1], values[2]];
for(i = 3; i < count(values); ++i)
  triangles[n++] = [
    values[i - 3],
    values[i - 1],
    values[i]
  ];

Example: