Связный список. Необходимо создать новый связный список только из положительных элементов

#include <stdio.h>
#include <stdlib.h>
 
typedef struct Node_s{
    Node_s* Next;
    int Value;
 
}Node_t;
 
void newlist(int N, char* fname);
void readList(Node_t* G, char* fname);
void SaveList(Node_t* G, char* fname);
void onlyPositive(Node_t* G, Node_t* Pos);
 
int main(){
    int N=10;
    char *INfname = {"input.txt"};
    char *OUTfname = {"output.txt"};
    newlist(N, INfname);
    Node_t G;
    Node_t Positive;
    readList(&G, INfname);
    SaveList(&G, OUTfname);
    onlyPositive(&G, &Positive);
    
 
    return 0;
}
 
 
void newlist(int N, char* fname){
    FILE* f = fopen(fname,"w");
    int i;
    for(i=0; i<N; i++){
        fprintf(f, "%d\n", rand()-RAND_MAX/2);
    }
}
 
void readList(Node_t* G, char* fname){
    FILE* f = fopen(fname,"r");
    Node_t *list = (Node_t*)malloc(sizeof(Node_t));
    int tmp;
    fscanf(f, "%d\n", &tmp);
    list->Value=tmp;
    list->Next=NULL;
    G=list;
 
    while(!feof(f)){
        list->Next = (Node_t*)malloc(sizeof(Node_t));
        fscanf(f, "%d\n", &tmp);
        list -> Next->Value=tmp;
        list = list->Next;      
    }
 
}
 
void onlyPositive(Node_t* G, Node_t* Pos){
    Node_t* currentG = G;
    Node_t* currentP = Pos;
    while(currentG){   
        if(currentG->Value>0){
            currentP->Value = currentG->Value;
            if(currentG->Next){currentP->Next = (Node_t*)malloc(sizeof(Node_t));}else{currentP->Next=NULL;}
            if(currentP->Next){currentP=currentP->Next;}
        }
        currentG = currentG->Next; 
      
    }
}
 
void SaveList(Node_t* G, char* fname){
    FILE* f = fopen(fname,"w");
    Node_t* current = G;
    while(current) 
    { 
        fprintf(f, "%d\n", current->Value);
        current = current->Next; 
    }  
}

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
typedef struct node_t {
    int value;
    struct node_t* next;
}   TList;
 
//-----------------------------------------------------------------------------
void Push(TList** list, int value) {
    TList* node = malloc(sizeof(TList));
    node->value = value;
    node->next = *list;
    *list = node;
}
//-----------------------------------------------------------------------------
void Write(FILE* f, const TList* list) {
    for (; list; list = list->next) {
        fprintf(f, "%d ", list->value);
    }
}
//-----------------------------------------------------------------------------
TList* Read(FILE* f) {
    TList* list = NULL;
    int value;
 
    while (fscanf(f, "%d", &value) == 1) {
        Push(&list, value);
    }
 
    return list;
}
//-----------------------------------------------------------------------------
TList* OnlyPositive(const TList* list) {
    TList* newList = NULL;
 
    for (; list; list = list->next) {
        if (0 <= list->value) {
            Push(&newList, list->value);
        }
    }
 
    return newList;
}
//-----------------------------------------------------------------------------
 
int main() {
    TList* all, * positive;
    FILE* fin, * fout;
 
    assert((fin = fopen("input.txt", "r")) != NULL);
    assert((fout = fopen("output.txt", "w")) != NULL);
 
    all = Read(fin);
    positive = OnlyPositive(all);
 
    Write(stdout, positive);
    Write(fout, positive);
 
    return 0;
}