721
Vývoj / Re:[C] Ako prečíst dáta zo súboru a zapísať je do PIPE-y když proces prijme signál?
« kdy: 06. 01. 2019, 21:15:39 »
Neviditelný, máte Github? že by som Vás pridal do repa, aby ste sa mi na to pozrel.
Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.
----------------------------------------------------
Runner:Spustam:
runner: Maximalny cas behu 120 sekund
Runner:kill
runner: Skutocny cas behu:121 s
runner: ukoncujem ostatne procesy:
Segment 1024 nemozno vymazat!
runner: Ukoncenych 3 procesov
Segment 1024 nemozno vymazat!
runner:OK
runner:vraciam 130
Pokud chceš posílat signály sám sobě, potřebuješ getpid(). Protože ale to cvičení řeší komunikaci mezi procesy, chceš ve skutečnosti signalizovat mezi rodiči a potomky. Funguje třeba toto:Kód: [Vybrat]#define _POSIX_C_SOURCE 199506L
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
static int pipefd[2];
static sigset_t sset;
static
void write_to_pipe()
{
size_t idx = 0;
int sigret;
FILE *fh;
char buf[151];
close(pipefd[0]);
if (sigwait(&sset, &sigret) != 0)
_exit(EXIT_FAILURE);
if (sigret != SIGUSR1)
_exit(EXIT_FAILURE);
fh = fopen("p1.txt", "r");
if (fh == NULL)
_exit(EXIT_FAILURE);
while (idx < sizeof(buf) - 1) {
if (fread(buf + idx, 1, 1, fh) != 1)
_exit(EXIT_FAILURE);
idx++;
if (buf[idx-1] == '\n')
break;
}
buf[idx + 1] = '\0';
write(pipefd[1], buf, idx);
close(pipefd[1]);
_exit(EXIT_SUCCESS);
}
static
void read_from_pipe()
{
char buf;
while (read(pipefd[0], &buf, 1) > 0)
putchar(buf);
close(pipefd[0]);
}
int main(int argc, char *argv[])
{
const char* textmsg = "P1 SA HLASI KU SLUZBE!";
pid_t child;
sigemptyset(&sset);
sigaddset(&sset, SIGUSR1);
sigprocmask(SIG_BLOCK, &sset, NULL);
if (pipe(pipefd) < 0) {
perror("Failed to create pipe");
exit(EXIT_FAILURE);
}
puts(textmsg);
child = fork();
if (child < 0) {
perror("Forking failed");
exit(EXIT_FAILURE);
}
if (child == 0) {
write_to_pipe();
} else {
close(pipefd[1]);
kill(child, SIGUSR1);
read_from_pipe();
wait(NULL);
}
puts("All done");
return EXIT_SUCCESS;
}
#define _POSIX_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
int fd, P1;
char input[151];
void handler(int signum)
{
write(P1, input, strlen(input));
}
int main(int argc, char *argv[])
{
fd = open("p1.txt", O_RDONLY);
char buffer;
int lenght = 0;
while (1)
{
read(fd, &buffer, 1);
input[lenght] = buffer;
input[lenght + 1] = '\0';
if (buffer != '\n')
{
lenght++;
}
else
{
break;
}
}
P1 = atoi(argv[1]);
(void)signal(SIGUSR1, handler);
const char* textmsg = "P1 SA HLASI KU SLUZBE!";
printf("%s\n", textmsg);
kill(getppid(), SIGUSR1);
while (1)
{
sleep(5);
}
return (0);
}
Nedělej ten zápis v signal handleru. V tom hlavním cyklu prostě počkej na signál a až dorazí, tak proveď zápis.
getc je pro použití s FILE*, ne s fd (to ti překladač neřve?). A máš zapsat jen jedno slovo.
Nechtěl jste místo getppid použít getpid?
#define _POSIX_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
int fd, P1;
void handler(int signum)
{
char buff[151], c;
size_t i;
for (i = 0; (c = getc(fd)) != EOF; i++) {
buff[i] = c;
}
buff[i+1] = '\0';
write(P1, buff, strlen(buff));
}
int main(int argc, char *argv[])
{
fd = open("p1.txt", O_RDONLY);
(void)signal(SIGUSR1, handler);
P1 = atoi(argv[1]);
const char* textmsg = "P1 SA HLASI KU SLUZBE!";
printf("%s\n", textmsg);
kill(getppid(), SIGUSR1);
while (1)
{
sleep(5);
}
return 0;
}
Tak to snad je webassembly, ne? To je i snad ten duvod, proc je takovy rozmach jazyku co se umi kompilovat do "webu". (jsem Javista, takze me napada Kotlin)
Pro vývoj webu bych se vyhnul všemu, co je typováno staticky.
//
Co lepsiho bylo k php a js? Imho to neposuzujes komplexne.No tak tohle je zrovna špatný příklad. JS se používá naopak právě proto, že nic jiného v prohlížečích pro skripty není. A také to není důkaz jeho "kvality".
JS se používá naopak právě proto, že nic jiného v prohlížečích pro skripty není,... v prohlížečích se používa JS, protože práve není nič lepšího čo by v prohlížečích mohlo bežať.
(Ale není. (Složitá. (Ta syntaxe. (Těch jazyků. (Programovacích.)))))a to jako píšeš tie zátvorky náhodne? toto nemá logiku... zato zátvorky v Céčku, JS, Scale, Go, atd, zmysel majú.
Tohle jsou lispové závorky. Lisp to normálně akceptuje jako platný výraz. Vyzkoušeno.
(Ale není. (Složitá. (Ta syntaxe. (Těch jazyků. (Programovacích.)))))
Podle mne je u naprosté většiny programovacích jazyků syntaxe naopak velice jednoduchá! Mám spíše dojem, že programovací jazyky, které se snaží podobat mluvenému lidskému slovu jsou mnohem méně přehledné a tudíž hůře čitelné.
Protoze pak neni ta metoda ten chliv, co jsi poslal, ale neco, co se da precist a pochopit.
takže podľa tebe je jednoduchšie povedať "chcem dolnú časť žemle hamburgeru na ňom kurací rezeň, a na ňom hornú časť žemle hamburgeru" než "chcem kurací hamburger", to je teda fajn logika. Čitatelnejšie to o nič nieje, a ani to nepotrebuješ. Predsa si hamburger kupuješ ako celok. Obsah hamburgeru zaujíma len zamestnanca mcdonalda, ktorý ale vytvára celistvý "produkt" teda hamburger.
Ne, konzument API samozrejme rika "chci burger".
Ale ta implementace musi byt rozdelena na male kusy, kazdy citelny a kazdy spravne pojmenovany. Aby to pak vypadalo zhrubaKód: [Vybrat]burger =
(horni, dolni) <- houskaNaPul
return Burger(horni, okurka, maso, dolni)
private okurka = ...
private maso = ...
To tvoje je spisKód: [Vybrat]burger =
police <- najdiPolici
housky <- police.prihradky.findFirst(\p -> p.maObrazekHousty)
houstka <- houstky.vemJednu()
if (houstka == NULL) ....
...
...
Pojmenovani jednotlivych casti ma smysl, prestoze nejsou znovupouzitelne. Kdyz to udelas, tak se stane jasne, co se deje (burger je z pulek houstky, okurky a masa), aniz by se musel nekdo prehrabovat v nejakem storadkovem bordelu.
Nemluve o tom, ze ty male pojmenovatelne casti mohou byt napr. samostatne testovatelne (coz muze i nemusi byt dobry napad vyuzit).