// 文件拷贝
// open, read, write, close
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[]) {
    if (argc != 3) {
        usageErr("error:%d\n", argc);
    }

    if (strcmp(argv[1], "--help") == 0) {
        usageErr("error: No support '--help'\n");
    }

    int ifd;
    int ofd;

    ifd = open(argv[1], O_RDONLY);
    if (ifd < 0) {
        errExit("error: open fd=%d fail!", ifd);
    }

    int filePerms = S_IRUSR | S_IWUSR;
    ofd = open(argv[2], O_WRONLY | O_CREAT | O_APPEND, filePerms);
    if (ofd < 0) {
        errExit("error: open fd=%d fail!", ofd);
    }

    int readcount = 0;
    char buf[1024];
    while ((readcount = read(ifd, buf, 1024)) > 0) {
        printf("readcount=%d\n", readcount);
        if (write(ofd, buf, readcount) != readcount) {
            fatal("error: fatal");
        }
    }

    if (readcount == -1) {
        errExit("read");
    }

    if (close(ifd) != 0) {
        errExit("error: close error fd=%d\n", ifd);
    }

    if (close(ofd) != 0) {
        errExit("error: close error fd=%d\n", ofd);
    }

    return 0;
}

// tee test
// test -a test
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include "tlpi_hdr.h"

#define BUF_SIZE 1024

int main(int argc, char* argv[]) {
    if (argc > 3) {
        usageErr("argv too long");
    }

    int ifd = 0;
    int ofd = 1;
    if (argc >= 2) {
        char* filename = argv[1];
        int mode = O_CREAT | O_WRONLY;
        if (argc == 3 && strcmp(argv[1], "-a") == 0) {
            filename = argv[2];
            mode |= O_APPEND;
        }

        int perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
        if ((ofd = open(filename, mode, perms)) == -1) {
            errExit("open file %s failed!", filename);
        }
    }

    ssize_t numRead;
    char buf[BUF_SIZE];
    while ((numRead = read(ifd, buf, BUF_SIZE)) > 0) {
        if (write(ofd, buf, numRead) != numRead) {
            fatal("write");
        }
    }

    if (numRead == -1) {
        errExit("read");
    }

    if (close(ifd) == -1) {
        errExit("close ifd");
    }

    if (close(ofd) == -1) {
        errExit("close ofd");
    }

    return 0;
}

// 文件空洞
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include "tlpi_hdr.h"

void writeText(int, char*);

int main(int argc, char* argv[]) {
    int fd = open("hole", O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        errExit("open");
    }

    writeText(fd, "hello");
    if (lseek(fd, 10000, SEEK_CUR) == -1) {
        errExit("lseek");
    }
    writeText(fd, "world");

    if (close(fd) == -1) {
        errExit("close");
    }

    return 0;
}

void writeText(int fd, char* buf) {
    int size = strlen(buf);
    if (write(fd, buf, size) != size) {
        errExit("write");
    }
}

#include <sys/stat.h>
#include <fcntl.h>
#include "tlpi_hdr.h"

void lookup(int);

int main(int argc, char* argv[]) {
    int fd = open("fcntl.c", O_WRONLY);
    if (fd == -1) {
        errExit("open");
    }

    int flags;
    flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        errExit("fnctl");
    }
    lookup(flags);

    flags |= O_APPEND;
    if (fcntl(fd, F_SETFL, flags) == -1) {
        errExit("fnctl");
    }

    flags = fcntl(fd, F_GETFL);
    if (flags == -1) {
        errExit("fnctl");
    }
    lookup(flags);

    return 0;
}

void lookup(int flags) {

    if (flags & O_SYNC) {
        printf("O_SYNC is open\n");
    }

    if (flags & O_APPEND) {
        printf("O_APPEND is open\n");
    }

    int accmode = flags & O_ACCMODE;
    if (accmode == O_RDONLY) {
        printf("O_RDONLY is open\n");
    }

    if (accmode == O_WRONLY) {
        printf("O_WRONLY is open\n");
    }

    if (accmode == O_RDWR) {
        printf("O_RDWR is open\n");
    }

    printf("----finish\n");
}

// 把标准输出重定向到日志文件
#include <sys/stat.h>
#include <fcntl.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[]) {
    int perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
    int ofd = open(argv[1], O_CREAT | O_WRONLY | O_APPEND, perms);
    if (ofd == -1) {
        errExit("open");
    }

    if (close(1) == -1) {
        errExit("close");
    }

    if (dup2(ofd, 1) == -1) {
        errExit("dup");
    }

    printf("hello world dup2\n");
    return 0;
}

// 
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[]) {
    int flags = O_CREAT | O_EXCL | O_RDWR;
    int perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IRGRP;
    int fd = open(argv[1], flags, perms);
    if (fd == -1) {
        errExit("open");
    }

    char* buf = "hello";
    if (pwrite(fd, buf, strlen(buf), 100) == -1) {
        errExit("pwrite");
    }

    char* buf1 = malloc(10);
    if (pread(fd, buf1, 10, 101) == -1) {
        errExit("pread");
    }
    printf("pread:%s\n", buf1);
    return 0;
}

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/uio.h>
#include "tlpi_hdr.h"

struct Cat {
    char name[10];
    int age;
};

void try_write(int fd);
void try_read(int fd);

int main(int argc, char* argv[]) {
    if (argc != 3) {
        usageErr("Error: argc is not 3\n");
    }

    int flags = O_CREAT | O_RDWR;
    int perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
    int fd = open(argv[2], flags, perms);
    if (fd == -1) {
        errExit("open");
    }

    if (strcmp(argv[1], "r") == 0) {
        try_read(fd);
    } else {
        try_write(fd);
    }

    if (close(fd) == -1) {
        errExit("close");
    }
    return 0;
}

void try_write(int fd) {
    struct iovec data[2];

    struct Cat cat = { "mimi", 10 };
    data[0].iov_base = &cat;
    data[0].iov_len = sizeof(struct Cat);

    int x = 99;
    data[1].iov_base = &x;
    data[1].iov_len = sizeof(int);

    if (writev(fd, data, 2) == -1) {
        errExit("writev");
    }
}

void try_read(int fd) {
    struct iovec data[2];

    struct Cat cat;
    data[0].iov_base = &cat;
    data[0].iov_len = sizeof(struct Cat);

    int x = 0;
    data[1].iov_base = &x;
    data[1].iov_len = sizeof(int);

    if (readv(fd, data, 2) == -1) {
        errExit("readv");
    }

    printf("cat:%s, %d\n", cat.name, cat.age);
    printf("x:%d\n", x);
}

#include <unistd.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
    if (truncate(argv[1], 1024) == -1) {
        printf("error");
    }
    return 0;
}

// 如果陷入阻塞，则直接返回错误EAGAIN

// 如果open的文件大于2GB，且没有此标记，则直接报错

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include "tlpi_hdr.h"

void try_mkstemp();
void try_tmpfile();

int main(int argc, char* argv[]) {
    try_tmpfile();
    return 0;
}

void try_mkstemp() {
    // XXXXXX必须大写
    char name[] = "/tmp/tmpfileXXXXXX";
    int fd;
    if ((fd = mkstemp(name)) == -1) {
        errExit("error mkstemp");
    }

    printf("tmp name:%s\n", name);
    unlink(name);

    if (close(fd) == -1) {
        errExit("error mkstemp");
    }
}

void try_tmpfile() {
    FILE* f = tmpfile();
    int fd = f->_fileno;
    printf("fd:%d\n", fd);


    char* buf = "helloabcdefghijklmn";
    if (write(fd, buf, strlen(buf)) == -1) {
        errExit("write");
    }

    int pos;
    if ((pos = lseek(fd, 0, SEEK_SET)) == -1) {
        errExit("lseek");
    }

    int numread;
    char* rbuf = malloc(10);
    if ((numread = read(fd, rbuf, 10)) == -1) {
        errExit("read");
    }

    printf("rbuf:%d %s\n", numread, rbuf);

    if (close(fd) == -1) {
        errExit("close");
    }
}

如果一个进程的父进程被杀，则子进程归属到init进程

#include "tlpi_hdr.h"

extern char** environ;

int main(int argc, char* argv[], char* envp[]) {
    // 清除所有环境变量
    clearenv();
    for (char** one=environ; one&&*one; one++) {
        printf("%s\n", *one);
    }

    if (setenv("ming", "hello", 1) == -1) {
        errExit("setenv");
    }
    printf("----->%s\n", getenv("ming"));
    if (unsetenv("ming") == -1) {
        errExit("unsetenv");
    }
    printf("----->%s\n", getenv("ming"));

    return 0;
}

#include "tlpi_hdr.h"
#include <setjmp.h>

jmp_buf env;

void f2(void) {
    longjmp(env, 2);
    printf("f2 finish\n");// 不会打印
}

void f1(int argc) {
    if (argc == 1) {
        longjmp(env, 1);
    }
    f2();
    printf("f1 finish\n");// 不会打印
}

int main(int argc, char* argv[]) {
    printf("setjmp\n");
    switch(setjmp(env)) {
        case 0:
            printf("first jmp\n");
            f1(argc);
            break;
        case 1:
            printf("second jmp from f1\n");
            break;
        case 2:
            printf("third jmp from f2\n");
            break;
    }
    printf("finish\n");
    return 0;
}

#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
    void* p1 = sbrk(0);
    printf("cur=%p\n", p1);

    //char* buf = malloc(0x10);
    brk(p1+1024);

    void* p2 = sbrk(0);
    printf("cur=%p\n", p2);

    printf("dx=%ld\n", (p2-p1));
    return 0;
}

//cur=0x55e333f69000
//cur=0x55e333f69400
//dx=1024

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
    printf("cur=%p\n", sbrk(0));

    void* buf = malloc(100);
    printf("cur=%p\n", sbrk(0));

    void* buf1 = malloc(200);
    printf("cur=%p\n", sbrk(0));

    return 0;
}

//cur=0x55608a112000
//cur=0x55608a133000
//cur=0x55608a133000

#include <stdio.h>
#include <pwd.h>

int main(int argc, char* argv[]) {
    struct passwd* pwd = getpwnam("ming");
    printf("uid:%d\n", pwd->pw_uid);
    printf("name:%s\n", pwd->pw_name);
    printf("dir:%s\n", pwd->pw_dir);
    printf("shell:%s\n", pwd->pw_shell);

    struct passwd* pwd1 = getpwuid(pwd->pw_uid);
    printf("name:%s\n", pwd1->pw_name);
    printf("dir:%s\n", pwd->pw_dir);
    printf("shell:%s\n", pwd->pw_shell);
    return 0;
}

#include <stdio.h>
#include "tlpi_hdr.h"
#include <pwd.h>
#include <string.h>
#include <shadow.h>
#include <unistd.h>
#include <crypt.h>

int main(int argc, char* argv[]) {

    printf("username:");

    char* username = malloc(8);
    memset(username, 0, 8);
    if (fgets(username, 8, stdin) == NULL) {
        errExit("fgets");
    }

    int len = strlen(username);
    if (username[len-1] == '\n') {
        username[len-1] = '\0';
    }

    struct passwd* pwd = getpwnam(username);
    if (pwd == NULL) {
        errExit("getpwnam");
    }
    struct spwd* sp = getspnam(pwd->pw_name);
    if (sp == NULL) {
        errExit("getpwnam");
    }
    printf("sp=%s\n", sp->sp_pwdp);

    char* password = getpass("password:");
    char* encrypted = crypt(password, sp->sp_pwdp);
    if (0 == strcmp(encrypted, sp->sp_pwdp)) {
        printf("welcome %s\n", username);
    } else {
        printf("username or password error!\n");
    }
    return 0;
}

#include <stdio.h>
#include <pwd.h>
#include <string.h>

struct passwd *getpwnam(const char *name);

int main(int argc, char* argv[]) {
    struct passwd *pwd = getpwnam("ming");
    printf("dir=%s\n", pwd->pw_dir);
    return 0;
}

struct passwd *getpwnam(const char *name) {
   struct passwd *pwd = NULL;
   while ((pwd = getpwent()) != NULL) {
       if (strcmp(name, pwd->pw_name) == 0) {
           break;
       }
   }
   endpwent();
   return pwd;
}

// 1. 实际用户ID
// 2. 有效用户ID
// 3. 保存用户ID
// 4. 文件系统用户ID


// aaa文件，只对1000用户有读写权限
// bbb文件，只对1001用户有读写权限
// 如果有效用户ID是1001，则无法open aaa

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "tlpi_hdr.h"

void show_resuid();
void try_read_file(const char* name);

int main(int argc, char* argv[]) {
    show_resuid();

    try_read_file("aaa");
    try_read_file("bbb");

    // 修改有效用户id
    if (setresuid(-1, 1001, -1) == -1) {
        errExit("setresuid");
    }
    show_resuid();
    try_read_file("aaa");
    try_read_file("bbb");

    // 尝试改回root, 如果ruid/euid/suid中有一个是0，则可用改回root，否则会失败
    if (setresuid(-1, 1001, -1) == -1) {
        errExit("setresuid");
    }
    show_resuid();
    return 0;
}

void try_read_file(const char* name) {
    printf("read %s\n", name);
    int fd = open(name, O_RDONLY);
    if (fd == -1) {
        errMsg("open");
        return;
    }

    char buf[10];
    if (read(fd, buf, 10) == -1) {
        errMsg("read");
    }
    printf("read file=%s\n", buf);

    if (close(fd) == -1) {
        errExit("close");
    }
}

void show_resuid() {
    // 获取实际用户id，有效用户id，保存用户id
    uid_t ruid, euid, suid;
    if (getresuid(&ruid, &euid, &suid) == -1) {
        errExit("getresuid");
    }
    printf("%d, %d, %d\n", ruid, euid, suid);
}

#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include "tlpi_hdr.h"

#define TIME_LEN 100

int main(int argc, char* argv[]) {
    struct timeval tv;
    int r = gettimeofday(&tv, NULL);
    if (r == -1) {
        errMsg("gettimeofday");
    }
    printf("cal=%ld, %ld\n", tv.tv_sec, tv.tv_usec);

    // 获取当前UTC秒数
    time_t t = time(NULL);
    printf("t=%ld\n", t);

    // Sun May  9 10:11:32 2021
    char* timestr = ctime(&t);
    printf("%s\n", timestr);

    // 以GMT时区分解时间2:18
    struct tm *tmp = gmtime(&t);
    printf("hour=%d:%d\n", tmp->tm_hour, tmp->tm_min);

    // 以本地时区分解时间10:18
    struct tm *ltmp = localtime(&t);
    printf("hour=%d:%d\n", ltmp->tm_hour, ltmp->tm_min);

    // 合并分解时间
    // 增加10秒
    ltmp->tm_sec += 10;
    time_t mkt = mktime(ltmp);
    printf("mkt=%ld\n", mkt);

    // 把分解时间转成字符串
    char* tstr = asctime(ltmp);
    printf("tstr=%s\n", tstr);

    // 格式化时间
    char tbuf[TIME_LEN];
    strftime(tbuf, TIME_LEN, "%Z %Y %X", ltmp);
    printf("%s\n", tbuf);

    return 0;
}

```

### 22. 进程时间, times/clock
```c
// 12-1
#include <stdio.h>
#include <pwd.h>
#include <dirent.h>
#include <ctype.h>
#include "tlpi_hdr.h"
#include "ps.h"

int main(int argc, char* argv[]) {
    if (argc < 2) {
        errExit("Not found username");
    }

    char* username = argv[1];
    int uid = get_uid_by_name(username);
    if (uid == -1) {
        errExit("get uid failed");
    }

    DIR *rootdir = opendir(ROOT_DIR);
    if (rootdir == NULL) {
        errExit("opendir");
    }

    struct dirent *dir;
    while ((dir = readdir(rootdir)) != NULL) {
        if (dir->d_type != DT_DIR) continue;
        if (!digit(dir->d_name)) continue;

        char* pid = dir->d_name;
        char* status_path = gen_status_path(pid);
        // printf("path=%s\n", status_path);
        struct Entry *entry = readentry(uid, status_path);
        if (entry != NULL) {
            printf("    %s    %ld\n", entry->name, entry->pid);
        }
    }
    // printf("finish\n");

    return 0;
}

// 12-2 生成进程树
#include <stdio.h>
#include "ps.h"

int main(int argc, char* argv[]) {
    struct node *head = NULL;
    struct node *tail = NULL;

    DIR *rootdir = opendir(ROOT_DIR);
    if (rootdir == NULL) {
        errExit("opendir");
    }

    struct dirent *dir;
    while ((dir = readdir(rootdir)) != NULL) {
        if (dir->d_type != DT_DIR) continue;
        if (!digit(dir->d_name)) continue;

        char* pid = dir->d_name;
        char* status_path = gen_status_path(pid);
        // printf("path=%s\n", status_path);
        // 1.create node
        struct node *np = createnode(status_path);

        // 2. sort
        if (head == NULL) {
            head = np;
            tail = np;
        } else {
            struct node *pre = NULL;
            struct node *p = head;
            while (p != NULL && p->entry->pid < np->entry->pid) {
                pre = p;
                p = p->next;
            }
            np->next = p;
            pre->next = np;
            if (tail->next != NULL) {
                tail = tail->next;
            }
        }
    }

    print_queue(head);

    // 3.gen tree
    struct node *root = createtree(head);

    // 4.print tree
    print_tree(head, root);
    return 0;
}

#include <stdio.h>
#include <pwd.h>
#include <dirent.h>
#include <ctype.h>
#include "tlpi_hdr.h"

#define ROOT_DIR "/proc"
#define STATUS "status"
#define READ_BUFFER_SIZE 1024

int get_uid_by_name(char*);
int digit(char* s);
char* gen_status_path(char* pid);
char* getval(char* line, char* name);

struct Entry {
    char name[100];
    long pid;
    long ppid;
};

struct node {
    struct Entry *entry;
    struct node *child; // for tree
    struct node *next; // for queue
};

void print_queue(struct node *head);
struct node *createnode(char* path);
struct node *createtree(struct node *head);
struct node *clonenode(struct node *p);
struct node *searchnode(struct node *root, long pid);
void print_tree(struct node *head, struct node *root);

struct Entry *readentry(int uid, char* path);

#include "ps.h"

int get_uid_by_name(char* name) {
    struct passwd *pwd = getpwnam(name);
    if (pwd == NULL) {
        return -1;
    }
    return pwd->pw_uid;
}

int digit(char* s) {
    for (char* p=s; (*p)!='\0'; p++) {
        if ((*p) < '0' || (*p) > '9') return 0;
    }
    return 1;
}

char* gen_status_path(char* pid) {
    int len = strlen(ROOT_DIR) + 1 + strlen(pid) + 1 + strlen(STATUS);
    char *buf = malloc(len);
    memset(buf, 0, len);
    strcat(buf, ROOT_DIR);
    strcat(buf, "/");
    strcat(buf, pid);
    strcat(buf, "/");
    strcat(buf, STATUS);
    return buf;
}

struct Entry *readentry(int uid, char* path) {
    struct Entry *pentry = malloc(sizeof(struct Entry));

    FILE* f = fopen(path, "r");

    char* linebuf = malloc(READ_BUFFER_SIZE);
    memset(linebuf, 0, READ_BUFFER_SIZE);

    // Name:	sshd
    // Pid:	1
    // Uid:	1000	1000	1000	1000

    // uid is match
    while ((linebuf = fgets(linebuf, READ_BUFFER_SIZE, f)) != NULL) {
        char* uidstr = getval(linebuf, "Uid:");
        if (uidstr == NULL) continue;
        int target = atoi(uidstr);
        if (target == uid) {
            break;
        } else {
            return NULL;
        }
    }

    if (fseek(f, 0, SEEK_SET) == -1) {
        errMsg("fseek");
        return NULL;
    }

    while ((linebuf = fgets(linebuf, READ_BUFFER_SIZE, f)) != NULL) {
        char* name = getval(linebuf, "Name:");
        if (name != NULL) {
            strcpy(pentry->name, name);
        }

        char* pid = getval(linebuf, "Pid:");
        if (pid != NULL) {
            pentry->pid = atol(pid);
        }
    }
    return pentry;
}

char* getval(char* line, char* name) {
    char* p1 = line;
    char* p2 = name;
    while ((*p1) == (*p2)) {
        p1++;
        p2++;
    }
    if (p2 - name != strlen(name)) {
        return NULL;
    }

    int size = strlen(line);
    char* buf = malloc(size);
    memset(buf, 0, size);
    int i = 0;
    for (char* p=p1+1; (*p)!='\0'; p++) {
        if (isspace(*p)) {
            if (i > 0) {
                break;
            } else {
                continue;
            }
        }
        buf[i] = *p;
        i++;
    }
    return buf;
}

struct node *createnode(char* path) {
    struct Entry *pentry = malloc(sizeof(struct Entry));

    FILE *f = fopen(path, "r");

    char *linebuf = malloc(READ_BUFFER_SIZE);
    memset(linebuf, 0, READ_BUFFER_SIZE);

    while ((linebuf = fgets(linebuf, READ_BUFFER_SIZE, f)) != NULL) {
        char* name = getval(linebuf, "Name:");
        if (name != NULL) {
            strcpy(pentry->name, name);
        }

        char* pid = getval(linebuf, "Pid:");
        if (pid != NULL) {
            pentry->pid = atol(pid);
        }

        char* ppid = getval(linebuf, "PPid:");
        if (ppid != NULL) {
            pentry->ppid = atol(ppid);
        }
    }

    struct node *p = malloc(sizeof(struct node));
    p->entry = pentry;
    return p;
}

void print_queue(struct node *head) {
    if (head == NULL) return;
    struct node *p = head;
    while (p->next != NULL) {
        printf("%s(%ld)-->", p->entry->name,  p->entry->pid);
        p = p->next;
    }
    printf("\n");
}

struct node *createtree(struct node *head) {
    struct node *root = NULL;
    struct node *p = head;
    while (p != NULL) {
        // 从队列里找child节点, 如果找到就clone，然后加入child队列
        struct node *q = head;
        while (q != NULL) {
            if (p->entry->pid == q->entry->ppid) {
                struct node *x = clonenode(q);
                if (root == NULL) {
                    root = x;
                }
                x->next = p->child;
                p->child = x;
            }
            q = q->next;
        }
        p = p->next;
    }
    return root;
}

struct node *clonenode(struct node *p) {
    struct node *r = malloc(sizeof(struct node));
    r->next = NULL;
    r->child = NULL;
    r->entry = malloc(sizeof(struct Entry));
    strcpy(r->entry->name, p->entry->name);
    r->entry->pid = p->entry->pid;
    r->entry->ppid = p->entry->ppid;
    return r;
}

struct node *searchnode(struct node *root, long pid) {
    if (root == NULL) return NULL;
    if (root->entry->pid == pid) return root;

    struct node *p = root->child;
    while (p != NULL) {
        struct node *x = searchnode(p, pid);
        if (x != NULL) return x;
        p = p->next;
    }
    return NULL;
}

void print_tree(struct node *head, struct node *root) {
    if (root == NULL) return;

    struct node *p = head;
    while (p != NULL) {
        printf("%s(%ld)-->>", p->entry->name,  p->entry->pid);
        struct node *x = p->child;
        while (x != NULL) {
            printf("%s(%ld)-->", x->entry->name,  x->entry->pid);
            x = x->next;
        }
        printf("\n");
        p = p->next;
    }
}