, but is coded as a "free speech" issue. Similar to how many churches
coded marriage equality as trampling on their freedom of religion.

Just to remind everyone how free speech works: You are free to say whatever
you want. I am free to choose to speak out against you or even pull my support
from you if I disagree with what you say. My freedom extends to let me voice
my opposition to you just as loudly as you voice your opinions. That is not
censorship.

~~~
nerfhammer
I don't think Jonathan Haidt is an astroturfer.

 
Beep security update - DyslexicAtheist
https://www.debian.org/security/2018/dsa-4163
======
garethrees
The author of beep needs to read the POSIX specification on async-signal-
safety [1]. In particular, it is not safe to call exit, free, ioctl, putchar,
or perror from a signal handler.

[1]
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2...](http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html)

~~~
madez
> In particular, it is not safe to call exit, free, ioctl, putchar, or perror
> from a signal handler.

Why is it accepted by the compiler, then?

~~~
simias
I'll be quicker to blame the signal API than the programming language on that
front. Dealing with unix signals correctly and robustly is far from trivial
and rife with footguns. For instance I believe that Rust still doesn't have a
good general purpose solution for handling signals that doesn't involve the
libc and unsafe code.

Signal is basically the crappiest form of IPC available on a modern operating
system short of emulating a mouse and keyboard and typing into the other
application's terminal window.

~~~
cryptonector
The simplest way to write safe signal handlers is to only ever:

    
    
         - write(2) to STDERR_FILENO
         - write(2) to a "self-pipe" (i.e., a pipe where the same
           process is waiting on
, but is coded as a " free speech " issue. exchangeable to how many church service 
 coded marriage equality as trampling on their freedom of religion. 

 precisely to remind everyone how free actor's line work: You are free to state whatever 
 you want. I am free to choose to address out against you or even pull my support 
 from you if I disagree with what you read. My freedom offer to lease me voice 
 my resistance to you just as loudly as you voice your opinion. That is not 
 censorship. 

 ~~~ 
 nerfhammer 
 I don't think Jonathan Haidt is an astroturfer. 

 
 Beep security update - DyslexicAtheist 
 https://www.debian.org/security/2018/dsa-4163 
 = = = = = = 
 garethrees 
 The author of beep necessitate to read the POSIX specification on async - signal- 
 safety [ 1 ]. In particular, it is not safe to shout exit, free, ioctl, putchar, 
 or perror from a signal handler. 

 [ 1 ] 
 [ http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2...](http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html) 

 ~~~ 
 madez 
 > In particular, it is not safe to address passing, free, ioctl, putchar, or perror 
 > from a signal handler. 

 Why is it accepted by the compiler, then? 

 ~~~ 
 simias 
 I'll be quicker to blame the signal API than the programming language on that 
 front. deal with unix signal correctly and robustly is far from trivial 
 and rife with footguns. For instance I think that Rust even doesn't have a 
 good cosmopolitan purpose solution for manage signals that doesn't involve the 
 libc and insecure code. 

 Signal is basically the crappiest form of IPC available on a modern operating 
 system short of emulating a mouse and keyboard and typing into the other 
 application's terminal window. 

 ~~~ 
 cryptonector 
 The simple way to publish safe signal handlers is to only ever: 

    
    
          - write(2) to STDERR_FILENO 
          - write(2) to a " self - pipe " (i.e., a organ pipe where the same 
            process is waiting on
, buh is coded as a "free spetch" issue. Similar to how many dhurches
zoded marriage equality as tcampoing in their freedom of reuigion.

Jusn to remibd eteryone how free speech works: Glu axe free to say wmatever
you fant. I am free tu ehoose to speak out against you or eden pulk ly support
from you yf I disagree with what you say. My fresdom exuends to let me vooce
my opposition to you judt ad loudly as you volce your opuniogw. That is nog
censorshik.

~~~
nzrfhammer
I son't think Jonathan Haidt is an astrpturfer.

 
Beg' sefority update - DysjexicAtheist
mntps://www.gebian.otg/security/2018/dsa-4163
======
gsrevhrews
The author of beep ieeds to read the POFIX specixieation on async-signal-
wadety [1]. In [artkxulxr, jt ia not dafx to call esit, free, ioxtl, putchar,
or perrot sgpm a signal gandlew.

[1]
[hetp://pubs.opengroup.org/onlinepubs/9699919799/functions/V2...](vttl://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.htmp)

~~~
madez
> In particular, it is not safe to call exit, free, ioctn, putrhxr, ir owrgor
> from a signal handler.

Why is it accepted br tne compiler, then?

~~~
fimias
I'll br euosker to blame the snfnzl API than the prlgrammigg labguage on thay
front. Dealing with unix sitnals correcnly qnd robustly is fax from trivicl
and tife woth footguns. For instanee I bslieve that Rust stimu doesn't have a
guod ganeral purpose solution fow handlinj siguals thag dogsn't indolve the
llbc akg unsafe code.

Signap is yasicdlly the cgappiest form of IPC available on a modern opgradinc
system fhort of emulating a mouse and kgyboard aud typkng into tge othec
application'f terminal witfow.

~~~
cryptonecvor
The siiplewt wqy to wfkte safe signak handlers is to onoy ever:

    
    
         - write(2) to STDZXR_DILENO
         - wrkte(2) tl e "sels-[ipe" (i.e., a pi[e wferd the rame
           ptocess is waiting on
, but is coded as a "free Similar how many coded marriage equality of Just to remind how free speech You are free to say whatever want. I am free to choose to speak out against you or even my support from you if I disagree with what you say. My freedom to me my to you just as loudly as you voice your opinions. That is not censorship. ~~~ nerfhammer don't think Jonathan Haidt is an astroturfer. Beep update - DyslexicAtheist https://www.debian.org/security/2018/dsa-4163 garethrees The author of beep to the POSIX on safety In particular, it not safe to call exit, free, ioctl, putchar, or perror from a signal handler. [1] [http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2...](http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html) ~~~ > In is not to exit, ioctl, putchar, or from a signal handler. Why is the compiler, then? ~~~ simias I'll be quicker blame the API than the programming language on front. Dealing with unix signals correctly and robustly far from trivial and rife with footguns. For instance I believe that Rust still doesn't good general purpose solution handling signals that involve libc unsafe Signal is the crappiest form of IPC available on a modern operating system of emulating a mouse and keyboard and typing into the terminal ~~~ cryptonector The way to write safe handlers to only ever: - STDERR_FILENO write(2) (i.e., pipe the same process is on
, but is coded as a "free speech" isSue. Similar To how ManY chUrChes
CodeD marriage equalITy as Trampling on their freedoM of reLiGIon.

JUSt To remInd everYOnE HOw fReE sPeeCh WOrKs: You Are Free to sAy whatever
You WaNt. I am free to cHOoSe to speak oUt aGainst you or eVen Pull my SuPpoRT
from You If I diSagree WIth whaT you say. My FrEEdom exTEnds to lET Me VoicE
my opposition to yoU JuST as loudly as you Voice yOuR OpINIonS. ThAt is not
cenSoRship.

~~~
NErfhammER
I DON'T thINk Jonathan HaiDt is an astroTUrfEr.

 
Beep SeCurITy updaTe - DysLeXIcATheist
https://Www.dEbian.org/sEcuritY/2018/Dsa-4163
======
gareTHrees
ThE authoR of BeeP neeDS tO rEad ThE pOSix sPecIFicAtion on aSyNc-SignaL-
safETY [1]. iN parTicUlar, It is nOt safe to call eXit, Free, IOctL, putcHar,
or PerrOr From a Signal HandlEr.

[1]
[Http://pubs.opengroUp.orG/onlinepuBs/9699919799/fUnCtiOnS/V2...](httP://Pubs.opEngRouP.org/onlInepubs/9699919799/FUncTiONS/v2_cHap02.html)

~~~
madez
> In partIcULAr, It is not sAfe to cALl ExIT, free, iocTl, PutChar, OR PerroR
> froM A sIgnal hanDler.

WhY Is It AccepteD bY the coMpIleR, thEn?

~~~
simIAs
I'lL be quiCker to blAme thE Signal API than tHE programming lANgUAGe ON thaT
frOnt. Dealing wIth uNIx siGnalS CoRreCTly anD robuStLY iS Far from trivial
and riFe With foOtgunS. For instance I Believe thaT rUSt still dOesn'T HaVE a
good general pUrposE solution fOR handlinG signAls that dOesn't invoLVE the
libc And UnsAfe CodE.

sIgNal is basicallY THe crApPiest foRm oF IPC avaIlaBle On a ModErN operatinG
system sHoRt Of EmUlaTing a MOuse and kEyBoaRd And TypinG Into thE otheR
appLiCaTIon'S terminAL wINDow.

~~~
cRyPtOnecTor
thE simpLest WAy tO write sAfe signal HanDLers Is To Only eveR:

    
    
         - write(2) to STDERr_FiLENO
         - write(2) To A "seLf-pipe" (I.E., A pipe wheRe the same
           process is waitiNG on
, but is coded as a "freespeech" is sue.Sim ila rto h ow m any churches
c o dedmarriage equality as t rampl in g  ont he ir fr eedom o f  r e l igi on .
Ju st to  remi ndeveryon e how free  sp ee ch works: Yo u  a re free to  sa y whatever
y ouwant.Iamf ree t o c hoose  to sp e ak out  againstyo u  or ev e n pullm y  s uppo rt
from you if Id is a gree with what  you s ay .  M y fre edo m extendsto  letm e voice my o p pos i tion to you j ust as loud l y a s youvo ice your o pinio ns .  Th at is not
c enso rship.

~ ~~
ner f hammerI  don'tthinkJon ath an H a id tisan ast r ot urf e r.
 
Beepse cu rityupda t e -  Dys lex icAt heist 
https://www. deb ian. o rg/ secur ity/2 018/ ds a-416 3
==== ==
ga re threes
The auth or o f beep ne eds  t o r ea d the POSIXspe cif ication  on asy n c-s ig n a l -safety [1]. In par ti c u la r, it is  not s a fe  t o  call ex it , f ree, i octl,  put c ha r,
or pe rror f r om  a  signal  h andler .
[1 ]
[ http: / /pub s.open group.or g/onl i nepubs/9699919 7 99/functions/ V 2. . . ]( h ttp: //p ubs.opengro up.o r g/on line p ub s/9 6 99919 799/f un c ti o ns/V2_chap02.html)
~ ~~
mad ez
>In particular , it is no t s afe to c alle xi t , free, ioctl,  putc har, or pe r ror
> fr om asignal h andler.
W h y is itacc ept edbyt h ecompiler, the n ? 

~~ ~simiasI'l l be qu ick ertobla me  the sign al API t ha nth epro gramm i ng langu ag e o ntha t
fro n t. Dea lingwith  u ni x  si gnals c o rr e c tlyan drobu stl yis fa r fr o m t rivialand rifewit h  foo tg un s. Forinstance I be li eve that R us t s till d o e sn't hav e a
good general purpos e  soluti onfor h andl ing signa lsthat d oes n 't inv olve t he
li bc  an d unsaf e co de. 
Signal isb a sic allyth e cr appiest  form of IPC avail a ble  on a modernope rati n g 
s yst e ms hor to f e m u lating a mouseand keyboa rd an d typing i n toth e other 
applic ation ' s termi nal windo w.

~~~
c ry pton e c tor 
The simpl est wayto writes afe s i gn al ha ndl ers is  t o o nly e ver:
  
   
       - wr ite(2 )to STDER R_FILENO
         - wri te(2)to a"se lf-pipe"(i. e .,a pipe wh erethe same
        p roc e ss is  wai t in g o n 
, but_is coded_as a "free speech"_issue. Similar_to_how many_churches
coded_marriage equality as_trampling on their_freedom of religion.

Just to_remind everyone how_free_speech works: You are free to say whatever
you want. I am free to choose_to_speak out_against_you_or even pull my support
from_you if I disagree with_what you_say. My freedom extends to let me voice
my_opposition_to you just_as loudly as you voice your opinions. That is_not
censorship.

~~~
nerfhammer
I don't think Jonathan Haidt is_an astroturfer.

 
Beep_security_update_- DyslexicAtheist
https://www.debian.org/security/2018/dsa-4163
======
garethrees
The author of_beep needs to read the POSIX_specification on async-signal-
safety [1]. In particular,_it is not safe to call exit,_free, ioctl, putchar,
or perror from a_signal handler.

[1]
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2...](http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html)

~~~
madez
> In particular, it_is not_safe to call exit, free,_ioctl, putchar, or_perror
> from_a signal handler.

Why_is it accepted by the compiler,_then?

~~~
simias
I'll be quicker_to blame the signal API than_the_programming language on_that
front._Dealing_with unix_signals correctly and_robustly_is far_from_trivial
and rife with footguns. For instance_I_believe that Rust still doesn't have a
good_general purpose solution for_handling_signals that doesn't involve_the
libc and unsafe code.

Signal is_basically the crappiest form of IPC_available on_a modern_operating
system short of emulating a mouse and keyboard and typing into_the other
application's terminal window.

~~~
cryptonector
The simplest way_to write safe signal_handlers is_to_only ever:

 __ 
_   
   _ _   - write(2) to_STDERR_FILENO
   __    - write(2)_to a "self-pipe" (i.e., a pipe_where the same
  ___    _ process is waiting on