A singly linked list implementation in C How is this Implementation of a list in C?

Please tell me whether it is good or please mention any problems.
It is a singly linked List and I tried to do it recursively.

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;conio.h&gt;

struct node{
    int value;
    struct node *next;
};

void add(struct node *lst, int num){
    if(lst-&gt;next == NULL){
        lst-&gt;value = num;
        lst-&gt;next = (struct node*)malloc(sizeof(struct node*));
        lst-&gt;next-&gt;next = NULL;
    }else{
        add(lst-&gt;next, num);
    }
}

void print_lst(struct node *lst){
    if(lst-&gt;next == NULL){

    }else{
        printf("\n%d", lst-&gt;value);
        print_lst(lst-&gt;next);
    }
}

int length(struct node *lst){
    if(lst-&gt;next == NULL){
        return 0;
    }else{
        return 1 + length(lst-&gt;next);
    }
}

int get(struct node *lst, int pos){
    if(pos &lt; 0 ||  pos &gt;= length(lst)){
        fprintf(stderr ,"\nIndexOutOfBoundsException\n");
    }else if(pos &gt; 0 &amp;&amp; pos &lt;length(lst)){
        pos += -1;
        get(lst-&gt;next, pos);
    } else if (pos == 0){
        return  lst-&gt;value;
    }
}

int main ( ) {

    struct node lst;
    lst.next = NULL;
    add(&amp;lst, 13);
    add(&amp;lst, 12);
    add(&amp;lst,  1);
    add(&amp;lst, 10);
    add(&amp;lst, 10);
    add(&amp;lst, 4);
    //print_lst(&amp;lst);
    printf("\n%d", get(&amp;lst, 2));
    printf("\n%d", get(&amp;lst, 5));
    printf("\n%d", get(&amp;lst, 13));

    printf("\n\n%d", length(&amp;lst));
    return 0;
}
Do not cast the result of malloc. If your code does #include &lt;stdlib.h&gt;, the cast is redundant. If it does not, the cast just masks the warning, which may lead to hard to find bugs.
Prefer sizeof(object) to sizeof(type). The latter leads to the double maintenance problem, in case the type is changed.
I strongly recommend to have a constructor-like function to create a node:

struct node * create_node(int num)
{
    struct node * node = malloc(sizeof(*node));
    node-&gt;value = num;
    node-&gt;next = NULL;
    return node;
}


It will spare you plenty of trouble when the definition of struct node changes.
You should get a warning that get doesn't always return a value (if you do not, enable all warnings, or change the compiler). It is a very serious warning, and in real life the code with such a problem leads to some dire consequences. You must return get(lst-&gt;next, pos); in a recursive clause.

The fact that your main printed expected values is an unlucky coincidence.

What to return in the IndexOutOfBound situation is a different matter. Consider returning an error code along with the value.
Calling length(lst) at each level of recursion degrades performance to quadratic.
As a side note, rather than testing for position &lt; 0, consider passing a position as some unsigned type. size_t is the most obvious candidate.
Along the same line, a low level utility function such as get should refrain from printing anything.
I strongly advise agains recursion when an iterative solution is immediately available.