I'm assuming you want to do dynamic lighting (rather than, say, baking your own lightmaps).
There are plenty of tutorials out there on dynamic per-pixel lighting using normal maps in OpenGL. I've got some on my website; they're a few years out of date, but might still be useful.
The tutorials there use forward shading, which means that you draw the scene geometry and evaluate all the textures and lighting equation in one pixel shader. If you need multiple lights, you have to re-render the scene geometry multiple times, combining them together with additive blending (you also have to include ambient light somewhere along the line). This is relatively easy and quick to code, but can become too expensive for complex levels with lots of geometry and lights. You'll definitely want to use a culling system to get rid of geometry and lights that aren't needed based on what the camera can see in a given frame.
Forward shading can also become cumbersome if you have many different kinds of materials requiring different shading equations (not just different textures), and many different kinds of lights (point, spot, etc.), because every combination of material type and light type requires its own shader.
In cases where forward shading is too expensive or cumbersome, there is another approach called "deferred shading" that has become very popular recently. You can read all about it online, so I won't explain it in detail here; I'll just say that it can be more efficient if you have highly complex scene geometry and/or large numbers of lights on-screen at once, and it often reduces the number of shaders you have to write. However, it's a more complex system and will be trickier to code, and take longer to implement and debug.
Since you said this is an old game I'd guess forward shading may work well enough for you, as the geometry and lighting are likely not that complex by modern standards. Just be aware that deferred shading is a viable alternative.