This is difficult to answer without knowing the level and skills of your students. Without that background information, I couldn't even tell if it is advisable at all to let them loose on any existing project.
In my opinion, before somebody is ready to contribute to any non-trivial open source effort, they should have a solid understanding of data structures and the concept of ADTs and information hiding. Ideally they would have implemented some basic ADTs on their own.
In my experience this is all too often lacking especially when the language used for instructing beginners is C since C doesn't have built-in ADTs nor a standard ADT library and developers are generally expected to be able to either write their own or select a third party library and if necessary customise it to their needs.
I have seen quite a few open source projects written in C where the only data structures used were fixed size arrays and linked lists, where every algorithm was the most naive possible, where the notion of an API was to expose structs and let everybody modify them.
A contributor who is familiar with ADTs will soon run away from such a project in horror. A contributor who is not familiar with ADTs will only learn bad habits there.
If your aim is solely to get your students to learn the use of version control and bugtracking systems, it is perhaps a better idea to assign them an exercise and make them set up a repository at one of those sites that integrate version control, online source code browsing and bugtracking, for example Github, Bitbucket, Google Code etc.
You can then examine the work they did for the assignment and if you find any mistakes you use the bugtracker to file a bug which they then have to deal with accordingly. You can then expand the assignment by filing feature requests again using the bugtracker etc.
Furthermore, sites like Github and Bitbucket have a clone-this-repository feature. This lends itself nicely to teaching collaboration as well. Depending on the skillset of your students you could either pick an existing repository for them to clone and then extend following your assignments, or you could ask them to search a repository (possibly matching certain criteria) and pick one for themselves, then again extend that following your assignments.
There is one more thing that I personally believe should be a pre-requisite for contributing to any non-trivial open source project: understanding design by contract, how to document a function contract, thinking in function contracts, having developed the discipline to never code anything without documenting a function contract first. Unfortunately, too few open source projects use design by contract. Again, a contributor familiar with this practise will soon run away from such a project in horror and one who isn't will only pick up bad habits.
However, you could turn this into an exercise by telling your students to clone an existing repository from say Github or Bitbucket and then assign them the task to fill in the missing function contract documentation. Needless to say that for such an exercise you would first have to have taught them what design by contract is and how to write function contracts.
Once your students have gained the skills I outlined above, I am sure the question of "which open source projects could we contribute to?" will become trivial to answer because at that stage your students will be able to find and choose a suitable project for themselves.
In the meantime, if you feel that your students still need some example code for both ADTs written in C and how to write function contracts, and you don't have any such examples handy, you might want to take a look at my repository at Bitbucket. It has a variety of common ADTs in C and all sources contains function contracts. Feel free to clone any of the repos in there and use them as a base for exercises:
I am sure if you look around there is plenty of suitable material by other authors, too.