Не работает велосипед pwd на сях

char *end = malloc( sizeof(*end ) );

char *last;
char *end;
strcpy(end,"home");
strcpy(last, "OS3cpp");

char last[] = "OS3cpp";

const char* end = "home";

pwd = getenv("PWD");

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

int
main()
{
        char path[PATH_MAX];

        getcwd(path, sizeof(path));
        puts(path);

        return 0;
}

#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define ROOT_INODE 2

char *
pwd(char *path, size_t len)
{
        DIR *dirp = opendir("..");
        struct dirent *dp;
        struct stat st;

        stat(".", &st);
        if (st.st_ino == ROOT_INODE)
                return path;

        dirp = opendir("..");
        while ((dp = readdir(dirp)) != NULL) {
                if (st.st_ino == dp->d_ino) {
                        size_t dlen = strlen(dp->d_name);
                        size_t plen = strlen(path);

                        if (len < dlen + 2)
                                return path;

                        memmove(path + dlen + 1, path, plen + 1);
                        memcpy(path + 1, dp->d_name, dlen);
                        path[0] = '/';
                        chdir("..");

                        return pwd(path, len - dlen - 1);
                }
        }
        closedir(dirp);

        return path;
}

int
main()
{
        char path[PATH_MAX] = {};

        puts(pwd(path, sizeof(path)));

        return 0;
}

    char *last;
    char *end;


    strcpy(end,"home");
    strcpy(last, "OS3cpp"); // OS3cpp - название проги

GETCWD(3)                                                                        Linux Programmer's Manual                                                                       GETCWD(3)



NAME
       getcwd, getwd, get_current_dir_name - get current working directory

SYNOPSIS
       #include <unistd.h>

       char *getcwd(char *buf, size_t size);

       char *getwd(char *buf);

       char *get_current_dir_name(void);

$1, $2...

while

if (st.st_ino == dp->d_ino) { // Тут вы проверяете на равенство что? Порядковый номер файла и что? Не очень понимаю смысл этого условия...

    size_t dlen = strlen(dp->d_name); // Здесь записываете в переменную dlen ко-во символов в dp->d_name, где поле d_name есть начало массива символов, задающего имя элемента каталога. Тут разве не всегда 1 будет? Гуглил и нашел такую вещь "char d_name [1];" в структуре dirent.

    size_t plen = strlen(path); // Здесь записываете не понимаю что... :( но догадываюсь, что это как-то связано с рекурсией...

                        if (len < dlen + 2)
                                return path; // аналогично не понимаю, но что-то с рекурсией

                        memmove(path + dlen + 1, path, plen + 1);
                        memcpy(path + 1, dp->d_name, dlen);
                        path[0] = '/';
                        chdir("..");

                        return pwd(path, len - dlen - 1);
                }

scan tmp (ino: 14096, need: 9497)

#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#define ROOT_INODE 2

/* insert name with prefix '/' at beginning of path */
/* not really effectiv, but enough for our purposes */
/* caveats: no boundaries checks, assumimg buffer is big enough */
/* homework: add boundary checking */
char *
insert(char *path, char *name)
{
	size_t plen = strlen(path);			/* len of path */
	size_t nlen = strlen(name);			/* len of name */

	memmove(path + nlen + 1, path, plen + 1);	/* move old content */
	memcpy(path + 1, name, nlen);			/* insert name */
	path[0] = '/';					/* ensure prefix */

	return path;
}

/* walk up a dir tree up to the root */
/* caveats: no boundaries checks, assumimg buffer is big enough */
/* homework: add boundary checking */
/* homework: what happens if we don't find a right inode? fix it. */
char *
pwd(char *path)
{
        struct stat st;
        struct dirent *dp;
        DIR *dirp;

        stat(".", &st);				/* get stats of current dir */
						/* if we are in root, we are done */
        if (st.st_ino == ROOT_INODE) {		/* root's inode is always 2 */
		path[0] = '/';			/* ensure there is a prefix */
                return path;
	}

	chdir("..");				/* go up to the parent dir */

        dirp = opendir(".");			/* open it */
        while ((dp = readdir(dirp)) != NULL) {	/* walk through content */
                if (st.st_ino == dp->d_ino) {	/* looking for inode */
			insert(path, dp->d_name);	/* found name, add */
			break;			/* break the loop */
                }
        }
	closedir(dirp);				/* clean up */

	return pwd(path);			/* repeat */
}

int
main()
{
        char path[PATH_MAX] = {};		/* zeroed buffer big enough */

        puts(pwd(path));			/* do it and show it */

        return 0;
}

#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

#define BUFSZ       (128)

char *pwd(char **path, size_t *len){
	size_t L = 0;
	struct dirent *dp;
	struct stat st;
	stat(".", &st);
	if(!path) return NULL;
	if(!*path){
		*path = malloc(BUFSZ + 1);
		**path = 0;
		L = BUFSZ;
		if(len) *len = BUFSZ;
	}else{
		if(len) L = *len;
		else return NULL;
	}
	DIR *dirp = opendir("..");
	while((dp = readdir(dirp))){
			if(strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
				continue;
			if(strcmp(dp->d_name, "/") == 0){
				printf("got ROOT\n");
				if(**path != '/'){
					**path = '/';
					*(*path+1) = 0;
				}
				return *path;
			}
			printf("scan %s (ino: %zd, need: %zd), %zd\n", dp->d_name, dp->d_ino, st.st_ino, st.st_rdev);
			if(st.st_ino == dp->d_ino){
					size_t dlen = strlen(dp->d_name) + 2;
					size_t plen = strlen(*path);
					if(plen + dlen < L){
						*path = realloc(*path, plen + dlen);
						L = plen + dlen;
					}
					if(len)
						memmove(*path + dlen - 1, *path, plen+1);
					memcpy(*path + 1, dp->d_name, dlen-2);
					**path = '/';
					chdir("..");
					printf("process %s\n", *path);
					return pwd(path, &L);
			}
	}
	closedir(dirp);
	return *path;
}

int main(int argc, char **argv){
	char *path = NULL;
	if(argc == 2)
		chdir(argv[1]);
	puts(pwd(&path, NULL));
	return 0;
}

#include <sys/stat.h>
#include <dirent.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <mntent.h>

#define ROOTINO     (2)
#define BUFSZ       (128)

typedef struct _mntdef{
	char *mntpoint;
	struct _mntdef *next;
} mntdef;

mntdef *mntlist = NULL;

void addmntdef(char *name){
	mntdef *m, *last = NULL;
	last = mntlist;
	if(last){
		do{
			if(strcmp(last->mntpoint, name) == 0) return;
			if(last->next) last = last->next;
			else break;
		}while(1);
	}
	m = calloc(1, sizeof(mntdef));
	m->mntpoint = strdup(name);
	if(!last) mntlist = m;
	else last->next = m;
}


void push_dir(char **old, char* new, size_t *len, size_t *L){
	size_t dlen = strlen(new) + 2;
	size_t plen = strlen(*old);
	if(plen + dlen < *L){
		*old = realloc(*old, plen + dlen);
		*L = plen + dlen;
	}
	if(len)
		memmove(*old + dlen - 1, *old, plen+1);
	memcpy(*old + 1, new, dlen-2);
	if(plen == 0) *(*old + dlen - 1) = 0;
	**old = '/';
}

struct stat original_st;
char *chkmounted(char *path){
	mntdef *m = mntlist;
	char p[1024];
	struct stat st;
	do{
		snprintf(p, 1023, "%s%s", m->mntpoint, path);
		stat(p, &st);
		if(st.st_ino == original_st.st_ino){
			if(strcmp("/", m->mntpoint))
				return m->mntpoint + 1;
			else
				return NULL;
		}
		if(m->next) m = m->next;
		else break;
	}while(1);
	return NULL;
}

char *pwd(char **path, size_t *len){
	size_t L = 0;
	struct dirent *dp;
	struct stat st;
	stat(".", &st);
	if(!path) return NULL;
	if(!*path){
		*path = malloc(BUFSZ + 1);
		**path = 0;
		L = BUFSZ;
		if(len) *len = BUFSZ;
	}else{
		if(len) L = *len;
		else return NULL;
	}
	if(st.st_ino == ROOTINO){
		char *m = NULL;
		if((m = chkmounted(*path))) push_dir(path, m, len, &L);
		if(**path != '/'){
			**path = '/';
			*(*path+1) = 0;
		}
		return *path;
	}
	DIR *dirp = opendir("..");
	while((dp = readdir(dirp))){
			if(strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
				continue;
			if(st.st_ino == dp->d_ino){
					push_dir(path, dp->d_name, len, &L);
					chdir("..");
					return pwd(path, &L);
			}
	}
	chdir("..");
	return pwd(path, &L);
	closedir(dirp);
	return *path;
}


int main(int argc, char **argv){
	char *path = NULL;
	struct stat st;
	struct mntent *m;
	FILE *f;
	f = setmntent(_PATH_MOUNTED, "r");
	while((m = getmntent(f))){
		stat(m->mnt_dir, &st);
		addmntdef(m->mnt_dir);
	}
	endmntent(f);
	if(argc == 2){
		if(chdir(argv[1])){
			perror("chdir()");
			return -1;
		}
	}
	stat(".", &original_st);
	puts(pwd(&path, NULL));
	return 0;
}