Byla vydána nová stabilní verze 3.22.0, tj. první z nové řady 3.22, minimalistické linuxové distribuce zaměřené na bezpečnost Alpine Linux (Wikipedie) postavené na standardní knihovně jazyka C musl libc a BusyBoxu. Přehled novinek v poznámkách k vydání.
FEL ČVUT vyvinula robotickou stavebnici pro mladé programátory. Stavebnice Brian byla navržená speciálně pro potřeby populární Robosoutěže. Jde ale také o samostatný produkt, který si může koupit každý fanoušek robotiky a programování od 10 let, ideální je i pro střední školy jako výuková pomůcka. Jádro stavebnice tvoří programovatelná řídicí jednotka, kterou vyvinul tým z FEL ČVUT ve spolupráci s průmyslovými partnery. Stavebnici
… více »Ubuntu bude pro testování nových verzí vydávat měsíční snapshoty. Dnes vyšel 1. snapshot Ubuntu 25.10 (Questing Quokka).
Společnost Netgate oznámila vydání nové verze 2.8.0 open source firewallové, routovací a VPN platformy pfSense (Wikipedie) postavené na FreeBSD. Přehled novinek v poznámkách k vydání.
Byla vydána nová verze 6.16 živé linuxové distribuce Tails (The Amnesic Incognito Live System), jež klade důraz na ochranu soukromí uživatelů a anonymitu. Tor Browser byl povýšen na verzi 14.5.3. Linux na verzi 6.1.140. Další změny v příslušném seznamu.
Člověk odsouzený za obchod s drogami daroval letos ministerstvu spravedlnosti 468 kusů kryptoměny bitcoin, které pak resort v aukcích prodal za skoro miliardu korun. Darováním se zabývá policejní Národní centrála proti organizovanému zločinu (NCOZ). Deníku N to potvrdil přímo ministr spravedlnosti Pavel Blažek (ODS). Podle resortu bylo nicméně vše v souladu s právem.
Svobodný a otevřený multiplatformní editor EPUB souborů Sigil (Wikipedie, GitHub) byl vydán ve verzi 2.5.0. Stejně tak doprovodný vizuální EPUB XHTML editor PageEdit (GitHub).
Na základě národního atribučního procesu vláda České republiky označila Čínskou lidovou republiku za zodpovědnou za škodlivou kybernetickou kampaň proti jedné z neutajovaných komunikačních sítí Ministerstva zahraničních věcí ČR. Tato škodlivá aktivita, která trvala od roku 2022 a zasáhla instituci zařazenou na seznam české kritické infrastruktury, byla provedena kyberšpionážní skupinou APT31, veřejně spojovanou se zpravodajskou službou Ministerstvo státní bezpečnosti (MSS).
Google Chrome 137 byl prohlášen za stabilní. Nejnovější stabilní verze 137.0.7151.55 přináší řadu novinek z hlediska uživatelů i vývojářů. Podrobný přehled v poznámkách k vydání. Opraveno bylo 11 bezpečnostních chyb. Vylepšeny byly také nástroje pro vývojáře.
Byl vydán AlmaLinux OS 10 s kódovým názvem Purple Lion. Podrobnosti v poznámkách k vydání. Na rozdíl od Red Hat Enterprise Linuxu 10 nadále podporuje x86-64-v2.
void watch_dir(char *file) { int ret; struct stat buf; struct dirent *data; char *path = NULL; if (lstat(file, &buf)) return; if (!S_ISDIR(buf.st_mode)) return; DIR *dir = opendir(file); if (dir == NULL) return; //char *path2 = NULL; while ((data = readdir(dir)) != NULL) { if (strcmp(data->d_name, ".") == 0 || strcmp(data->d_name, "..") == 0) continue; if (strstr(data->d_name, ".") == data->d_name) continue; path = (char *) malloc(strlen(file) + strlen(data->d_name) +1 * sizeof (path)); asprintf(&path, "%s/%s", file, data->d_name); if (lstat(path, &buf)) continue; //If it's a dir then launch watch_dir himself on it if (S_ISDIR(buf.st_mode)) watch_dir(path); } closedir(dir); // now set watch for the argument of watch_dir ret = inotify_add_watch(inotify, file, IN_ALL_EVENTS); if (ret == -1) { printf("%s\n", file); perror("Error in watcher setting\n"); exit(0); } strcpy(files[ret], file); free(path); path = NULL; return; }Valgrind hlasi:
==10177== Invalid write of size 1 ==10177== at 0x4A09350: strcpy (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) ==10177== by 0x4011C9: watch_dir (testclient1.c:147) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401274: handle_event (testclient1.c:169) ==10177== by 0x401945: main (testclient1.c:353) ==10177== Address 0x704180 is not stack'd, malloc'd or (recently) free'd ==10177== ==10177== ==10177== Process terminating with default action of signal 11 (SIGSEGV) ==10177== Access not within mapped region at address 0x704180 ==10177== at 0x4A09350: strcpy (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so) ==10177== by 0x4011C9: watch_dir (testclient1.c:147) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401138: watch_dir (testclient1.c:132) ==10177== by 0x401274: handle_event (testclient1.c:169) ==10177== by 0x401945: main (testclient1.c:353)Problem je tedy v nejake ctvrte rekurzi. Myslim, ze blbe mallocuju path, ktery se pridava do rekurzivniho volani. A pokud ho blbe nemallocuju, tak ho urcite blbe uvolnuji pomoci free. Chci vas poprosit o radu, jak to spravne osetrit. Fce je soucasti klienta, ktery rekurzivne pomoci inotify monitoruje zadany adresar. Cely klient je zde:
int inotify; char files[1024][1024]; struct inotify_event *event; struct sockaddr_in serv_addr; int sockfd; /** * @brief Test if only a correct message is about to be sent * * @param s * @return */ int is_empty(const char *s) { char buff[1024]; strcpy(buff,s);; buff[strlen(buff)] = '\0'; if (buff[0] == '/' || isdigit(buff[0])){ return 1; } return 0; } /** * @brief Sends a message to the server. * * @param message * @param portno */ void send_msg(char *message, int portno) { int n; char recvbuff[256]; serv_addr.sin_port = htons(portno); sockfd = socket(AF_INET, SOCK_STREAM, 0); bzero(recvbuff, 256); if (sockfd < 0) perror("send_msg: ERROR opening socket"); if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) perror("send msg: ERROR connecting"); n = write(sockfd, message, strlen(message) +1); if (n < 0) perror("send msg: ERROR writing to socket"); n = read(sockfd, recvbuff, 256); if (n < 0) perror(" send_msg: ERROR reading from socket"); printf("%s\n", recvbuff); free(message); message = NULL; close(sockfd); } /** * @brief Recursively watches a directory. * * @param file */ void watch_dir(char *file) { int ret; struct stat buf; struct dirent *data; char *path = NULL; if (lstat(file, &buf)) return; if (!S_ISDIR(buf.st_mode)) return; DIR *dir = opendir(file); if (dir == NULL) return; //char *path2 = NULL; while ((data = readdir(dir)) != NULL) { if (strcmp(data->d_name, ".") == 0 || strcmp(data->d_name, "..") == 0) continue; if (strstr(data->d_name, ".") == data->d_name) continue; path = (char *) malloc(strlen(file) + strlen(data->d_name) +1 * sizeof (path)); asprintf(&path, "%s/%s", file, data->d_name); if (lstat(path, &buf)) continue; //If it's a dir then launch watch_dir himself on it if (S_ISDIR(buf.st_mode)) watch_dir(path); } closedir(dir); // now set watch for the argument of watch_dir ret = inotify_add_watch(inotify, file, IN_ALL_EVENTS); if (ret == -1) { printf("%s\n", file); perror("Error in watcher setting\n"); exit(0); } strcpy(files[ret], file); free(path); path = NULL; return; } /** * @brief Handles notified events. * * @param path * @param dest */ void handle_event(char *path, char *dest, int portno) { char *message = (char *) malloc((strlen(path) * sizeof (message)) + 10); if (event->mask & IN_CREATE) { if (event->mask & IN_ISDIR) { printf("The directory %s was created.\n", event->name); watch_dir(dest); } else { printf("The file %s was created.\n", event->name); } asprintf(&message, "%d:%d:%s", IN_CREATE, (int) strlen(dest), path); int j = is_empty(message); if (j == 1) send_msg(message, portno); //printf("") } else if (event->mask & IN_DELETE) { if (event->mask & IN_ISDIR) { printf("The directory %s was deleted.\n", event->name); } else { printf("The file %s was deleted.\n", event->name); } asprintf(&message, "%d:%d:%s", IN_DELETE, (int) strlen(dest), path); int j = is_empty(message); if (j == 1) send_msg(message, portno); } else if (event->mask & IN_MODIFY) { if (event->mask & IN_ISDIR) { printf("The directory %s was modified.\n", event->name); } else { printf("The file %s was modified.\n", event->name); } asprintf(&message, "%d:%d:%s", IN_MODIFY, (int) strlen(dest), path); int j = is_empty(message); if (j == 1) send_msg(message, portno); } else if (event->mask & IN_MOVED_FROM) { if (event->mask & IN_ISDIR) { printf("Directory %s with cookie %d has been " "moved from the sync directory.\n", event->name, event->cookie); } else { printf("Directory %s with cookie %d has been " "moved from the sync directory.\n", event->name, event->cookie); } asprintf(&message, "%d:%d:%s", IN_MOVED_FROM, (int) strlen(dest), path); int j = is_empty(message); if (j == 1) send_msg(message, portno); } else if (event->mask & IN_MOVED_TO) { if (event->mask & IN_ISDIR) { printf("Directory %s with cookie %d has been " "moved to the sync directory.\n", event->name, event->cookie); watch_dir(dest); } else { printf("Directory %s with cookie %d has been " "moved to the sync directory.\n", event->name, event->cookie); } asprintf(&message, "%d:%d:%s", IN_MOVED_TO, (int) strlen(dest), path); int j = is_empty(message); if (j == 1) send_msg(message, portno); } else { free(message); message = NULL; } free(path); path = NULL; } int main(int agrc, char *argv[]) { int portno, n; struct hostent *server; char buffer[4096]; char *dest = malloc(strlen(argv[1]) + 1); strcpy(dest, argv[1]); inotify = inotify_init(); if (!inotify) { perror("Open inotify device"); fprintf(stderr, "Are you sure your kernel supports inotify?\n"); } //launch recursive watching watch_dir(dest); printf("Start monitoring!\n"); portno = atoi(argv[2]); server = gethostbyname("localhost"); if (server == NULL) { fprintf(stderr, "ERROR, no such host\n"); exit(0); } bzero((char *) &serv_addr, sizeof (serv_addr)); serv_addr.sin_family = AF_INET; bcopy((char *) server->h_addr, (char *) &serv_addr.sin_addr.s_addr, server->h_length); /*First connection to the server. * Client sends to a server a path * to client's "dropbox" folder*/ serv_addr.sin_port = htons(portno); sockfd = socket(AF_INET, SOCK_STREAM, 0); if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) perror("ERROR connecting"); n = write(sockfd, dest, strlen(dest) + 1); if (n < 0) perror("ERROR writing to socket"); close(sockfd); while (1) { int ret; int i = 0; ret = read(inotify, buffer, 4096); if (ret < 0) perror("read"); if (ret == 0) sleep(1); char *path = NULL; while (i < ret) { char *name = NULL; event = (struct inotify_event *) &buffer[i]; if (event->len) name = &buffer[i] + sizeof (struct inotify_event); path = (char *) malloc(1024 * sizeof (path)); asprintf(&path, "%s/%s", files[event->wd], name); handle_event(path, dest, portno); i += sizeof (struct inotify_event) +event->len; //free(path); //path = NULL; } } close(sockfd); return 0; }
Řešení dotazu:
path = (char *) malloc((strlen(file) + strlen(data->d_name) + 2) * sizeof (char));
Pravidlo: „Když nevíš, závorkuj.“
JSem se jen zběžně juknul a akdž bylo napsáno mallocuju, tak jsem se podíval jen na malloc.
Více, pravda - o 3 nebo 7 byte, sizeof(char) je vždy 1, asi jsem moc nepřemýšlel, viděl jsem divné násobení velikostí a hotovo...
Jo-jo free(path);
, by mělo být ve smyčce také - na jejím konci, ne až mimo na konci fce, jinak dochází k „memory leak“.
Nicméně problém bude spíše v zápis mimo files[1024][1024]
na 147 řádku (hlášení je o zápisu mimo alokovaný prostor):
strcpy(files[ret], file);nevím jakých hodnot nabývá watch descriptor, nicméně nikde se nepíše, že je < 1024, jak je asi zamýšleno v kódu, stejně jako maximální možná délka pro
file
, parametr fce watch_dir
, 1023 znaků).
K autorovi: „Ošetřit návrat malloc()
na NULL
je opravdu dobrý nápad a základ...“
char files[10000][1024];Tak to nepada. Ale to mi prijde uz dost robustni. Premyslim, co s tim. Bud do protokolu (ktery k programu musim psat) napisu proste, ze to ma takove a takove omezeni, nebo se s tim nejak vyporadam dynamicky, jenze jak?
Nesouvisí ale neošetření alokace paměti je fatální chyba v 99 % případů.
Watch descriptor jako index pole je CHYBA, dle man-u inotify_add_watch
vrací při úspěchu nezápornou hodnotu, tedy >= 0 <= INT_MAX, nikde není zaručeno, že to začne na 0. Zvětšení velikosti pole není robustní, ale stále stejně špatně a postup (zvětšování pole až to vyjde) je nesprávný.
Vypořádat se - rozhodně dynamicky a to plně, tedy i pro délku, céčko má výhodu (oproti c++), že lze použít fci realloc
a ta často umí to, že alokovanou pamět „jen prodlužuje“ (pokud nelze tak alokuje novou a obsah zkopíruje), takže si můžeš nachystat třeba na 1000 položek a pak po 1000 přidávat - jen bych přehodnotil přístup watch descriptor = index.
Malá rada, když jsi v situaci kdy nevíš co dělat (v dané fázi, či nedostatkem zkušeností co s tím) při zklamání čehokoliv (třeba malloc), prostě to zabij, vytvoř si macro či třeba fci, která vypíše řádek s jedním volitelným textovým parametrem (jako komentář) a v té fci volej exit(), případně abort(). A tuto fci použij při zklamání takového kódu, v budoucnu si můžeš, postupně jednoduchým grepem ta místa lokalizovat a postupně řešit.
#define MY_KILL_ON_ERROR(text) { \ fprintf(stderr,"KILLED ON ERROR: %s\nAt: %s Line: %d" \ ,text,__FILE__, __LINE__); \ exit(3); \ }Použití:
MY_KILL_ON_ERROR("Not enought memory")
…céčko má výhodu (oproti c++), že lze použít fci realloc…Proč by to v C++ nemělo jít? Mě naopak při pohledu na ten kód jako první napadlo že jeden std::vector by autorovi ušetřil spoustu potíží.
Asi jsem to blbě napsal. C++ by mu usnadnilo hodně věcí, hlavně ve správě paměti - o tom žádná. (Pokud ovšem použije dané kontejnery, ale bez nich by to zas tak úplně nebylo C++ ;))
Poukazoval jsem na rozdíl, že v C lze použít fci realloc
, která může daný blok paměti jen zvětšit, což je efektivnější než alokovat druhý blok a obsah paměti kopírovat.
OT: A může ji i zmenšit bez alokace nového bloku oboje na rozdíl od uváděného std::vector
což nemá v tomto případě žádný faktický dopad, ale rozdíl to je a někdy se to hodí.
jen bych přehodnotil přístup watch descriptor = index.Me bohuzel zadny lepsi zpusob nenapada. Potreboval jsem rekurzivne monitorovat celou adresarovou stukturu, inotify rekurzivne nemonitoruje a tohle se mi jevilo jako jedine reseni. Napada te nejake lepsi?
Received message: 256:32:/home/tomesh/Development/dropbox/New Folder/Text File Received message: 2:32:/home/tomesh/Development/dropbox/New Folder/Text File Received message: 64:32:/home/tomesh/Development/dropbox/New Folder Received message: 128:32:/home/tomesh/Development/dropbox/u Received message: 256:32:/home/tomesh/Development/dropbox/New Folder/.Text File.kate-swp Received message: 2:32:/home/tomesh/Development/dropbox/New Folder/.Text File.kate-swp256 je inotify flag pro CREATE. 2 pro MODIFY, 64 pro MOVED_FROM a 128 pro MOVED_TO. Vypis rika, ze se adresar New Folder prejmenoval na 'u'. Nejdriv se odstrani stary(64) a pak se vlozi novy (128) se stejnym cookie. Muj klient tohle zachycuje a server se podle toho zaridi. Klient tedy spatne monitoruje, tak mi pak server hodi segfault, protoze dostane zpravu o zmene souboru v neexistujicim adresari. Muze to byt zrovna timhle, ze pouzivam polep ro mapovani deskriptoru?
The inotify API identifies affected files by filename. However, by the time an application processes an inotify event, the filename may already have been deleted or renamed. If monitoring an entire directory subtree, and a new subdirectory is created in that tree, be aware that by the time you create a watch for the new subdirectory, new files may already have been created in the subdirectory. Therefore, you may want to scan the contents of the subdirectory immediately after adding the watch.Takze muj hrubej odhad je, ze chyba je spis ve spatny praci s inotfiy, nez ve zvolenejch strukturach. Ale jak uz bylo receno. Pouziti pole neni zrovna robustni a pouzil bych radsi hash tabulku.
Taka poznamka mimo: Segmentation fault urcite nie je sposobeny chybnou alokaciou path, kedze asprintf si alokuje pamat sam (preto tam ide char **).
Chyba v tej alokacii je a to ta, ze sa vobec nejaka manualna alokacia premennej path robi.
asprintf
nepoužívám a man jsem nedočetl…
Tiskni
Sdílej: