Q:

Palindromo recursivo C

Minhas funções não estão funcionando corretamente, sempre o programa me fala que não é palíndromo, para qualquer situação. Segue o código: 
#include<stdio.h>
#include<string.h>

int inverte (char *n, int y, int aux) {

     if (y <= aux) return 1;

     else {
         if (n[y] != n[aux]) return 0;

         return inverte(n, y-1, aux+1);
     } 
}

 int palindromo (char *n) {
     int aux1, x = 0;

     aux1 = inverte(n, strlen(n), x);

     if (aux1 == 1) printf("Eh palindromo");

     else printf("Nao eh palindromo");

 }

 int main() {

     char m[30] = {"anna"};

     palindromo(m);

     return 0; 
 }

A:

A resposta da Taisbevalle é linda, porém senti que não tocou onde o Marcelo de Sousa cometeu seu engano.
Strings
Basicamente, o problema não foi no entendimento de recursão, mas na manipulação da string. Em C, uma string é iniciada pelo índice zero e finalizada pelo caracter '\0'. Assim, a palavra de testes de palíndromo anna tem os seguintes caracteres, nas seguintes posições:
[0] -> 'a'
[1] -> 'n'
[2] -> 'n'
[3] -> 'a'
[4] -> '\0'

O quinto caracter é o terminador da string, necessário em C para indicar seu final.
A função strlen conta quantos caracteres há em determinada string.  anna tem claramente 4 caracteres. Então, o retorno de strlen("anna") é 4.
A função inverte, ele recebe 3 parâmetros:

n, que é a string que perguntamos se é palíndromo ou não
y, de cujo nome eu não consigo arrancar um significa, mas que no código é algo como a base para fazer a comparação do lado direito da string
aux, o índice auxiliar que vai sendo percorrido, da esquerda para a direita, para determinar se a string é palíndromo

Na chamada inicial de inverte, são passados os seguintes valores:

n ==> a string em questão
y ==> o tamanho da string passada como n
aux ==> 0, a posição inicial da string

A comparação dentro de inverte ocorre sobre o índice esquerdo (aux) e o índice direito (y) da seguinte maneira:
if (n[y] != n[aux]) return 0;

Voltando ao caso da anna; o tamanho da anna é 4, então o valor inicial de y é 4. No primeiro passo da recursão, os valores sendo comparados são os seguintes:
if (n[4] != n[0]) return 0;

Lembrando-se da decomposição inicial que eu fiz para a palavra anna, na posição 0 temos o caracter 'a', enquanto que na posição 4 temos o caracter '\0'! Então, substituindo pelos caracteres sendo comparados:
if ('\0' != 'a') return 0;

E '\0' é direferente de 'a', portanto ele sairá da função nesse ponto. Sempre.
Quase qualquer que seja a string passada para a função palindromo (que por sua vez chama a função inverte), ela comparará o primeiro caracter dessa string com '\0', o que sempre será distinto; a única string que essa função reconhece corretamente como palíndromo é a string vazia, pois assim a comparação do primeiro caracter (fim de string, '\0') e o fim de string dá igual e inverte detecta corretamente que "" é palíndromo. Então, nosso problema está ou na interpretação do índice y ou no valor inicial de y. Então, fiz duas sugestões de correção para isso.
Note que, nas sugestões, adicionei alguns casos a mais de teste.
Sugestão 1: passar a posição da última letra válida
Nessa sugestão, altero como a função palindromo chama inverte. Aqui, a última posição válida para a palavra anna é 3, pois ela tem comprimento 4 e C começa strings na posição 0:
    #include<stdio.h>
    #include<string.h>

    int inverte (char *n, int y, int aux) {
        if (y <= aux) return 1;
        else {
            if (n[y] != n[aux]) return 0;

            return inverte(n, y-1, aux+1);
        } 
    }

     int palindromo (char *n) {
        int aux1, x = 0;

        aux1 = inverte(n, strlen(n) - 1, x);

        if (aux1 == 1) printf("Eh palindromo\n");
        else printf("Nao eh palindromo\n");

     }

     int main() {
        palindromo("banana");
        palindromo("anna");
        palindromo("ana");
        palindromo("bananab");
        palindromo("aa");
        palindromo("a");

        return 0; 
     }

Vejo no Ideone
Sugestão 2: y é o índice que indica o caracter logo depois do último válido
Nessa sugestão, mudei a interpretação de y: agora, y sempre será o índice depois do último caracter válido. Então, a chamada de palindromo continua idêntica, porém mudei quem estava sendo comparada na comparação de inverte:
#include<stdio.h>
#include<string.h>

int inverte (char *n, int y, int aux) {
    if (y <= aux) return 1;
    else {
        if (n[y - 1] != n[aux]) return 0;

        return inverte(n, y-1, aux+1);
    } 
}

 int palindromo (char *n) {
    int aux1, x = 0;

    aux1 = inverte(n, strlen(n), x);

    if (aux1 == 1) printf("Eh palindromo\n");
    else printf("Nao eh palindromo\n");

 }

 int main() {
    palindromo("banana");
    palindromo("anna");
    palindromo("ana");
    palindromo("bananab");
    palindromo("aa");
    palindromo("a");

    return 0; 
 }

Vejo no Ideone

A:

Seu código está confuso, tem muito if "solto", uma dica é utilizar as chaves {} para separar, na minha opinião fica melhor a visualização.
Como no comentário você disse que está um pouco perdido na recursão, vou te mostrar uma forma de fazer (não é a única). No código abaixo você digita a palavra que você quer e ele retorna se é ou não palíndromo.
#include <stdio.h>
#include <string.h>

// Função recursiva para verificar se a palavra é palíndromo
int palindromo(char palavra[], int tam, int posicao) {

    if (posicao < tam / 2){
        if (palavra[posicao] == palavra[tam - posicao - 1]){
            return 1 * palindromo(palavra, tam, posicao+1);
        }
        else{
            return 0;
        }
    }
    else{
        return 1;
    }
}

int main() {

   char palavra[255];
   int tam;

   printf ("Digite a palavra: \n");   
   gets(palavra); // Ler a palavra digitada pelo usuário

   tam = strlen(palavra); // Tamanho da palavra

   if (palindromo(palavra, tam, 0))
      printf("É palíndromo\n");
   else
      printf("Não é palíndromo\n");

   return 0;
}

Veja funcionando no Ideone.
Usando a função int palindromo (char *n) você pode fazer conforme o código abaixo:
#include <stdio.h>
#include <string.h>

// Função recursiva para verificar se a palavra é palíndromo
int inverte(char *n, int tam, int posicao){

    if (posicao < tam / 2){
        if (n[posicao] == n[tam - posicao - 1]){
            return 1 * inverte(n, tam, posicao+1);
        }
        else{
            return 0;
        }
    }
    else{
        return 1;
    }
}

int palindromo(char *n) { 

    int aux1, x = 0;

    aux1 = inverte(n, strlen(n), x);

    if (aux1 == 1) printf("Eh palindromo");
    else printf("Nao eh palindromo");

}

int main() {

    char m[30] = {"teste"};
    palindromo(m);

    return 0;
}

Só modifiquei a sua função inverte.
Veja no Ideone.

