Заполнение таблицы(массива структур) - C (СИ)

Формулировка задачи:

Имеется файл такого содержания: root : qwerty: 123 : 465 : Acc. for root : /root : /bin/sh admin: 33fr5: 456: 555: acc. for admin : /usr/home :/ bin/sh User: kg77o: 899: 11: acc. for user: /home: /bin/sh И имеется код:

#include <stdio.h>
#include <stdlib.h>
 
#define MAX_PATH 260
 
void skip_spaces(char file[], char file1[]);
int input(char path[], char home[]);
int main() {
 
    struct ini {
        char login[MAX_PATH];
        char password[MAX_PATH];
        int uid;
        int gid;
        char gecos[MAX_PATH];
        char home[MAX_PATH];
        char shell[MAX_PATH];
        char error[MAX_PATH];
    };
    
    char path[MAX_PATH];
    char home[MAX_PATH];
    char file[MAX_PATH];
    char file1[1024];
    FILE *in;
    char *ptr[512];
    char ch = ':';
    int i,n, b, j,k;
    in = fopen("conf.pasw", "r");
    for(i = 0; !feof(in); i++){
        fscanf(in, "%c", &n);
        file[i] = n;
    }
    file[i]='\0';
    input(path, home);
    skip_spaces(file, file1);
    b = strtok(file1, ch, ptr);
    for(i=0;i<b;i++){
        printf(" %s", ptr[i]);
    }
    k=b/6;
    struct ini table[k];
    for(j=0;j<k;j++){
        for(i=0;i<b;i=i+7){
            strcopy(ptr[i], table[j].login);
            strcopy(ptr[i+1], table[j].password);
            table[j].uid = atoi(ptr[i+2]);
            table[j].gid = atoi(ptr[i+3]);
            strcopy(ptr[i+4], table[j].gecos);
            strcopy(ptr[i+5], table[j].home);
            strcopy(ptr[i+6], table[j].shell);
        }
    }
    printf("\t%s\n", table[0].home);
    return 0;
}
 
void skip_spaces(char file[], char file1[])
{
    
    int i,j;
    for(i = j = 0; file[i] != '\0'; i++){
        if (file[i] != ' '){
            file1[j++] = file[i];
        }
        file1[j] = '\0';
    }
}
int strtok(char path[],char ch,  char *ptr[])
{
    char *suf=path;
    ptr[0]=path;
    int i,j=1;
    while((i=strch(suf, ch))>=0){
        suf[i]='\0';
        suf=suf+i+1;
        ptr[j]=suf;
        j++;
    }
    return j;
}
int strcopy(char path[], char home[])
{       
    int i;
    for(i=0;path[i]!='\0'; i++)
    {
        home[i]=path[i];
    }
    home[i]='\0';
    return 0;
}

Таким способом структура не заполняется, пробовал делать в одном цикле результат тот же Помогите пожалуйста разобраться

Ап чтоле

Решение задачи: «Заполнение таблицы(массива структур)»

textual
                            Листинг программы 
                        

                            #include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_PATH 260
#define BUF_SIZE 1600
 
typedef struct _TIni 
{   char login[MAX_PATH];
    char password[MAX_PATH];
    int uid;
    int gid;
    char gecos[MAX_PATH];
    char home[MAX_PATH];
    char shell[MAX_PATH];
    char error[MAX_PATH];
}   TIni;
 
typedef enum _EError
{   None            = 0x00,
    ErrorLogin      = 0x01,
    ErrorPassword   = 0x02,
    ErrorUid        = 0x04,
    ErrorGid        = 0x08,
    ErrorGecos      = 0x10,
    ErrorHome       = 0x20,
    ErrorShell      = 0x40,
}   EError;
 
/*функции для работы с одной структурой*/
TIni *CreateIni ();                         /*создаем одну запись и заполняем ее значениями по умолчанию: строки - пустая строка, числа - 0*/
void FillIni (TIni *ini, char *source);     /*заполняем запись данными из отфильтрованной строки*/
void PrintIni (TIni *ini);                  /*печатаем запись*/
void DeleteIni (TIni *ini);                 /*освобождаем память от записи*/
 
/*функции для работы с массивом структур*/
TIni **CreateArray (int N);                 /*создаем массив из записей размерностью N*/
void DeleteArray (TIni **arr, int N);       /*освобождаем память от массива*/
 
/*вспомогательные функции*/
void DeleteFirstChar (char *source);                /*удаляем первый символ в строке*/
void ErrorToString(EError error, char *result);     /*преобразуем список ошибок в строку*/
void SkipSpaces (char *source);                     /*фильтруем строку от лишних пробелов*/
void InsertChar (char *source, char c, int pos);    /*вставляем в строку <source> символ <c> на позицию <pos>. Также делает Append*/
void FillEmptyFields (char *source);                /*пустое поле заполняем одним '_'*/
int IsEmpty (char *s);                              /*проверка поля записи на пустоту*/
void CheckTemplate (char *source);                  /*проверка вводной строки на наличие шести ':'*/
 
 
/*=======================================================================функции для работы с одной структурой*/
TIni *CreateIni ()
{   TIni *ini = (TIni*) malloc (sizeof(TIni));
    
    strcpy(ini->login, "\0");
    strcpy(ini->password, "\0");
    ini->uid = 0;
    ini->gid = 0;
    strcpy(ini->gecos, "\0");
    strcpy(ini->home, "\0");
    strcpy(ini->shell, "\0");
    strcpy(ini->error, "_\0");
    
    return ini;
}
 
void FillIni (TIni *ini, char *source)
{   char * word;
    EError err = None;
 
    word = strtok (source,":");
    if (!IsEmpty (word))
        strcpy(ini->login, word);
    else
        err = (EError) ((int)err| (int)ErrorLogin);
 
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        strcpy(ini->password, word);
    else
        err = (EError) ((int)err| (int)ErrorPassword);
 
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        ini->uid = (int) strtol(word, NULL, 10);
    else
        err = (EError) ((int)err| (int)ErrorUid);
 
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        ini->gid = (int) strtol(word, NULL, 10);
    else
        err = (EError) ((int)err| (int)ErrorGid);
    
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        strcpy(ini->gecos, word);
    else
        err = (EError) ((int)err| (int)ErrorGecos);
 
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        strcpy(ini->home, word);
    else
        err = (EError) ((int)err| (int)ErrorHome);
    
    word = strtok (NULL,":");
    if (!IsEmpty (word))
        strcpy(ini->shell, word);
    else
        err = (EError) ((int)err| (int)ErrorShell);
 
    ErrorToString (err, ini->error);
}
 
 
void PrintIni (TIni *ini)
{   printf("\nLogin:\t\t%s\n", ini->login);
    printf("Password:\t%s\n", ini->password);
    printf("Uid:\t\t%d\n", ini->uid);
    printf("Gid:\t\t%d\n", ini->gid);
    printf("Gecos:\t\t%s\n", ini->gecos);
    printf("Home:\t\t%s\n", ini->home);
    printf("Shell: \t\t%s\n", ini->shell);
    printf("Errors:\t\t%s\n\n", ini->error);
}
 
void DeleteIni (TIni *ini)
{   free (ini);
}
 
/*============================================================================================================*/
/*=======================================================================функции для работы с массивом структур*/
TIni **CreateArray (int N)
{   TIni **arr = (TIni**) malloc (N * sizeof (TIni*));
    for (int i = 0; i<N; i++)
        arr[i] = CreateIni();
    return arr;
}
 
void DeleteArray (TIni **arr, int N)
{   for (int i = 0; i<N; i++)
        free (arr[i]);
    free (arr);
}
 
/*============================================================================================================*/
/*======================================================================================вспомогательные функции*/
 
void DeleteFirstChar (char *source)
{   int i = 0;
    while (source[++i] != '\0')
        source[i-1] = source[i];
    source[i-1] = '\0';
}
 
void ErrorToString(EError error, char *result)
{   if (error == None)
    {   strcat(result,"NO ERROR");
        DeleteFirstChar (result);
        return;
    }
    
    if ((error & ErrorLogin) == ErrorLogin)
        strcat(result,"LOGIN ERROR | ");
    if ((error & ErrorPassword) == ErrorPassword)
        strcat(result,"PW ERROR | ");
    if ((error & ErrorUid) == ErrorUid)
        strcat(result,"UID ERROR | ");
    if ((error & ErrorGid) == ErrorGid)
        strcat(result,"GID ERROR | ");
    if ((error & ErrorGecos) == ErrorGecos)
        strcat(result,"GECOS ERROR | ");
    if ((error & ErrorHome) == ErrorHome)
        strcat(result,"HOME ERROR | ");
    if ((error & ErrorShell) == ErrorShell)
        strcat(result,"SHELL ERROR | ");
    DeleteFirstChar (result);
}
 
void SkipSpaces (char *source)
{   char *destination = (char*) malloc (strlen(source) + 1);
    int i = -1, j = -1;
    while (source[++i] != '\0')
        if (source[i] != ' ')
            destination[++j] = source[i];
    destination[++j] = '\0';
    strcpy(source, destination);
    free (destination);
}
 
void InsertChar (char *source, char c, int pos)
{   int len = strlen(source), i = len+2;
    if (len + 2 <= BUF_SIZE)
    {   while (--i > pos)
            source[i] = source[i-1];
        source[i] = c;
    }
}
 
void FillEmptyFields (char *source)
{   int i = 1;
    if (source[0] == ':')
        InsertChar (source, '_', 0);
    while (source [++i] != '\0')
        if (source[i-1] == ':' && source[i] == ':')
            InsertChar (source, '_', i);
    if (source[strlen(source) - 1] == ':')
        InsertChar (source, '_', strlen(source));
}
 
int IsEmpty (char *s)
{   if(strcmp(s, "_") == 0)
        return 1;
    return 0;
}
 
void CheckTemplate (char *source)
{   int i = -1, count = 0;
    while (source [++i] !='\0')
        if(source[i] == ':')
            count++;
 
    if (count == 6)
        return;
 
    strcpy(source, "::::::");   /*обнуляем запись с непрвильным к-вом разделителей ':'*/
}
/*============================================================================================================*/
 
int main() 
{   FILE *in = fopen ("data.txt", "r");
    char buf[BUF_SIZE];
    int count = 0, i = -1;
 
    if(!in)
    {   printf("Error opening file");
        getchar();
        return 1;
    }
 
    while (fgets (buf, BUF_SIZE, in) != NULL)
        count++;
 
    TIni **arrayOfIni = CreateArray (count);
    
    rewind (in);
    while (fgets (buf, BUF_SIZE, in) != NULL)
    {   if (buf [strlen(buf) - 1] == '\n')
            buf [strlen(buf) - 1] = '\0';
        SkipSpaces (buf);
        CheckTemplate (buf);
        FillEmptyFields (buf);
        FillIni (arrayOfIni[++i], buf);
    }
 
    for (i = 0; i<count; i++)
        PrintIni (arrayOfIni[i]);
 
    DeleteArray (arrayOfIni, count);
    fclose (in);
    getchar();
    return 0;
}
                        