I've seen palindrome functions here before, but not recursive ones, and the requirement to allow for nonalpha characters and spaces is different, too. I like it!
As to how to do this: since you are required to make it recursive, it seems there's only one general approach: compare characters at the ends, and if they match, recursively call for a comparison of the string between them.
Design the function to take two arguments:
(1) a pointer to the beginning of the string; and
(2) a pointer to just past the end of the string.
There's a string length function in the standard libraries to help you with (2).
(a) If the beginning-pointer is greater than or equal to the end-pointer, return TRUE. (An empty string counts as a palindrome.)
(b) See if the first character is alpha. If not, return the result of a recursive call, with the first pointer advanced one character.
(c) Move the end-pointer back one and see if it points to an alpha character. If not, return the result of recursive call with the present pointers (the back one having moved).
(d) If you get here, you've got two alpha characters. Compare these characters; if they don't match, return FALSE.
-- Note: It's possible this will compare a middle character to itself. That's a valid case, and the next recursive invocation will find an empty string and return TRUE, as it should.
-- Note: This is where you have to worry about upper- and lower-case characters. At this point, I would perform the comparison by XORing the two together and then disregarding the bit that distinguishes between the lower- and upper-case versions of ASCII letters. That is, the two match if
((*begin_ptr ^ *end_ptr) | 0x20) == 0x20
which means that no bits differ between the two characters, other than perhaps the one that indicates they differ in case.
(e) If the compared characters match, return the result of a recursive call, in which you pass a pointer to the string following the first character compared (which begins the portion for the next comparison), and a pointer to the last character compared (which is just past the end of that portion).
You don't have to use my particular method of making the whole comparison nondestructive of the input, but it makes it easier to print out a final result in a pretty format like this:
Madam, I'm Adam!
is a palindrome.
ABCDEFGHIJHGFEDCBA
is not a palindrome.
The method I've described is just the one that comes naturally to a bit-masher. (I've had a career in data communications programming, much of it in C.)