draccut/LLL
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: draccut/LLL:c
Branches Tags
draccut/LLL:rust draccut/LLL:main draccut/LLL:c
...
pull from: draccut/LLL:rust
Branches Tags
draccut/LLL:main draccut/LLL:rust draccut/LLL:c
1 Commits
c ... rust
Author SHA1 Message Date
draccut e7958242d8 rust ll 2026-09-13 20:52:58 +02:00
2 changed files with 742 additions and 713 deletions
Expand all files Collapse all files
lll.c
-713
View File
@@ -1,713 +0,0 @@
/**
* KOMPILATION
* ===========
* gcc -Og -fstack-protector-strong -D_FORTIFY_SOURCE=3 -fstrict-flex-arrays=3 -fno-strict-aliasing -fno-strict-overflow -fno-delete-null-pointer-checks -fcf-protection=full -Wall -Wextra -Wformat -Wformat-security -fPIE -pie -Wl,-z,relro,-z,now -Wl,-z,noexecstack -o lll lll.c
*/
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>
#include <limits.h>
#include <inttypes.h>
#include <stdint.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#define MOUNT_LOOPS 2
#ifndef MAX_PATH
#define MAX_PATH 0xFFF
#endif
#define FILE_SYSTEM_BUFF_SIZE (MAX_PATH * MOUNT_LOOPS)
#define NR_OF_SUPPORTET_LANG 13
#define CARD_LEN 10
#define ERRR 0xFFFAFFFu
#define LLL_HELP_MESSAGE_JANUAR_X \
"-s --size sort by size\n" \
"-l --ls ls like output\n" \
"-h --help print help\n" \
"-p --path set path default is current\n" \
"-q --qqqq print all absolut paths of a folder\n" \
"@COMPILER gcc (GCC) 15.2.0\n"
typedef struct {
const char *name;
uint64_t countet_size;
int globalsumindex;
} Type;
typedef struct {
time_t unixtimestamp;
char *row;
} TTAS;
static Type types[NR_OF_SUPPORTET_LANG] = {
{"", 0ULL, 0},
{"c", 0ULL, 1},
{"cpp", 0ULL, 2},
{"ino", 0ULL, 3},
{"py", 0ULL, 4},
{"java", 0ULL, 5},
{"sh", 0ULL, 6},
{"js", 0ULL, 7},
{"html", 0ULL, 8},
{"asm", 0ULL, 9},
{"rs", 0ULL, 10},
{"sql", 0ULL, 11},
{"h", 0ULL, 1}
};
static const char *nameList[NR_OF_SUPPORTET_LANG] = {
"Undefined","C","C++","ESP","Python","Java","ShellScript","JavaScript","HTML","Assembly","Rust","SQL","C"
};
static const uint64_t colorList[NR_OF_SUPPORTET_LANG] = {
0x2222077877CCULL,
0x222205666666ULL,
0x22220A2222FFULL,
0x22220FEEAA00ULL,
0x222200A8A862ULL,
0x222200FFFF00ULL,
0x222200FF0010ULL,
0x222200BB0010ULL,
0x222200CC66FFULL,
0x222200FF8800ULL,
0x222200DEA584ULL,
0x2222000000FFULL,
0x222205666666ULL
};
/**
* ANSI-Farbstring mit Hintergrund und Vordergrund erzeugen
*/
char *coloramaprintifarma(const char *ptext, uint64_t col) {
uint8_t bg_r = (col >> 40) & 0xFF;
uint8_t bg_g = (col >> 32) & 0xFF;
uint8_t bg_b = (col >> 24) & 0xFF;
uint8_t fg_r = (col >> 16) & 0xFF;
uint8_t fg_g = (col >> 8) & 0xFF;
uint8_t fg_b = col & 0xFF;
const char *suffix = "\033[0m";
const char *fmt = "\033[38;2;%u;%u;%um\033[48;2;%u;%u;%um";
int prefix_len = snprintf(NULL, 0, fmt,
fg_r, fg_g, fg_b,
bg_r, bg_g, bg_b);
if (prefix_len < 0) return NULL;
size_t text_len = strlen(ptext);
size_t suffix_len = strlen(suffix);
size_t total_len = (size_t)prefix_len + text_len + suffix_len + 1;
char *buf = malloc(total_len);
if (!buf) return NULL;
int written = snprintf(buf, total_len, fmt,
fg_r, fg_g, fg_b,
bg_r, bg_g, bg_b);
memcpy(buf + written, ptext, text_len);
memcpy(buf + written + text_len, suffix, suffix_len + 1);
return buf;
}
/**
* UTF-8 Zeichenlänge (erstes Byte)
*/
static size_t utf8_char_len_local(unsigned char c) {
if (c < 0x80) return 1;
if ((c >> 5) == 0x6) return 2;
if ((c >> 4) == 0xE) return 3;
if ((c >> 3) == 0x1E) return 4;
return 1;
}
/**
* Füllt Text auf CARD_LEN auf und färbt mit Hintergrund
*/
char *coloramaprintifarmafillup(const char *text, uint64_t advansed_color) {
if (!text) return NULL;
char *res = malloc(CARD_LEN + 1);
if (!res) return NULL;
size_t pos = 0;
size_t i = 0;
while (pos < CARD_LEN && text[i]) {
size_t clen = utf8_char_len_local((unsigned char)text[i]);
if (pos + clen > CARD_LEN) break;
memcpy(res + pos, text + i, clen);
pos += clen;
i += clen;
}
while (pos < CARD_LEN) res[pos++] = ' ';
res[CARD_LEN] = '\0';
char *colored = coloramaprintifarma(res, advansed_color);
free(res);
return colored;
}
/**
* Vordergrundfarbe für Text
*/
char *coll(uint64_t col, const char *ptext) {
uint8_t r = (col >> 16) & 0xFF;
uint8_t g = (col >> 8) & 0xFF;
uint8_t b = col & 0xFF;
const char *suffix = "\033[0m";
const char *fmt = "\033[38;2;%u;%u;%um";
int prefix_len = snprintf(NULL, 0, fmt, r, g, b);
if (prefix_len < 0) return NULL;
size_t text_len = strlen(ptext);
size_t suffix_len = strlen(suffix);
size_t total_len = (size_t)prefix_len + text_len + suffix_len + 1;
char *buffer = malloc(total_len);
if (!buffer) return NULL;
int written = snprintf(buffer, total_len, fmt, r, g, b);
memcpy(buffer + written, ptext, text_len);
memcpy(buffer + written + text_len, suffix, suffix_len + 1);
return buffer;
}
/**
* Füllt Text auf max Länge und färbt mit Vordergrundfarbe
*/
char *chngg(const char *pp, uint64_t color, int more_space) {
int mse = (more_space == 1) ? (CARD_LEN * 3) : CARD_LEN;
char *rptr = malloc(mse + 1);
if (!rptr) return NULL;
size_t pos = 0;
size_t i = 0;
while (pos < (size_t)mse && pp[i]) {
size_t clen = utf8_char_len_local((unsigned char)pp[i]);
if (pos + clen > (size_t)mse) break;
memcpy(rptr + pos, pp + i, clen);
pos += clen;
i += clen;
}
while (pos < (size_t)mse) rptr[pos++] = ' ';
rptr[mse] = '\0';
char *rrr = coll(color, rptr);
free(rptr); /* rptr freigeben, coll liefert neuen Buffer */
return rrr;
}
/**
* Wrapper: erzeugt gefülltes, gefärbtes Feld für Typnamen
*/
char *chngg_wrapper(int index, uint64_t unused_size) {
(void)unused_size;
if (index < 0 || index >= NR_OF_SUPPORTET_LANG) index = 0;
return coloramaprintifarmafillup(nameList[index], colorList[index]);
}
/**
* Mode bits in ls -l Stil konvertieren
*/
void mode_to_str(mode_t m, char out[11]) {
out[0] = S_ISDIR(m) ? 'd' : S_ISLNK(m) ? 'l' : S_ISCHR(m) ? 'c' :
S_ISBLK(m) ? 'b' : S_ISFIFO(m) ? 'p' : S_ISSOCK(m) ? 's' : '-';
out[1] = (m & S_IRUSR) ? 'r' : '-';
out[2] = (m & S_IWUSR) ? 'w' : '-';
out[3] = (m & S_IXUSR) ? 'x' : '-';
out[4] = (m & S_IRGRP) ? 'r' : '-';
out[5] = (m & S_IWGRP) ? 'w' : '-';
out[6] = (m & S_IXGRP) ? 'x' : '-';
out[7] = (m & S_IROTH) ? 'r' : '-';
out[8] = (m & S_IWOTH) ? 'w' : '-';
out[9] = (m & S_IXOTH) ? 'x' : '-';
out[10] = '\0';
}
/**
* Prozessiert Größe in menschenlesbares Format
*/
void process_size(off_t size, char *buf, size_t buflen) {
const char *units[] = {"B","KB","MB","GB","TB"};
double s = (double)size;
int u = 0;
while (s >= 1024 && u < 4) { s /= 1024; u++; }
snprintf(buf, buflen, "%.1f %s", s, units[u]);
}
/**
* Sucht Index anhand Dateiendung
*/
int get_type_ind_by_name(const char *type_s) {
if (!type_s) return ERRR;
for (int i = 1; i < NR_OF_SUPPORTET_LANG; ++i) {
if (types[i].name && types[i].name[0] != '\0' && strcmp(types[i].name, type_s) == 0) return i;
}
return ERRR;
}
/**
* Addiert Dateigröße zum Typ
*/
int add_type_value(int pp_index, size_t filesize) {
if (pp_index < 0 || pp_index >= NR_OF_SUPPORTET_LANG) return -1;
types[pp_index].countet_size += (uint64_t)filesize;
return 0;
}
/**
* Ermittelt Typ aus Pfad und addiert Größe
*/
void get_type(const char *fullpath, int size, size_t filesize) {
if (!fullpath || size <= 0) return;
int point_index = -1;
for (int i = size - 1; i >= 0; --i) {
if (fullpath[i] == '.') { point_index = i; break; }
if (fullpath[i] == '/') { point_index = -1; break; }
}
if (point_index <= 0) return;
int len = size - point_index - 1;
if (len <= 0) return;
char *type_s = malloc(len + 1);
if (!type_s) return;
memcpy(type_s, fullpath + point_index + 1, len);
type_s[len] = '\0';
int index = get_type_ind_by_name(type_s);
if (index != ERRR) add_type_value(index, filesize);
free(type_s);
}
/**
* Rekursive Ordnergrößenberechnung und Typzählung
*/
uint64_t folder_size(const char *path) {
uint64_t total = 0;
DIR *d = opendir(path);
if (!d) return 0;
struct dirent *e;
while ((e = readdir(d)) != NULL) {
if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue;
char full[FILE_SYSTEM_BUFF_SIZE];
if (strlen(path) + strlen(e->d_name) > FILE_SYSTEM_BUFF_SIZE) continue;
snprintf(full, sizeof(full), "%s/%s", path, e->d_name);
struct stat st;
if (lstat(full, &st) != 0) continue;
if (S_ISDIR(st.st_mode)) total += folder_size(full);
else {
total += (uint64_t)st.st_size;
get_type(full, (int)strlen(full), (size_t)st.st_size);
}
}
closedir(d);
return total;
}
/**
* Ermittelt dominanten Sprachindex basierend auf gesammelten Größen
*/
int get_dom_lang_index(void) {
uint64_t local_sums[NR_OF_SUPPORTET_LANG];
for (int i = 0; i < NR_OF_SUPPORTET_LANG; ++i) local_sums[i] = 0;
for (int i = 1; i < NR_OF_SUPPORTET_LANG; ++i) {
int g = types[i].globalsumindex;
if (g >= 0 && g < NR_OF_SUPPORTET_LANG) local_sums[g] += types[i].countet_size;
}
int max_idx = 0;
uint64_t max_val = 0;
for (int i = 0; i < NR_OF_SUPPORTET_LANG; ++i) {
if (local_sums[i] > max_val) { max_val = local_sums[i]; max_idx = i; }
}
for (int i = 0; i < NR_OF_SUPPORTET_LANG; ++i) types[i].countet_size = 0;
return max_idx;
}
/**
* Ermittelt Index für einzelne Datei anhand Extension
*/
int get_dom_single_file_index_from_path(const char *path) {
if (!path) return 0;
const char *dot = strrchr(path, '.');
const char *ext = dot ? dot + 1 : "";
for (int i = 0; i < NR_OF_SUPPORTET_LANG; ++i) {
if (types[i].name && types[i].name[0] != '\0' && strcmp(types[i].name, ext) == 0) return i;
}
return 0;
}
/**
* Schreibt content in Zwischenablage via xclip
*/
void clipper(const char *content) {
if (!content) return;
FILE *p = popen("xclip -selection clipboard", "w");
if (!p) return;
fwrite(content, 1, strlen(content), p);
pclose(p);
}
/**
* Erzeugt absoluten Pfad aus aktuellem Arbeitsverzeichnis und name
*/
void getAbsolutPath(char *name, int nameLen) {
if (name == NULL) {
printf("No name passed\n");
}
char path[FILE_SYSTEM_BUFF_SIZE];
if (getcwd(path, sizeof(path)) != NULL) {
int pathLen = (int)strlen(path);
int len = pathLen + nameLen + 2;
char *absolutPath = malloc(len + 1);
if (!absolutPath) { perror("malloc"); return; }
absolutPath[len] = '\0';
int k = 0;
for (int i = 0; i < len; ++i) {
if (i < pathLen) {
absolutPath[i] = path[k];
++k;
}
if (i > pathLen) {
absolutPath[i] = name[k];
++k;
}
if (i == pathLen) {
absolutPath[i] = '/';
k = 0;
}
}
printf("%s\n", absolutPath);
clipper(absolutPath);
free(absolutPath);
} else {
perror("ERROR: getcwd");
}
}
/**
* Vertauscht zwei TTAS-Elemente
*/
void swapTTAS(TTAS *a, TTAS *b) {
TTAS temp = *a;
*a = *b;
*b = temp;
}
/**
* Kehrt ein Array von TTAS um
*/
void reverseArray(TTAS *arr, int n) {
int left = 0;
int right = n - 1;
while (left < right) {
swapTTAS(&arr[left], &arr[right]);
left++;
right--;
}
}
/**
* Sortiert nach Timestamp (neueste zuerst), nutzt Auswahl-Sort und reversiert Ergebnis
*/
void sortByTimestamp(time_t *unixTimestamps, char **rows, int n) {
if (unixTimestamps == NULL || rows == NULL || n <= 1)
return;
for (int i = 0; i < n - 1; ++i) {
int maxIndex = i;
for (int j = i + 1; j < n; ++j) {
if (unixTimestamps[j] > unixTimestamps[maxIndex]) {
maxIndex = j;
}
}
if (maxIndex != i) {
time_t tempTime = unixTimestamps[i];
unixTimestamps[i] = unixTimestamps[maxIndex];
unixTimestamps[maxIndex] = tempTime;
char *tempRow = rows[i];
rows[i] = rows[maxIndex];
rows[maxIndex] = tempRow;
}
}
TTAS *array = malloc(n * sizeof(TTAS));
if (array == NULL) {
perror("malloc TTAS array");
return;
}
for (int i = 0; i < n; ++i) {
array[i].unixtimestamp = unixTimestamps[i];
array[i].row = rows[i];
}
reverseArray(array, n);
for (int i = 0; i < n; ++i) {
unixTimestamps[i] = array[i].unixtimestamp;
rows[i] = array[i].row;
}
free(array);
}
/**
* Sortiert Einträge nach Größe (absteigend)
*/
void sortBySize(uint64_t *sizes, char **rows, int n) {
if (sizes == NULL || rows == NULL || n <= 1) return;
for (int i = 0; i < n - 1; ++i) {
int maxIndex = i;
for (int j = i + 1; j < n; ++j) {
if (sizes[j] < sizes[maxIndex]) maxIndex = j;
}
if (maxIndex != i) {
uint64_t tmp = sizes[i];
sizes[i] = sizes[maxIndex];
sizes[maxIndex] = tmp;
char *trow = rows[i];
rows[i] = rows[maxIndex];
rows[maxIndex] = trow;
}
}
}
/**
* Ermittelt dominanten Sprachindex und liefert Index und Summe (Wrapper)
*/
void getDomLangIndex(int *out_index, uintptr_t *out_size) {
int idx = get_dom_lang_index();
*out_index = idx;
*out_size = 0;
}
void print_absolut_paths(const char *path_to_process) {
DIR *d = opendir(path_to_process);
if (!d) {
perror("opendir");
return;
}
struct dirent *e;
while ((e = readdir(d)) != NULL) {
if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue;
char name[PATH_MAX];
if (snprintf(name, sizeof(name), "%s", e->d_name) >= (int)sizeof(name)) continue;
char path[FILE_SYSTEM_BUFF_SIZE];
char respath[PATH_MAX + FILE_SYSTEM_BUFF_SIZE + 2] = { 0 };
if (path_to_process[0] == '.') {
if (!(getcwd(path, sizeof(path)) != NULL)) {
perror("ERROR: getcwd");
} else {
snprintf(respath, sizeof(respath), "%s/%s\n", path, name);
}
} else {
snprintf(respath, sizeof(respath), "%s/%s\n", path_to_process, name);
}
printf("%s", respath);
}
}
/**
* Hauptfunktion: listet Ordner ähnlich lll/main_lll, unterstützt Sortierung nach Zeit (default) oder Größe (-s)
*/
int main_lll_impl(int sort_by_size, const char *path_to_process) {
DIR *d = opendir(path_to_process);
if (!d) {
perror("opendir");
return 1;
}
struct dirent *e;
char **rows = NULL;
uint64_t *sizes = NULL;
time_t *unixTimestamps = NULL;
size_t count = 0, cap = 0;
while ((e = readdir(d)) != NULL) {
if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue;
char full[PATH_MAX];
if (snprintf(full, sizeof(full), "%s/%s", path_to_process, e->d_name) >= (int)sizeof(full)) continue;
struct stat st;
if (lstat(full, &st) == -1) continue;
char perms[11];
mode_to_str(st.st_mode, perms);
nlink_t links = st.st_nlink;
struct passwd *pw = getpwuid(st.st_uid);
struct group *gr = getgrgid(st.st_gid);
const char *owner = pw ? pw->pw_name : "unknown";
const char *group = gr ? gr->gr_name : "unknown";
char sizebuf[32];
char timestr[64];
struct tm tm;
localtime_r(&st.st_mtime, &tm);
strftime(timestr, sizeof(timestr), "%e. %b %H:%M", &tm);
time_t timestamp = st.st_mtime;
uint64_t raw_size = 0;
if (S_ISDIR(st.st_mode)) {
raw_size = folder_size(full);
process_size((off_t)raw_size, sizebuf, sizeof(sizebuf));
get_type(full, (int)strlen(full), (size_t)raw_size);
} else {
raw_size = (uint64_t)st.st_size;
process_size((off_t)st.st_size, sizebuf, sizeof(sizebuf));
get_type(full, (int)strlen(full), (size_t)st.st_size);
}
int ja_index = 0;
uintptr_t ja_size = 0;
getDomLangIndex(&ja_index, &ja_size);
char *line = NULL;
if (S_ISLNK(st.st_mode)) {
char target[PATH_MAX];
ssize_t len = readlink(full, target, sizeof(target) - 1);
if (len != -1) {
target[len] = '\0';
size_t needed = strlen(perms) + 128 + strlen(owner) + strlen(group) + strlen(sizebuf) + strlen(timestr) + strlen(e->d_name) + strlen(target) + 64;
line = malloc(needed);
if (!line) { closedir(d); return 1; }
snprintf(line, needed, "%s %3lu %s %s %8s %s %s -> %s",
perms, (unsigned long)links, owner, group, sizebuf, timestr, e->d_name, target);
} else {
size_t needed = strlen(perms) + 128 + strlen(owner) + strlen(group) + strlen(sizebuf) + strlen(timestr) + strlen(e->d_name) + 32;
line = malloc(needed);
if (!line) { closedir(d); return 1; }
snprintf(line, needed, "%s %3lu %s %s %8s %s %s",
perms, (unsigned long)links, owner, group, sizebuf, timestr, e->d_name);
}
} else {
char *owner_col = chngg(owner, 0x44FF44, 0);
char *group_col = chngg(group, 0x88FF88, 0);
char *size_col = chngg(sizebuf, 0xFF0000, 0);
char *time_col = chngg(timestr, 0x888866, 0);
char *type_fld = chngg_wrapper(ja_index, ja_size);
char *name_col = chngg(e->d_name, S_ISDIR(st.st_mode) ? 0x9999FF : 0xFF33FF, 1);
size_t needed = strlen(perms) + 128 + strlen(owner_col) + strlen(group_col) + strlen(size_col) + strlen(time_col) + strlen(type_fld) + strlen(name_col) + 64;
line = malloc(needed);
if (!line) { closedir(d); return 1; }
snprintf(line, needed, "%s %3lu %s %s %8s %s %s %s",
perms, (unsigned long)links,
owner_col, group_col, size_col, time_col, type_fld, name_col);
free(owner_col); free(group_col); free(size_col); free(time_col); free(type_fld); free(name_col);
}
if (count + 1 > cap) {
size_t ncap = cap ? cap * 2 : 64;
char **tmp = realloc(rows, ncap * sizeof(char*));
uint64_t *tmp2 = realloc(sizes, ncap * sizeof(uint64_t));
time_t *tmp3 = realloc(unixTimestamps, ncap * sizeof(time_t));
if (!tmp || !tmp2 || !tmp3) { perror("realloc"); free(line); break; }
rows = tmp; sizes = tmp2; unixTimestamps = tmp3;
cap = ncap;
}
rows[count] = line;
sizes[count] = raw_size;
unixTimestamps[count] = timestamp;
count++;
}
closedir(d);
if (count > 0) {
if (sort_by_size) {
sortBySize(sizes, rows, (int)count);
} else {
sortByTimestamp(unixTimestamps, rows, (int)count);
}
}
for (size_t i = 0; i < count; ++i) {
printf("%s\n", rows[i]);
free(rows[i]);
}
free(rows);
free(sizes);
free(unixTimestamps);
return 0;
}
/**
* ls-ähnliche Kurzliste: zeigt Typ-Feld und gekürzten Namen in Spalten
*/
int main_ls_impl(void) {
DIR *d = opendir(".");
if (!d) { perror("opendir"); return 1; }
struct dirent *e;
char **entries = NULL;
size_t count = 0, cap = 0;
while ((e = readdir(d)) != NULL) {
if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue;
char full[PATH_MAX];
if (snprintf(full, sizeof(full), "./%s", e->d_name) >= (int)sizeof(full)) continue;
struct stat st;
if (lstat(full, &st) != 0) continue;
if (S_ISDIR(st.st_mode)) folder_size(full);
nlink_t links = st.st_nlink;
int lang_idx = S_ISDIR(st.st_mode) ? get_dom_lang_index() : get_dom_single_file_index_from_path(full);
uint64_t name_color = S_ISDIR(st.st_mode) ? 0x9999FF : 0xFF33FF;
char *type_fld = chngg_wrapper(lang_idx, 0);
char *project_name = chngg(e->d_name, name_color, 1);
char gek[46]; memset(gek,0,sizeof(gek)); strncpy(gek, project_name, 45); gek[45]='\0';
size_t needed = 5 + 1 + strlen(type_fld) + 1 + strlen(gek) + 32;
char *line = malloc(needed);
if (!line) { free(type_fld); free(project_name); break; }
snprintf(line, needed, "%3lu %8s %s", (unsigned long)links, type_fld, gek);
free(type_fld); free(project_name);
if (count + 1 > cap) {
size_t ncap = cap ? cap * 2 : 64;
char **tmp = realloc(entries, ncap * sizeof(char*));
if (!tmp) { free(line); break; }
entries = tmp; cap = ncap;
}
entries[count++] = line;
}
closedir(d);
char *reset = coloramaprintifarma("", 0x000000000000ULL);
if (reset) free(reset);
for (size_t i = 0; i < count; i += 4) {
size_t end = i + 4; if (end > count) end = count;
size_t total_len = 0;
for (size_t j = i; j < end; ++j) total_len += strlen(entries[j]) + 1;
char *line = malloc(total_len + 1);
if (!line) continue;
line[0] = '\0';
for (size_t j = i; j < end; ++j) {
if (j > i) strcat(line, " ");
strcat(line, entries[j]);
}
printf("%s\n", line);
free(line);
}
for (size_t i = 0; i < count; ++i) free(entries[i]);
free(entries);
return 0;
}
/**
* Programmstart und CLI-Argumente Dispatcher
*/
int main(int argc, char **argv) {
if (argc == 1) {
if (main_lll_impl(0, ".") > 0) goto label_exit_error;
goto label_exit_end;
}
if (argc == 2 || argc == 3) {
if ((strcmp(argv[1], "-s") == 0) || (strcmp(argv[1], "--size") == 0)) goto label_size;
if ((strcmp(argv[1], "-l") == 0) || (strcmp(argv[1], "--ls") == 0)) goto label_ls;
if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) goto label_help;
if ((strcmp(argv[1], "-p") == 0) || (strcmp(argv[1], "--path") == 0)) goto label_path;
if ((strcmp(argv[1], "-q") == 0) || (strcmp(argv[1], "--qqqq") == 0)) goto label_list_absolut;
goto label_absolut_path;
}
label_size:
if (main_lll_impl(1, ".") > 0) goto label_exit_error;
goto label_exit_end;
label_ls:
main_ls_impl();
goto label_exit_end;
label_path:
if (argc != 3) goto label_exit_error;
if (main_lll_impl(0, argv[2]) > 0) goto label_exit_error;
goto label_exit_end;
label_help:
printf(LLL_HELP_MESSAGE_JANUAR_X);
printf("MAX_PATH : %d\n", PATH_MAX);
goto label_exit_end;
label_absolut_path:
getAbsolutPath(argv[1], strlen(argv[1]));
goto label_exit_end;
label_list_absolut:
if (argc == 2) {
print_absolut_paths(".");
} else {
print_absolut_paths(argv[2]);
}
goto label_exit_end;
label_exit_error:
fprintf(stderr, "Unbekannter Parameter oder falsche Nutzung\n");
return 1;
label_exit_end:
return 0;
}
lll.rs
Executable
+742
View File
@@ -0,0 +1,742 @@
use std::env;
use std::fs;
use std::io::Write;
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::mem;
use std::fs::Metadata;
use std::time::UNIX_EPOCH;
const FILE_SYSTEM_MAX_PATH: usize = 0xfff;
const NR_OF_SUPPORTET_LANG: usize = 13;
const CARD_LEN: usize = 12;
const ERRR: i32 = 0x0FFF_AFFF_u32 as i32;
const LLL_CLI_HELP_MESSAGE: &str = "\
rustc -O -C panic=abort lll.rs -o lll
-s --size sort by size
-l --ls ls like output
-h --help print help
-p --path set path default is current
-q --qqqq print all absolut paths of a folder
@VERSION 10.0.0
";
#[repr(C)]
struct Passwd {
pw_name: *mut LllLibcChar,
pw_passwd: *mut LllLibcChar,
pw_uid: u32,
pw_gid: u32,
pw_gecos: *mut LllLibcChar,
pw_dir: *mut LllLibcChar,
pw_shell: *mut LllLibcChar,
}
#[repr(C)]
struct Group {
gr_name: *mut LllLibcChar,
gr_passwd: *mut LllLibcChar,
gr_gid: u32,
gr_mem: *mut *mut LllLibcChar,
}
type LllLibcChar = i8;
extern "C" {
fn getpwuid(uid: u32) -> *mut Passwd;
fn getgrgid(gid: u32) -> *mut Group;
}
#[derive(Clone)]
struct TypeEntry {
name: &'static str,
countet_size: u64,
globalsumindex: i32,
}
static mut TYPES: [TypeEntry; NR_OF_SUPPORTET_LANG] = [
TypeEntry { name: "", countet_size: 0, globalsumindex: 0 },
TypeEntry { name: "c", countet_size: 0, globalsumindex: 1 },
TypeEntry { name: "cpp", countet_size: 0, globalsumindex: 2 },
TypeEntry { name: "ino", countet_size: 0, globalsumindex: 3 },
TypeEntry { name: "py", countet_size: 0, globalsumindex: 4 },
TypeEntry { name: "java", countet_size: 0, globalsumindex: 5 },
TypeEntry { name: "sh", countet_size: 0, globalsumindex: 6 },
TypeEntry { name: "js", countet_size: 0, globalsumindex: 7 },
TypeEntry { name: "html", countet_size: 0, globalsumindex: 8 },
TypeEntry { name: "asm", countet_size: 0, globalsumindex: 9 },
TypeEntry { name: "rs", countet_size: 0, globalsumindex: 10 },
TypeEntry { name: "sql", countet_size: 0, globalsumindex: 11 },
TypeEntry { name: "h", countet_size: 0, globalsumindex: 1 },
];
static NAME_LIST: [&str; NR_OF_SUPPORTET_LANG] = [
"Undefined", "C", "C++", "ESP", "Python", "Java", "ShellScript", "JavaScript", "HTML",
"Assembly", "Rust", "SQL", "C",
];
static COLOR_LIST: [u64; NR_OF_SUPPORTET_LANG] = [
0x2222_0778_77CC,
0x2222_0566_6666,
0x2222_0A22_22FF,
0x2222_0FEE_AA00,
0x2222_00A8_A862,
0x2222_00FF_FF00,
0x2222_00FF_0010,
0x2222_00BB_0010,
0x2222_0088_8888,
0x2222_00FF_8800,
0x2222_00DE_A584,
0x2222_0000_00FF,
0x2222_0566_6666,
];
fn coloramaprintifarma(ptext: &str, col: u64) -> String {
let bg_r = ((col >> 40) & 0xFF) as u8;
let bg_g = ((col >> 32) & 0xFF) as u8;
let bg_b = ((col >> 24) & 0xFF) as u8;
let fg_r = ((col >> 16) & 0xFF) as u8;
let fg_g = ((col >> 8) & 0xFF) as u8;
let fg_b = (col & 0xFF) as u8;
format!(
"\x1b[38;2;{};{};{}m\x1b[48;2;{};{};{}m{}\x1b[0m",
fg_r, fg_g, fg_b, bg_r, bg_g, bg_b, ptext
)
}
fn utf8_char_len_local(c: u8) -> usize {
if c < 0x80 {
1
} else if (c >> 5) == 0x6 {
2
} else if (c >> 4) == 0xE {
3
} else if (c >> 3) == 0x1E {
4
} else {
1
}
}
fn pad_utf8(text: &str, mse: usize) -> String {
let bytes = text.as_bytes();
let mut res = Vec::with_capacity(mse + 4);
let mut pos = 0usize;
let mut i = 0usize;
while pos < mse && i < bytes.len() {
let clen = utf8_char_len_local(bytes[i]);
if pos + clen > mse {
break;
}
if i + clen > bytes.len() {
break;
}
res.extend_from_slice(&bytes[i..i + clen]);
pos += clen;
i += clen;
}
while pos < mse {
res.push(b' ');
pos += 1;
}
String::from_utf8_lossy(&res).into_owned()
}
fn coloramaprintifarmafillup(text: &str, advansed_color: u64) -> String {
let padded = pad_utf8(text, CARD_LEN);
coloramaprintifarma(&padded, advansed_color)
}
fn coll(col: u64, ptext: &str) -> String {
let r = ((col >> 16) & 0xFF) as u8;
let g = ((col >> 8) & 0xFF) as u8;
let b = (col & 0xFF) as u8;
format!("\x1b[38;2;{};{};{}m{}\x1b[0m", r, g, b, ptext)
}
fn chngg(pp: &str, color: u64, more_space: i32) -> String {
let mse = match more_space {
1 => CARD_LEN * 3,
2 => CARD_LEN + 3,
3 => CARD_LEN.saturating_sub(3),
_ => CARD_LEN,
};
let padded = pad_utf8(pp, mse);
coll(color, &padded)
}
fn chngg_wrapper(index: i32) -> String {
let idx = if index < 0 || index as usize >= NR_OF_SUPPORTET_LANG {
0
} else {
index as usize
};
coloramaprintifarmafillup(NAME_LIST[idx], COLOR_LIST[idx])
}
fn mode_to_str(mode: u32) -> String {
let mut out = String::with_capacity(10);
let ft = mode & 0o170000;
out.push(match ft {
0o040000 => 'd',
0o120000 => 'l',
0o020000 => 'c',
0o060000 => 'b',
0o010000 => 'p',
0o140000 => 's',
_ => '-',
});
out.push(if mode & 0o400 != 0 { 'r' } else { '-' });
out.push(if mode & 0o200 != 0 { 'w' } else { '-' });
out.push(if mode & 0o100 != 0 { 'x' } else { '-' });
out.push(if mode & 0o040 != 0 { 'r' } else { '-' });
out.push(if mode & 0o020 != 0 { 'w' } else { '-' });
out.push(if mode & 0o010 != 0 { 'x' } else { '-' });
out.push(if mode & 0o004 != 0 { 'r' } else { '-' });
out.push(if mode & 0o002 != 0 { 'w' } else { '-' });
out.push(if mode & 0o001 != 0 { 'x' } else { '-' });
out
}
fn process_size(size: u64) -> String {
let units = ["B", "KB", "MB", "GB", "TB"];
let mut s = size as f64;
let mut u = 0usize;
while s >= 1024.0 && u < 4 {
s /= 1024.0;
u += 1;
}
format!("{:.1} {}", s, units[u])
}
fn get_type_ind_by_name(type_s: &str) -> i32 {
unsafe {
for i in 1..NR_OF_SUPPORTET_LANG {
if !TYPES[i].name.is_empty() && TYPES[i].name == type_s {
return i as i32;
}
}
}
ERRR
}
fn add_type_value(pp_index: i32, filesize: u64) -> i32 {
if pp_index < 0 || pp_index as usize >= NR_OF_SUPPORTET_LANG {
return -1;
}
unsafe {
TYPES[pp_index as usize].countet_size =
TYPES[pp_index as usize].countet_size.saturating_add(filesize);
}
0
}
fn get_type(fullpath: &str, filesize: u64) {
let bytes = fullpath.as_bytes();
let size = bytes.len() as i32;
if size <= 0 {
return;
}
let mut point_index: i32 = -1;
let mut i = size - 1;
loop {
if bytes[i as usize] == b'.' {
point_index = i;
break;
}
if bytes[i as usize] == b'/' {
point_index = -1;
break;
}
if i == 0 {
break;
}
i -= 1;
}
if point_index <= 0 {
return;
}
let start = (point_index + 1) as usize;
if start >= bytes.len() {
return;
}
let type_s = match std::str::from_utf8(&bytes[start..]) {
Ok(s) => s,
Err(_) => return,
};
let index = get_type_ind_by_name(type_s);
if index != ERRR {
add_type_value(index, filesize);
}
}
fn is_mount_point(path: &Path) -> bool {
let st_path = match fs::metadata(path) {
Ok(m) => m,
Err(_) => return false,
};
let parent = path.join("..");
let st_parent = match fs::metadata(&parent) {
Ok(m) => m,
Err(_) => return false,
};
st_path.dev() != st_parent.dev()
}
fn store_modification_timestamp(metadata: &Metadata, timestamp: &mut i64) {
if let Ok(modified) = metadata.modified() {
if let Ok(duration) = modified.duration_since(UNIX_EPOCH) {
if *timestamp < duration.as_secs() as i64 {
*timestamp = duration.as_secs() as i64;
}
}
}
}
fn folder_size(path: &Path, ts_max: &mut i64) -> u64 {
if is_mount_point(path) {
return 0;
}
let mut total: u64 = 0;
let rd = match fs::read_dir(path) {
Ok(d) => d,
Err(_) => return 0,
};
for entry in rd.flatten() {
let name = entry.file_name();
if name == "." || name == ".." {
continue;
}
let full = entry.path();
let st = match fs::symlink_metadata(&full) {
Ok(m) => m,
Err(_) => continue,
};
if st.file_type().is_dir() {
total = total.saturating_add(folder_size(&full, ts_max));
} else if st.file_type().is_symlink() {
continue;
} else {
store_modification_timestamp(&st, ts_max);
let sz = st.len();
total = total.saturating_add(sz);
if let Some(s) = full.to_str() {
get_type(s, sz);
}
}
}
total
}
fn get_dom_lang_index() -> i32 {
let mut local_sums = [0u64; NR_OF_SUPPORTET_LANG];
unsafe {
for i in 1..NR_OF_SUPPORTET_LANG {
let g = TYPES[i].globalsumindex;
if g >= 0 && (g as usize) < NR_OF_SUPPORTET_LANG {
local_sums[g as usize] = local_sums[g as usize].saturating_add(TYPES[i].countet_size);
}
}
}
let mut max_idx = 0i32;
let mut max_val = 0u64;
for i in 0..NR_OF_SUPPORTET_LANG {
if local_sums[i] > max_val {
max_val = local_sums[i];
max_idx = i as i32;
}
}
unsafe {
for i in 0..NR_OF_SUPPORTET_LANG {
TYPES[i].countet_size = 0;
}
}
max_idx
}
fn get_dom_single_file_index_from_path(path: &str) -> i32 {
let ext = Path::new(path)
.extension()
.and_then(|e| e.to_str())
.unwrap_or("");
unsafe {
for i in 0..NR_OF_SUPPORTET_LANG {
if !TYPES[i].name.is_empty() && TYPES[i].name == ext {
return i as i32;
}
}
}
0
}
fn clipper(content: &str) {
let mut child = match Command::new("xclip")
.arg("-selection")
.arg("clipboard")
.stdin(Stdio::piped())
.spawn()
{
Ok(c) => c,
Err(_) => return,
};
if let Some(mut stdin) = child.stdin.take() {
let _ = stdin.write_all(content.as_bytes());
}
let _ = child.wait();
}
fn uid_name(uid: u32) -> String {
unsafe {
let pw = getpwuid(uid);
if pw.is_null() {
return "unknown".to_string();
}
let name = (*pw).pw_name;
if name.is_null() {
return "unknown".to_string();
}
std::ffi::CStr::from_ptr(name)
.to_string_lossy()
.into_owned()
}
}
fn gid_name(gid: u32) -> String {
unsafe {
let gr = getgrgid(gid);
if gr.is_null() {
return "unknown".to_string();
}
let name = (*gr).gr_name;
if name.is_null() {
return "unknown".to_string();
}
std::ffi::CStr::from_ptr(name)
.to_string_lossy()
.into_owned()
}
}
fn format_mtime(secs: i64) -> String {
extern "C" {
fn localtime_r(timep: *const i64, result: *mut LibcTm) -> *mut LibcTm;
fn strftime(
s: *mut i8,
max: usize,
format: *const i8,
tm: *const LibcTm,
) -> usize;
}
#[repr(C)]
struct LibcTm {
tm_sec: i32,
tm_min: i32,
tm_hour: i32,
tm_mday: i32,
tm_mon: i32,
tm_year: i32,
tm_wday: i32,
tm_yday: i32,
tm_isdst: i32,
tm_gmtoff: i64,
tm_zone: *const i8,
}
unsafe {
let mut tm: LibcTm = mem::zeroed();
let t = secs;
if localtime_r(&t, &mut tm).is_null() {
return String::from("?");
}
let mut buf = [0i8; 64];
let fmt = b"%e. %b %H:%M\0";
let n = strftime(
buf.as_mut_ptr(),
buf.len(),
fmt.as_ptr() as *const i8,
&tm,
);
if n == 0 {
return String::from("?");
}
std::ffi::CStr::from_ptr(buf.as_ptr())
.to_string_lossy()
.trim()
.to_string()
}
}
fn get_absolut_path(name: &str) {
let cwd = match env::current_dir() {
Ok(p) => p,
Err(e) => {
eprintln!("ERROR: getcwd: {}", e);
return;
}
};
let mut absolut = cwd;
absolut.push(name);
let s = absolut.to_string_lossy().into_owned();
println!("{}", s);
clipper(&s);
}
fn sort_by_timestamp(unix_timestamps: &mut [i64], rows: &mut [String]) {
let n = unix_timestamps.len();
if n <= 1 {
return;
}
for i in 0..n - 1 {
let mut max_index = i;
for j in i + 1..n {
if unix_timestamps[j] > unix_timestamps[max_index] {
max_index = j;
}
}
if max_index != i {
unix_timestamps.swap(i, max_index);
rows.swap(i, max_index);
}
}
rows.reverse();
unix_timestamps.reverse();
}
fn sort_by_size(sizes: &mut [u64], rows: &mut [String]) {
let n = sizes.len();
if n <= 1 {
return;
}
for i in 0..n - 1 {
let mut max_index = i;
for j in i + 1..n {
if sizes[j] < sizes[max_index] {
max_index = j;
}
}
if max_index != i {
sizes.swap(i, max_index);
rows.swap(i, max_index);
}
}
}
fn print_absolut_paths(path_to_process: &str) {
let rd = match fs::read_dir(path_to_process) {
Ok(d) => d,
Err(e) => {
eprintln!("opendir: {}", e);
return;
}
};
let is_dot = path_to_process.starts_with('.');
let cwd = env::current_dir().ok();
for entry in rd.flatten() {
let name = entry.file_name();
if name == "." || name == ".." {
continue;
}
let name_s = name.to_string_lossy();
if is_dot {
if let Some(ref p) = cwd {
println!("{}/{}", p.display(), name_s);
}
} else {
println!("{}/{}", path_to_process.trim_end_matches('/'), name_s);
}
}
}
fn main_lll_impl(sort_by_size_flag: bool, path_to_process: &str) -> i32 {
let rd = match fs::read_dir(path_to_process) {
Ok(d) => d,
Err(e) => {
eprintln!("opendir: {}", e);
return 1;
}
};
let mut rows: Vec<String> = Vec::new();
let mut sizes: Vec<u64> = Vec::new();
let mut unix_timestamps: Vec<i64> = Vec::new();
for entry in rd.flatten() {
let name_os = entry.file_name();
if name_os == "." || name_os == ".." {
continue;
}
let name = name_os.to_string_lossy();
let full: PathBuf = Path::new(path_to_process).join(&*name);
let st = match fs::symlink_metadata(&full) {
Ok(m) => m,
Err(_) => continue,
};
let mode = st.mode();
let perms = mode_to_str(mode);
let links = st.nlink();
let owner = uid_name(st.uid());
let group = gid_name(st.gid());
let ft = st.file_type();
let raw_size: u64;
let sizebuf: String;
let mut timestamp: i64 = 0;
if ft.is_dir() {
raw_size = folder_size(&full, &mut timestamp);
sizebuf = process_size(raw_size);
if let Some(s) = full.to_str() {
get_type(s, raw_size);
}
} else {
store_modification_timestamp(&st, &mut timestamp);
raw_size = st.len();
sizebuf = process_size(raw_size);
if let Some(s) = full.to_str() {
get_type(s, raw_size);
}
}
let timestr = format_mtime(timestamp);
let ja_index = get_dom_lang_index();
let line = if ft.is_symlink() {
match fs::read_link(&full) {
Ok(target) => {
let t = target.to_string_lossy();
format!(
"{} {:3} {} {} {:>8} {} {} -> {}",
perms, links, owner, group, sizebuf, timestr, name, t
)
}
Err(_) => format!(
"{} {:3} {} {} {:>8} {} {}",
perms, links, owner, group, sizebuf, timestr, name
),
}
} else {
let owner_col = chngg(&owner, 0x44FF44, 0);
let group_col = chngg(&group, 0x88FF88, 0);
let size_col = chngg(&sizebuf, 0xFF0000, 3);
let time_col = chngg(&timestr, 0x888866, 2);
let type_fld = chngg_wrapper(ja_index);
let name_col = chngg(
&name,
if ft.is_dir() { 0x9999FF } else { 0xFF33FF },
1,
);
format!(
"{} {:3} {} {} {:>8} {} {} {}",
perms, links, owner_col, group_col, size_col, time_col, type_fld, name_col
)
};
rows.push(line);
sizes.push(raw_size);
unix_timestamps.push(timestamp);
}
if !rows.is_empty() {
if sort_by_size_flag {
sort_by_size(&mut sizes, &mut rows);
} else {
sort_by_timestamp(&mut unix_timestamps, &mut rows);
}
}
for row in &rows {
println!("{}", row);
}
0
}
fn main_ls_impl() -> i32 {
let rd = match fs::read_dir(".") {
Ok(d) => d,
Err(e) => {
eprintln!("opendir: {}", e);
return 1;
}
};
let mut entries: Vec<String> = Vec::new();
for entry in rd.flatten() {
let name_os = entry.file_name();
if name_os == "." || name_os == ".." {
continue;
}
let name = name_os.to_string_lossy();
let full = PathBuf::from(format!("./{}", name));
let st = match fs::symlink_metadata(&full) {
Ok(m) => m,
Err(_) => continue,
};
let ft = st.file_type();
let mut max_date_ts: i64 = 0;
if ft.is_dir() {
let _ = folder_size(&full, &mut max_date_ts);
}
let links = st.nlink();
let lang_idx = if ft.is_dir() {
get_dom_lang_index()
} else {
get_dom_single_file_index_from_path(full.to_str().unwrap_or(""))
};
let name_color: u64 = if ft.is_dir() { 0x9999FF } else { 0xFF33FF };
let type_fld = chngg_wrapper(lang_idx);
let project_name = chngg(&name, name_color, 1);
let _ = {
let b = project_name.as_bytes();
let take = b.len().min(45);
String::from_utf8_lossy(&b[..take]).into_owned()
};
let line = format!("{:5} {:>8} {:>46}", links, type_fld, project_name);
entries.push(line);
}
let mut i = 0usize;
while i < entries.len() {
let end = (i + 4).min(entries.len());
let mut line = String::new();
for j in i..end {
if j > i {
line.push(' ');
}
line.push_str(&entries[j]);
}
println!("{}", line);
i = end;
}
0
}
fn main() {
let args: Vec<String> = env::args().collect();
let argc = args.len();
let exit_code = if argc == 1 {
main_lll_impl(false, ".")
} else if argc == 2 || argc == 3 {
let a1 = args[1].as_str();
if a1 == "-s" || a1 == "--size" {
main_lll_impl(true, ".")
} else if a1 == "-l" || a1 == "--ls" {
main_ls_impl()
} else if a1 == "-h" || a1 == "--help" {
print!("{}", LLL_CLI_HELP_MESSAGE);
println!("FILE_SYSTEM_MAX_PATH : {}", FILE_SYSTEM_MAX_PATH);
0
} else if a1 == "-p" || a1 == "--path" {
if argc != 3 {
eprintln!("Unbekannter Parameter oder falsche Nutzung");
1
} else {
main_lll_impl(false, &args[2])
}
} else if a1 == "-q" || a1 == "--qqqq" {
if argc == 2 {
print_absolut_paths(".");
} else {
print_absolut_paths(&args[2]);
}
0
} else {
get_absolut_path(&args[1]);
0
}
} else {
eprintln!("Unbekannter Parameter oder falsche Nutzung");
1
};
std::process::exit(exit_code);
}